TensorFlow pildiklassifikatsioon: kõik, mida peate teadma ehituse klassifikaatorite kohta

See TensorFlow pildiklassifikatsiooni artikkel annab teile üksikasjaliku ja põhjaliku teabe piltide klassifitseerimise kohta.

Piltide klassifitseerimine - ülesanne, mille isegi beebi saab teha sekunditega, kuid masina jaoks on see olnud raske ülesanne kuni viimaste edusammudeni ja Sügav õppimine . Isesõitvad autod suudavad esemeid tuvastada ja reaalajas vajalikke toiminguid teha ning suurem osa sellest on võimalik tänu sellele Piltide klassifikatsioon. Selles artiklis juhendan teid järgmiste teemade kaudu:



Mis on TensorFlow?

TensorFlow on Google'i avatud lähtekoodiga masinõppe raamistik andmevoo programmeerimiseks paljude ülesannete jaoks. Graafikus olevad sõlmed tähistavad matemaatilisi toiminguid, graafi servad aga nende vahel edastatud mitmemõõtmelisi andmemassiive.

TensorFlow-Image-Recognition
Tensorid on lihtsalt mitmemõõtmelised massiivid, kahemõõtmeliste tabelite laiendus suurema mõõtmega andmetele. Tensorflow'l on palju funktsioone, mis muudavad selle süvaõppeks sobivaks ja see on avatud lähtekoodiga kogu, mis aitab teil välja töötada ja koolitada ML-mudeleid.

Mis on piltide klassifikatsioon?

Piltide klassifitseerimise eesmärk on kategoriseerida kõik digitaalse pildi pikslid ühte mitmest maakatte klassides või teemad . Seejärel saab neid kategoriseeritud andmeid toota temaatilised kaardid pildil oleva maakatte osa.



viske ja java visete vahe

Nüüd, sõltuvalt analüütiku ja arvuti suhtlemisest klassifitseerimise ajal, on kahte tüüpi klassifikatsiooni:



  • Juhendatud ja
  • Järelevalveta

Niisiis, hüpates aega raiskamata, jätkame TensorFlow pildiklassifikatsiooni. Mul on 2 näidet: lihtne ja raske. Jätkame lihtsamat.

TensorFlow pildiklassifikatsioon: mood MNIST

Mood MNIST andmekogum

Siinkohal hakkame kasutama Fashion MNISTi andmekogumit, mis sisaldab 70 000 halltooni pilti 10 kategoorias. Koolituseks kasutame 60000 ja testimiseks ülejäänud 10000. Fashion MNIST-ile pääseb otse teenusest TensorFlow, lihtsalt importige ja laadige andmed.

  • Impordime kõigepealt raamatukogud
alates __future__ impordi absoluutne_import, jagamine, printimisfunktsioon # TensorFlow ja tf.keras impordivad tensorflow tf-na tensorflow-impordi keradest
  • Laadime andmed
mood_mnist = keras.datasets.fashion_mnist (rongi_pildid, rongi sildid), (test_images, test_labels) = mood_mnist.load_data ()
  • Järgmisena kaardistame pildid klassidesse
klassi_nimed = ['T-särk / top', 'Püksid', 'Pullover', 'Kleit', 'Mantel', 'Sandaal', 'Särk', 'Toss', 'Kott', 'Hüppesaabas']
  • Andmete uurimine
rongipildid.kuju 
#Iga silt on vahemikus 0–9
rongi sildid 
test_images.kuju
  • Nüüd on aeg andmeid eeltöödelda.
plt.joonis() plt.imshow(rongipildid[0]) plt.värviriba() plt.ruudustik(Vale) plt.saade() 
#Kui kontrollite treeningukomplekti esimest pilti, näete, et pikslite väärtused langevad vahemikku 0 kuni 255.

  • Neuraalvõrku toomiseks peame pilte mõõtkavas 0–1 suurendama
rongipildid = rongipildid / 255,0 test_images = test_images / 255,0
  • Kuvame mõned pildid.
plt.joonis(figsize=(10,10)) jaoks i aastal vahemik(25): plt.alamkrunt(5,5,i+üks) plt.pikad([]) plt.yticks([]) plt.ruudustik(Vale) plt.imshow(rongipildid[i], cmap=plt.cm.binaarne) plt.xlabel(klassi_nimed[rongi sildid[i]]) plt.saade()
 

  • Paigaldage kihid
mudel = raske.Järjestikune([ raske.kihid.Tasandage(sisendi_kuju=(28, 28)), raske.kihid.Tihe(128, aktiveerimine=tf.nr.relu), raske.kihid.Tihe(10, aktiveerimine=tf.nr.softmax) ])
  • Koosta mudel
mudel.koostama(optimeerija='adam', kaotus='hõre_kategooriline_krossentroopia', mõõdikud=['täpsus'])
  • Mudelikoolitus
mudel.sobib(rongipildid, rongi sildid, ajastud=10)

  • Täpsuse hindamine
test_loss, test_acc = mudel.hinnata(test_images, test_labels) printida('Testi täpsus:', test_acc)

  • Ennustuste tegemine
ennustused = mudel.ennustada(test_images)
ennustused[0]

Ennustus on 10 numbri massiiv. Need kirjeldavad mudeli “enesekindlust”, et pilt vastab igale kümnele erinevale rõivaesemele. Näeme, millisel sildil on kõrgeim usaldusväärtus.

nt..argmax(ennustused[0])#Model on kõige kindlam, et see on poolsaapas. Vaatame, kas see on õige

Väljund: 9

test_labels[0]

Väljund: 9

  • Nüüd on aeg vaadata kogu 10 kanali komplekti
def plot_image(i, ennustused_vajutus, true_label, img): ennustused_vajutus, true_label, img = ennustused_vajutus[i], true_label[i], img[i] plt.ruudustik(Vale) plt.pikad([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binaarne) ennustatud_märgis = nt..argmax(ennustused_vajutus) kui ennustatud_märgis == true_label: värv = 'roheline' muud: värv = 'võrk' plt.xlabel('{} {: 2.0f}% ({}) '.vormingus(klassi_nimed[ennustatud_märgis], 100*nt..max(ennustused_vajutus), klassi_nimed[true_label]), värv=värv) def plot_value_array(i, ennustused_vajutus, true_label): ennustused_vajutus, true_label = ennustused_vajutus[i], true_label[i] plt.ruudustik(Vale) plt.pikad([]) plt.yticks([]) see krunt = plt.baar(vahemik(10), ennustused_vajutus, värv='# 777777') plt.ylim([0, üks]) ennustatud_märgis = nt..argmax(ennustused_vajutus) see krunt[ennustatud_märgis].set_color('võrk') see krunt[true_label].set_color('roheline')
  • Vaatame kõigepealt 0 ja 10 pilti
i = 0 plt.joonis(figsize=(6,3)) plt.alamkrunt(üks,2,üks) plot_image(i, ennustused, test_labels, test_images) plt.alamkrunt(üks,2,2) plot_value_array(i, ennustused, test_labels) plt.saade()

i = 10 plt.joonis(figsize=(6,3)) plt.alamkrunt(üks,2,üks) plot_image(i, ennustused, test_labels, test_images) plt.alamkrunt(üks,2,2) plot_value_array(i, ennustused, test_labels) plt.saade()

  • Nüüd joonistame mitu pilti ja nende ennustusi. Õiged on rohelised, valed aga punased.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.joonis(figsize=(2*2*num_cols, 2*num_rows)) jaoks i aastal vahemik(num_images): plt.alamkrunt(num_rows, 2*num_cols, 2*i+üks) plot_image(i, ennustused, test_labels, test_images) plt.alamkrunt(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, ennustused, test_labels) plt.saade()

  • Lõpuks kasutame koolitatud mudelit ühe pildi prognoosimiseks.
# Haarake testandmete kogumist pilt img = test_images[0] printida(img.kuju)
# Lisage pilt partiisse, kus see on ainus liige. img = (nt..laienda_dime(img,0)) printida(img.kuju)
ennustused_üksik = mudel.ennustada(img) printida(ennustused_üksik)

java operaatori võimule
plot_value_array(0, ennustused_üksik, test_labels) plt.pikad(vahemik(10), klassi_nimed, pöörlemine=Neli, viis) plt.saade()

  • Nagu näete meie ainsa pildipaketi ennustust.
ennustus_tulemus = nt..argmax(ennustused_üksik[0])

Väljund: 9

CIFAR-10: CNN

Andmekogum CIFAR-10 koosneb lennukitest, koertest, kassidest ja muudest objektidest. Eeltöödeldakse pilte ja koolitatakse kõigi proovide jaoks konvolutsiooniline närvivõrk. Kujutised tuleb normaliseerida ja sildid ühe kuumaga kodeerida. See kasutusjuht kõrvaldab kindlasti teie kahtlused TensorFlow pildiklassifikatsiooni osas.

  • Andmete allalaadimine
alates urllib.request import urlretrieve alates os. rada import isfile, on tahma alates tqdm import tqdm import tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klass DownloadProgress(tqdm): viimane_blokk = 0 def konks(ise, block_num=üks, ploki_suurus=üks, kokku_suurus=Puudub): ise.kokku = kokku_suurus ise.värskendus((block_num - ise.viimane_blokk) * ploki_suurus) ise.viimane_blokk = block_num » kontrollige, kas andmete (zip) fail on juba alla laaditud kui ei, laadige see alla saidilt https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz ja salvestage nimega cifar-10-python.tar.gz » kui mitte isfile('cifar-10-python.tar.gz'): koos DownloadProgress(üksus='B', unit_scale=Tõsi, miniters=üks, kirjeldus=„CIFAR-10 andmekogum”) as pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.konks) kui mitte on tahma(cifar10_dataset_folder_path): koos tarfile.avatud('cifar-10-python.tar.gz') as tõrv: tõrv.extractall() tõrv.Sulge()
  • Vajalike raamatukogude importimine
import hapukurk import numpy as nt. import matplotlib.pyplot as plt
  • Andmete mõistmine

Algne andmepartii on 10000 × 3072 tensor, väljendatuna numpy massiivis, kus 10000 on prooviandmete arv. Pilt on värviline ja suurusega 32 × 32. Söötmist saab teha kas kujul (laius x kõrgus x num_kanal) või (arv_kanal x laius x kõrgus). Määratleme sildid.

def laadige sildi_nimed(): tagasi ['lennuk', 'auto', 'lind', 'kass', 'hirv', 'koer', 'konn', 'hobune', 'laev', 'veoauto']
  • Andmete ümberkujundamine

Andmeid kujundame ümber kahes etapis

Esiteks jagage reavektor (3072) 3 tükiks. Iga tükk vastab igale kanalile. Selle tulemuseks on (3 x 1024) tensori mõõde. Seejärel jagage saadud tensor eelmisest etapist punktiga 32. 32 tähendab siin pildi laiust. Selle tulemuseks on (3x32x32).

Teiseks peame andmed üle kandma (num_kanal, laius, kõrgus) asendisse (laius, kõrgus, num_kanal). Selleks hakkame kasutama transponeerimisfunktsiooni.

def load_cfar10_batch(cifar10_dataset_folder_path, partii_id): koos avatud(cifar10_dataset_folder_path + '/ data_batch_' + lk(partii_id), režiimis='rb') as faili: # note, kodeerimise tüüp on 'latin1' partii = hapukurk.koormus(faili, kodeerimine='ladina1') Funktsioonid = partii['andmed'].ümber kujundama((len(partii['andmed']), 3, 32, 32)).üle võtma(0, 2, 3, üks) sildid = partii['sildid'] tagasi Funktsioonid, silt
  • Andmete uurimine
def display_stats(cifar10_dataset_folder_path, partii_id, näidis_id): Funktsioonid, sildid = load_cfar10_batch(cifar10_dataset_folder_path, partii_id) kui mitte (0 <= näidis_id < len(Funktsioonid)): printida('{}partiid{}.{}on vahemikust väljas. '.vormingus(len(Funktsioonid), partii_id, näidis_id)) tagasi Puudub printida(' Partii statistika{}: '.vormingus(partii_id)) printida('Proovide arv:{} '.vormingus(len(Funktsioonid))) silt_nimed = laadige sildi_nimed() silt_arvud = dikteerima(tõmblukk(*nt..ainulaadne(sildid, return_counts=Tõsi))) jaoks võti, väärtus aastal silt_arvud.esemed(): printida('Siltide arv{}] ({}):{}'.vormingus(võti, silt_nimed[võti].ülemine(), väärtus)) näidis_pilt = Funktsioonid[näidis_id] näidissilt = sildid[näidis_id] printida(' Näide pildist{}: '.vormingus(näidis_id)) printida('Pilt - minimaalne väärtus:{}Maksimaalne väärtus:{}'.vormingus(näidis_pilt.min(), näidis_pilt.max())) printida('Pilt - kuju:{}'.vormingus(näidis_pilt.kuju)) printida('Silt - sildi ID:{}Nimi:{}'.vormingus(näidissilt, silt_nimed[näidissilt])) plt.imshow(näidis_pilt)
%matplotlib järjekorras %konfig Sisseehitatud tagumine.joonis_vorming = 'võrkkesta' import numpy as nt. # Uurige andmekogumit partii_id = 3 näidis_id = 7000 display_stats(cifar10_dataset_folder_path, partii_id, näidis_id)

  • Eeltöötlusfunktsioonide rakendamine

Andmed normaliseerime Min-Maxi normaliseerimise kaudu. See paneb kõik x väärtused lihtsalt vahemikku 0 kuni 1.
y = (x-min) / (max-min)

def normaliseerima(x): » argument - x: sisestatud pildiandmed numpy massiivis [32, 32, 3] tagasi - normaliseeritud x » min_val = nt..min(x) max_val = nt..max(x) x = (x-min_val) / (max_val-min_val) tagasi x
  • Üks kuum kodeerimine
def one_hot_encode(x): » argument - x: siltide loend tagasi - üks kuuma kodeerimise maatriks (siltide arv, klassi arv) » kodeeritud = nt..nullid((len(x), 10)) jaoks idx, tunnid aastal loendama(x): kodeeritud[idx] [tunnid] = üks tagasi kodeeritud
  • Andmete eeltöötlus ja salvestamine
def _preprocess_and_save(normaliseerima, one_hot_encode, Funktsioonid, sildid, faili nimi): Funktsioonid = normaliseerima(Funktsioonid) sildid = one_hot_encode(sildid) hapukurk.prügimägi((Funktsioonid, sildid), avatud(faili nimi, 'wb')) def eeltöötlus_ja_salvestusandmed(cifar10_dataset_folder_path, normaliseerima, one_hot_encode): n_partiid = 5 kehtivad_omadused = [] kehtivad sildid = [] jaoks partii_i aastal vahemik(üks, n_partiid + üks): Funktsioonid, sildid = load_cfar10_batch(cifar10_dataset_folder_path, partii_i) # leida indeks, mis on valideerimisandmetena punkt kogu partii andmekogumis (10%) index_of_validation = int(len(Funktsioonid) * 0,1) # eeltöödelda 90% kogu partii andmekogumist # - funktsioonide normaliseerimine # - one_hot_encode sildid # - salvesta uude faili nimega 'preprocess_batch_' + partii_number # - iga fail iga partii kohta _preprocess_and_save(normaliseerima, one_hot_encode, Funktsioonid[:-index_of_validation], sildid[:-index_of_validation], 'preprocess_batch_' + lk(partii_i) + '.p') # erinevalt koolituse andmekogust lisatakse valideerimisandmete kogu pakettandmekogumi kaudu # - võtke 10% kogu andmepaketist # - lisage need loendisse # - kehtivad_omadused # - kehtivad sildid kehtivad_omadused.pikendada(Funktsioonid[-index_of_validation:]) kehtivad sildid.pikendada(sildid[-index_of_validation:]) # eeltöödelda kõik virnastatud valideerimisandmed _preprocess_and_save(normaliseerima, one_hot_encode, nt..massiiv(kehtivad_omadused), nt..massiiv(kehtivad sildid), 'preprocess_validation.p') # laadige testi andmekogum koos avatud(cifar10_dataset_folder_path + '/ test_batch', režiimis='rb') as faili: partii = hapukurk.koormus(faili, kodeerimine='ladina1') # testimisandmete eeltöötlus test_funktsioonid = partii['andmed'].ümber kujundama((len(partii['andmed']), 3, 32, 32)).üle võtma(0, 2, 3, üks) test_labels = partii['sildid'] # Eeltöödelda ja salvestada kõik testimisandmed _preprocess_and_save(normaliseerima, one_hot_encode, nt..massiiv(test_funktsioonid), nt..massiiv(test_labels), 'preprocess_training.p')
eeltöötlus_ja_salvestusandmed(cifar10_dataset_folder_path, normaliseerima, one_hot_encode)
  • Kontrollpunkt
import hapukurk kehtivad_omadused, kehtivad sildid = hapukurk.koormus(avatud('preprocess_validation.p', režiimis='rb'))
  • Võrgustiku ülesehitamine

Kogu mudel koosneb kokku 14 kihist.

c ++ rekursiivsed fibonacci

import tensorivool as tf def conv_net(x, keep_prob): conv1_filter = tf.Muutuv(tf.kärbitud_normaalne(kuju=[3, 3, 3, 64], tähendab=0, stddev=0,08)) conv2_filter = tf.Muutuv(tf.kärbitud_normaalne(kuju=[3, 3, 64, 128], tähendab=0, stddev=0,08)) conv3_filter = tf.Muutuv(tf.kärbitud_normaalne(kuju=[5, 5, 128, 256], tähendab=0, stddev=0,08)) conv4_filter = tf.Muutuv(tf.kärbitud_normaalne(kuju=[5, 5, 256, 512], tähendab=0, stddev=0,08)) # 1, 2 konv = tf.nr.konv(x, conv1_filter, sammud=[üks,üks,üks,üks], polsterdus='SAMA') konv = tf.nr.relu(konv) conv1_pool = tf.nr.max_pool(konv, ksize=[üks,2,2,üks], sammud=[üks,2,2,üks], polsterdus='SAMA') conv1_bn = tf.kihid.partii_normaliseerimine(conv1_pool) # 3. 4 konv2 = tf.nr.konv(conv1_bn, conv2_filter, sammud=[üks,üks,üks,üks], polsterdus='SAMA') konv2 = tf.nr.relu(konv2) conv2_pool = tf.nr.max_pool(konv2, ksize=[üks,2,2,üks], sammud=[üks,2,2,üks], polsterdus='SAMA') conv2_bn = tf.kihid.partii_normaliseerimine(conv2_pool) # 5, 6 konv3 = tf.nr.konv(conv2_bn, conv3_filter, sammud=[üks,üks,üks,üks], polsterdus='SAMA') konv3 = tf.nr.relu(konv3) conv3_pool = tf.nr.max_pool(konv3, ksize=[üks,2,2,üks], sammud=[üks,2,2,üks], polsterdus='SAMA') conv3_bn = tf.kihid.partii_normaliseerimine(conv3_pool) # 7, 8 konv4 = tf.nr.konv(conv3_bn, conv4_filter, sammud=[üks,üks,üks,üks], polsterdus='SAMA') konv4 = tf.nr.relu(konv4) conv4_pool = tf.nr.max_pool(konv4, ksize=[üks,2,2,üks], sammud=[üks,2,2,üks], polsterdus='SAMA') conv4_bn = tf.kihid.partii_normaliseerimine(conv4_pool) # 9 tasane = tf.kaastöö.kihid.tasane(conv4_bn) # 10 täis1 = tf.kaastöö.kihid.täielikult_ühendatud(sisendid=tasane, arv_väljundid=128, activation_fn=tf.nr.relu) täis1 = tf.nr.välja kukkuma(täis1, keep_prob) täis1 = tf.kihid.partii_normaliseerimine(täis1) # üksteist täis2 = tf.kaastöö.kihid.täielikult_ühendatud(sisendid=täis1, arv_väljundid=256, activation_fn=tf.nr.relu) täis2 = tf.nr.välja kukkuma(täis2, keep_prob) täis2 = tf.kihid.partii_normaliseerimine(täis2) # 12 täis3 = tf.kaastöö.kihid.täielikult_ühendatud(sisendid=täis2, arv_väljundid=512, activation_fn=tf.nr.relu) täis3 = tf.nr.välja kukkuma(täis3, keep_prob) täis3 = tf.kihid.partii_normaliseerimine(täis3) # 13 täis4 = tf.kaastöö.kihid.täielikult_ühendatud(sisendid=täis3, arv_väljundid=1024, activation_fn=tf.nr.relu) täis4 = tf.nr.välja kukkuma(täis4, keep_prob) täis4 = tf.kihid.partii_normaliseerimine(täis4) # 14 välja = tf.kaastöö.kihid.täielikult_ühendatud(sisendid=täis3, arv_väljundid=10, activation_fn=Puudub) tagasi välja
  • Hüperparameetrid
ajastud = 10 partii_suurus = 128 hoida_tõenäosust = 0.7 õppimise määr = 0,001
logitid = conv_net(x, keep_prob) mudel = tf.identiteet(logitid, nimi='logits') # Nimi logib Tensori, et seda saaks pärast treeningut kettalt laadida # Kaotus ja optimeerija maksumus = tf.vähendada_mean(tf.nr.softmax_cross_entropy_with_logits(logitid=logitid, sildid=Y)) optimeerija = tf.rong.AdamOptimizer(õppimise määr=õppimise määr).minimeerida(maksumus) # Täpsus õige_pred = tf.võrdsed(tf.argmax(logitid, üks), tf.argmax(Y, üks)) täpsus = tf.vähendada_mean(tf.valatud(õige_pred, tf.ujuk32), nimi='täpsus')
  • Treenige närvivõrku
# Ühe optimeerimine 
def
rongi_närvivõrk(seanss, optimeerija, hoida_tõenäosust, funktsioon_partii, silt_partii): seanss.jooksma(optimeerija, feed_dict={ x: funktsioon_partii, Y: silt_partii, keep_prob: hoida_tõenäosust })
#Showing Stats def print_stats(seanss, funktsioon_partii, silt_partii, maksumus, täpsus): kaotus = sess.jooksma(maksumus, feed_dict={ x: funktsioon_partii, Y: silt_partii, keep_prob: üks. }) kehtiv = sess.jooksma(täpsus, feed_dict={ x: kehtivad_omadused, Y: kehtivad sildid, keep_prob: üks. }) printida('Kaotus:{:> 10.4f}Valideerimise täpsus:{: .6f}'.vormingus(kaotus, kehtiv))
  • Täielik koolitus ja mudeli salvestamine
def partii_omadused_sildid(Funktsioonid, sildid, partii_suurus): » Jagage funktsioonid ja sildid partiideks » jaoks algus aastal vahemik(0, len(Funktsioonid), partii_suurus): lõpp = min(algus + partii_suurus, len(Funktsioonid)) saagikus Funktsioonid[algus:lõpp], sildid[algus:lõpp] def laadimisprotsessi_koolituse_pakett(partii_id, partii_suurus): » Laadige eeltöödeldud treeningu andmed ja tagastage need partiidena või vähem » faili nimi = 'preprocess_batch_' + lk(partii_id) + '.p' Funktsioonid, sildid = hapukurk.koormus(avatud(faili nimi, režiimis='rb')) # Tagastage treeninguandmed suuruses või vähem tagasi partii_omadused_sildid(Funktsioonid, sildid, partii_suurus)
# Mudeli ja tee salvestamine 
save_model_path
= './image_classification' printida('Koolitus ...') koos tf.Seanss() as sess: # Muutujate lähtestamine sess.jooksma(tf.global_variables_initializer()) # Treeningtsükkel jaoks ajastu aastal vahemik(ajastud): # Loop kõigi partiide üle n_partiid = 5 jaoks partii_i aastal vahemik(üks, n_partiid + üks): jaoks partii_funktsioonid, partii_ sildid aastal laadimisprotsessi_koolituse_pakett(partii_i, partii_suurus): rongi_närvivõrk(sess, optimeerija, hoida_tõenäosust, partii_funktsioonid, partii_ sildid) printida('Epohh{:> 2}, CIFAR-10 partii{}: '.vormingus(ajastu + üks, partii_i), lõpp=') print_stats(sess, partii_funktsioonid, partii_ sildid, maksumus, täpsus) # Salvesta mudel säästja = tf.rong.Säästja() save_path = säästja.salvesta(sess, save_model_path)

Nüüd on Tensorflow pildiklassifikatsiooni oluline osa valmis. Nüüd on aeg mudelit testida.

  • Mudeli testimine
import hapukurk import numpy as nt. import matplotlib.pyplot as plt alates sklearn.töötlus import LabelBinarizer def partii_omadused_sildid(Funktsioonid, sildid, partii_suurus): » Jagage funktsioonid ja sildid partiideks » jaoks algus aastal vahemik(0, len(Funktsioonid), partii_suurus): lõpp = min(algus + partii_suurus, len(Funktsioonid)) saagikus Funktsioonid[algus:lõpp], sildid[algus:lõpp] def kuva_pildi_prognoosid(Funktsioonid, sildid, ennustused, top_n_prognoosid): n_klassid = 10 silt_nimed = laadige sildi_nimed() label_binarizer = LabelBinarizer() label_binarizer.sobib(vahemik(n_klassid)) silt_id = label_binarizer.inverse_transform(nt..massiiv(sildid)) joon, teljed = plt.alamkrundid(nrows=top_n_prognoosid, ncols=2, figsize=(kakskümmend, 10)) joon.tihe_paigutus() joon.suptitle('Softmaxi ennustused', fondisuurus=kakskümmend, Y=1.1) n_ennustused = 3 marginaal = 0,05 ind = nt..arane(n_ennustused) laius = (üks. - 2. * marginaal) / n_ennustused jaoks pilt_i, (tunnusjoon, silt_id, prognoosid_indikaadid, eelmäärused) aastal loendama(tõmblukk(Funktsioonid, silt_id, ennustused.indeksid, ennustused.väärtused)): kui (pilt_i < top_n_prognoosid): eelnimed = [silt_nimed[pred_i] jaoks pred_i aastal prognoosid_indikaadid] õige_nimi = silt_nimed[silt_id] teljed[pilt_i] [0].imshow((tunnusjoon*255).astüüp(nt..int32, koopia=Vale)) teljed[pilt_i] [0].set_title(õige_nimi) teljed[pilt_i] [0].set_axis_off() teljed[pilt_i] [üks].barh(ind + marginaal, eelmäärused[:3], laius) teljed[pilt_i] [üks].set_yticks(ind + marginaal) teljed[pilt_i] [üks].set_yticklabels(eelnimed[::-üks]) teljed[pilt_i] [üks].set_xticks([0, 0.5, 1.0])
%matplotlib järjekorras %konfig Sisseehitatud tagumine.joonis_vorming = 'võrkkesta' import tensorivool as tf import hapukurk import juhuslik save_model_path = './image_classification' partii_suurus = 64 n_proovid = 10 top_n_prognoosid = 5 def test_model(): test_funktsioonid, test_labels = hapukurk.koormus(avatud('preprocess_training.p', režiimis='rb')) koormatud_graafik = tf.Graafik() koos tf.Seanss(graafik=koormatud_graafik) as sess: # Laadige mudel laadur = tf.rong.import_meta_graafik(save_model_path + '.meta') laadur.taastama(sess, save_model_path) # Hankige tensorid laaditud mudelilt koormatud_x = koormatud_graafik.get_tensor_by_name('sisend_x: 0') laetud_y = koormatud_graafik.get_tensor_by_name('output_y: 0') loading_keep_prob = koormatud_graafik.get_tensor_by_name('keep_prob: 0') koormatud_logitid = koormatud_graafik.get_tensor_by_name('logits: 0') laetud_ak = koormatud_graafik.get_tensor_by_name('täpsus: 0') # Hangi partiide täpsus mälupiirangute jaoks test_batch_acc_total = 0 test_partii_arv = 0 jaoks rongiomaduste partii, rongi sildi partii aastal partii_omadused_sildid(test_funktsioonid, test_labels, partii_suurus): test_batch_acc_total + = sess.jooksma( laetud_ak, feed_dict={koormatud_x: rongiomaduste partii, laetud_y: rongi sildi partii, loading_keep_prob: 1.0}) test_partii_arv + = üks printida('Täpsuse testimine:{} '.vormingus(test_batch_acc_total/test_partii_arv)) # Printige juhuslikud proovid juhuslikud_testifunktsioonid, juhuslikud_testi_sildid = kahekordne(tõmblukk(*juhuslik.proov(nimekirja(tõmblukk(test_funktsioonid, test_labels)), n_proovid))) juhuslikud_testiprognoosid = sess.jooksma( tf.nr.top_k(tf.nr.softmax(koormatud_logitid), top_n_prognoosid), feed_dict={koormatud_x: juhuslikud_testifunktsioonid, laetud_y: juhuslikud_testi_sildid, loading_keep_prob: 1.0}) kuva_pildi_prognoosid(juhuslikud_testifunktsioonid, juhuslikud_testi_sildid, juhuslikud_testiprognoosid, top_n_prognoosid) test_model()

Väljund: Täpsuse testimine: 0.5882762738853503

Kui nüüd treenite oma närvivõrku rohkemate ajastute jaoks või muudate aktiveerimisfunktsiooni, võite saada teistsuguse tulemuse, millel võib olla parem täpsus.

Nii jõuame sellega selle TensorFlow pildiklassifikatsiooni artikli lõppu. Olen kindel, et saate nüüd sama kasutada mis tahes piltide klassifitseerimiseks ja te pole piltide klassifitseerimise algaja.

Edureka oma koos Pythoni sertifitseerimisõppega on kureeritud valdkonna spetsialistide poolt vastavalt tööstusharu nõuetele ja nõudmistele. Saate teada sellistest mõistetest nagu funktsioon SoftMax, Autoencoderi närvivõrgud, piiratud Boltzmanni masin (RBM), Keras ja TFLearn. Kursuse on spetsiaalselt kureerinud valdkonna eksperdid reaalajas juhtumiuuringutega.