Klasifikacija slika TensorFlow: Sve što trebate znati o klasifikatorima zgrada

Ovaj članak o klasifikaciji slika TensorFlow pružit će vam detaljno i sveobuhvatno znanje o klasifikaciji slika.

Klasifikacija slika zadatak koji čak i beba može učiniti za nekoliko sekundi, ali za stroj je to bio težak zadatak do nedavnih napretka u i Duboko učenje . Samovozeći automobili mogu otkriti predmete i poduzeti potrebne radnje u stvarnom vremenu, a većina je toga moguća zbog Klasifikacija slika. U ovom članku vodit ću vas kroz sljedeće teme:

Što je TensorFlow?

TensorFlow je Googleov okvir za strojno učenje otvorenog koda za programiranje protoka podataka za niz zadataka. Čvorovi na grafikonu predstavljaju matematičke operacije, dok rubovi grafikona predstavljaju višedimenzionalne nizove podataka koji se međusobno prenose.





TensorFlow-Image-Recognition
Tenzori su samo višedimenzionalni nizovi, produžetak dvodimenzionalnih tablica na podatke s većom dimenzijom. Postoje mnoge značajke Tensorflowa što ga čini prikladnim za duboko učenje, a osnovna biblioteka s otvorenim kodom pomaže vam u razvoju i obuci ML modela.

Što je klasifikacija slika?

Namjera klasifikacije slika je kategorizirati sve piksele na digitalnoj slici u jedan od nekoliko pokrivač zemlje razreda ili teme . Ovi kategorizirani podaci tada se mogu koristiti za proizvodnju tematske karte zemljišnog pokrivača prisutnog na slici.



Sada, ovisno o interakciji analitičara i računala tijekom klasifikacije, postoje dvije vrste klasifikacije:



  • Nadzirano &
  • Bez nadzora

Dakle, bez gubljenja vremena, uskočimo u TensorFlow Classification Image. Imam 2 primjera: lagan i težak. Nastavimo s onim laganim.

Klasifikacija slika TensorFlow: Moda MNIST

Modni MNIST skup podataka

Ovdje ćemo koristiti Fashion MNIST Dataset, koji sadrži 70 000 slika u sivim skalama u 10 kategorija. Za trening ćemo upotrijebiti 60000, a ostatak 10000 za potrebe testiranja. Fashion MNIST-u možete pristupiti izravno s TensorFlow-a, samo uvezite i učitajte podatke.

  • Uvezimo prvo knjižnice
iz __future__ import absolute_import, podjela, funkcija ispisa # TensorFlow i tf.keras uvoze tensorflow kao tf iz tensorflow import keras # Pomoćne biblioteke uvoze numpy kao np import matplotlib.pyplot kao plt
  • Učitajmo podatke
fashion_mnist = keras.datasets.fashion_mnist (slike_ vlaka, oznake_vlaka), (slike_izvještaja, test_znake) = fashion_mnist.load_data ()
  • Dalje ćemo slike preslikati u razrede
class_names = ['Majica / gornji dio', 'Hlače', 'Pulover', 'Haljina', 'Kaput', 'Sandala', 'Košulja', 'Tenisica', 'Torba', 'Gležnjača']
  • Istraživanje podataka
slike_ vlaka.oblik 
# Svaka oznaka je između 0-9
oznake_vlaka 
test_ slike.oblik
  • Sada je vrijeme za prethodnu obradu podataka.
plt.lik() plt.imshow(slike_ vlaka[0])) plt.traka u boji() plt.rešetka(Lažno) plt.pokazati() 
#Ako pregledate prvu sliku u setu treninga, vidjet ćete da vrijednosti piksela padaju u rasponu od 0 do 255.

  • Moramo skalirati slike od 0-1 da bismo ih unijeli u neuronsku mrežu
slike_ vlaka = slike_ vlaka / 255,0 test_ slike = test_ slike / 255,0
  • Prikažimo neke slike.
plt.lik(shvatiti=(10,10)) za ja u domet(25): plt.podzaplet(5,5,ja+jedan) plt.xticks([]) plt.yticks([]) plt.rešetka(Lažno) plt.imshow(slike_ vlaka[ja], cmap=plt.cm.binarni) plt.xlabel(imena_razreda[oznake_vlaka[ja]]) plt.pokazati()
 

  • Postavite slojeve
model = teško.Sekvencijalno([ teško.slojevi.Poravnati(oblik_unosa=(28, 28)), teško.slojevi.Gusto(128, aktivacija=tf.br.relu), teško.slojevi.Gusto(10, aktivacija=tf.br.softmax) ]))
  • Sastavite Model
model.sastaviti(optimizator='Adam', gubitak='rijetka_kategorička_krossentropija', metrika=['točnost']))
  • Trening modela
model.pristajati(slike_ vlaka, oznake_vlaka, epohe=10)

zadana vrijednost niza u javi
  • Procjena točnosti
gubitak_testa, test_acc = model.procijeniti(test_ slike, test_labels) ispis('Ispitivanje točnosti:', test_acc)

  • Izrada predviđanja
predviđanja = model.predvidjeti(test_ slike)
predviđanja[0]

Predviđanje je niz od 10 brojeva. Oni opisuju 'samopouzdanje' modela da slika odgovara svakom od 10 različitih odjevnih predmeta. Možemo vidjeti koja oznaka ima najveću vrijednost pouzdanosti.

npr..argmax(predviđanja[0]))#Model je najsigurniji da je to gležnjača. Da vidimo je li točno

Izlaz: 9

test_labels[0]

Izlaz: 9

  • Sada je vrijeme da pogledamo cijeli set od 10 kanala
def slika_zapletke(ja, predviđanje_ niz, true_label, img): predviđanje_ niz, true_label, img = predviđanje_ niz[ja], true_label[ja], img[ja] plt.rešetka(Lažno) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binarni) predviđena_znaka = npr..argmax(predviđanje_ niz) ako predviđena_znaka == true_label: boja = 'zeleno' drugo: boja = 'neto' plt.xlabel('{} {: 2.0f}% ({}) '.format(imena_razreda[predviđena_znaka], 100*npr..maks(predviđanje_ niz), imena_razreda[true_label]), boja=boja) def niz_vrijednosti_parcele(ja, predviđanje_ niz, true_label): predviđanje_ niz, true_label = predviđanje_ niz[ja], true_label[ja] plt.rešetka(Lažno) plt.xticks([]) plt.yticks([]) ovaj zaplet = plt.bar(domet(10), predviđanje_ niz, boja='# 777777') plt.ylim([0, jedan])) predviđena_znaka = npr..argmax(predviđanje_ niz) ovaj zaplet[predviđena_znaka].set_boja('neto') ovaj zaplet[true_label].set_boja('zeleno')
  • Pogledajmo prvo 0. i 10. sliku
ja = 0 plt.lik(shvatiti=(6,3)) plt.podzaplet(jedan,2,jedan) slika_zapletke(ja, predviđanja, test_labels, test_ slike) plt.podzaplet(jedan,2,2) niz_vrijednosti_parcele(ja, predviđanja, test_labels) plt.pokazati()

ja = 10 plt.lik(shvatiti=(6,3)) plt.podzaplet(jedan,2,jedan) slika_zapletke(ja, predviđanja, test_labels, test_ slike) plt.podzaplet(jedan,2,2) niz_vrijednosti_parcele(ja, predviđanja, test_labels) plt.pokazati()

  • Sad, ucrtajmo nekoliko slika i njihova predviđanja. Ispravni su zeleni, dok su netočni crveni.
broj_redova = 5 num_cols = 3 broj_slika = broj_redova*num_cols plt.lik(shvatiti=(2*2*num_cols, 2*broj_redova)) za ja u domet(broj_slika): plt.podzaplet(broj_redova, 2*num_cols, 2*ja+jedan) slika_zapletke(ja, predviđanja, test_labels, test_ slike) plt.podzaplet(broj_redova, 2*num_cols, 2*ja+2) niz_vrijednosti_parcele(ja, predviđanja, test_labels) plt.pokazati()

  • Konačno, poslužit ćemo se istreniranim modelom za predviđanje jedne slike.
# Uzmite sliku iz testnog skupa podataka img = test_ slike[0] ispis(img.oblik)
# Dodajte sliku u skupinu u kojoj je jedini član. img = (npr..proširiti_dims(img,0)) ispis(img.oblik)
predviđanja_ pojedinačno = model.predvidjeti(img) ispis(predviđanja_ pojedinačno)

niz_vrijednosti_parcele(0, predviđanja_ pojedinačno, test_labels) plt.xticks(domet(10), imena_razreda, rotacija=Četiri pet) plt.pokazati()

  • Kao što vidite, predviđanje za našu jedinu sliku u paketu.
rezultat_predviđanja = npr..argmax(predviđanja_ pojedinačno[0]))

Izlaz: 9

CIFAR-10: CNN

Skup podataka CIFAR-10 sastoji se od zrakoplova, pasa, mačaka i drugih objekata. Prethodno ćete obraditi slike, a zatim na svim uzorcima uvježbati konvolucijsku neuronsku mrežu. Slike moraju biti normalizirane, a naljepnice moraju biti kodirane na jedan vrući način. Ovaj će vam slučaj upotrebe sigurno razjasniti sumnje u vezi s klasifikacijom slika TensorFlow.

  • Preuzimanje podataka
iz urllib.zahtjev uvoz urlretrieve iz os.put uvoz isfile, je čađa iz tqdm uvoz tqdm uvoz tarfile cifar10_dataset_folder_path = 'cifar-10-batch-py' razred DownloadProgress(tqdm): zadnji_blok = 0 def kuka(sebe, broj_bloka=jedan, veličina_bloka=jedan, ukupna_velika=Nijedna): sebe.ukupno = ukupna_velika sebe.Ažuriraj((broj_bloka - sebe.zadnji_blok) * veličina_bloka) sebe.zadnji_blok = broj_bloka '' provjerite je li datoteka podataka (zip) već preuzeta ako ne, preuzmite ga s 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' i spremite kao cifar-10-python.tar.gz '' ako ne isfile('cifar-10-python.tar.gz'): s DownloadProgress(jedinica='B', mjerna_jedinica=Pravi, miniteri=jedan, desc='Skup podataka CIFAR-10') kao pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.kuka) ako ne je čađa(cifar10_dataset_folder_path): s tarfile.otvoren('cifar-10-python.tar.gz') kao katran: katran.raspakiraj sve() katran.Zatvoriti()
  • Uvoz potrebnih knjižnica
uvoz kiseli krastavac uvoz numpy kao npr. uvoz matplotlib.pyplot kao plt
  • Razumijevanje podataka

Izvorna serija podataka je 10000 × 3072 tenzora izražena u numpy polju, gdje je 10000 broj podataka uzorka. Slika je u boji i veličine 32 × 32. Hranjenje se može obaviti u formatu (širina x visina x broj_kanala) ili (broj_kanal x širina x visina). Definirajmo oznake.

def load_label_names(): povratak ['zrakoplov', 'automobil', 'ptica', 'mačka', 'jelen', 'pas', 'žaba', 'konj', 'brod', 'kamion']
  • Preoblikovanje podataka

Podatke ćemo preoblikovati u dvije faze

Prvo podijelite vektor reda (3072) na 3 dijela. Svaki komad odgovara svakom kanalu. To rezultira (3 x 1024) dimenzijom tenzora. Zatim podijelite dobiveni tenzor iz prethodnog koraka sa 32. 32 ovdje znači širinu slike. To rezultira (3x32x32).

Drugo, moramo prenijeti podatke iz (num_channel, width, height) u (width, height, num_channel). Za to ćemo koristiti funkciju transponiranja.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): s otvoren(cifar10_dataset_folder_path + '/ data_batch_' + str(batch_id), način rada='rb') kao datoteka: # napomena vrsta kodiranja je 'latin1' šarža = kiseli krastavac.opterećenje(datoteka, kodiranje='latin1') značajke = šarža['podaci'].preoblikovati((len(šarža['podaci']), 3, 32, 32)).transponirati(0, 2, 3, jedan) oznake = šarža['oznake'] povratak značajke, označiti
  • Istraživanje podataka
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): značajke, oznake = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ako ne (0 <= sample_id < len(značajke)): ispis('{}uzorci u šarži{}.{}je izvan dosega. '.format(len(značajke), batch_id, sample_id)) povratak Nijedna ispis(' Statistika serije #{}: '.format(batch_id)) ispis('Broj uzoraka:{} '.format(len(značajke))) imena_naznaka = load_label_names() oznaka_brojeva = diktat(zip(*npr..jedinstven(oznake, return_counts=Pravi))) za ključ, vrijednost u oznaka_brojeva.predmeta(): ispis('Brojevi oznaka od [{}] ({}):{}'.format(ključ, imena_naznaka[ključ].Gornji(), vrijednost)) uzorak_slika = značajke[sample_id] uzorak_oznaka = oznake[sample_id] ispis(' Primjer slike{}: '.format(sample_id)) ispis('Slika - minimalna vrijednost:{}Maksimalna vrijednost:{}'.format(uzorak_slika.min(), uzorak_slika.maks())) ispis('Slika - oblik:{}'.format(uzorak_slika.oblik)) ispis('Oznaka - ID oznake:{}Ime:{}'.format(uzorak_oznaka, imena_naznaka[uzorak_oznaka])) plt.imshow(uzorak_slika)
%matplotlib u redu %konfiguracija InlineBackend.lik_format = 'Mrežnica' uvoz numpy kao npr. # Istražite skup podataka batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

  • Implementacija funkcija predobrade

Normalizirat ćemo podatke pomoću Min-Max normalizacije. Ovo jednostavno čini da se sve x vrijednosti kreću između 0 i 1.
y = (x-min) / (max-min)

def normalizirati(x): '' argument - x: unos podataka o slici u numpy niz [32, 32, 3] povratak - normalizirano x '' min_val = npr..min(x) max_val = npr..maks(x) x = (x-min_val) / (max_val-min_val) povratak x
  • Jednokratno kodiranje
def jedan_hot_enkod(x): '' argument - x: popis naljepnica povratak - jedna matrica vrućeg kodiranja (broj naljepnica, broj klase) '' kodirano = npr..nule((len(x), 10)) za idx, sati u nabrojati(x): kodirano[idx] [sati] = jedan povratak kodirano
  • Predprocesirajte i spremite podatke
def _preproces_i_spremiti(normalizirati, jedan_hot_enkod, značajke, oznake, naziv datoteke): značajke = normalizirati(značajke) oznake = jedan_hot_enkod(oznake) kiseli krastavac.istovariti((značajke, oznake), otvoren(naziv datoteke, 'wb')) def pretproces_i_spremiti_podatke(cifar10_dataset_folder_path, normalizirati, jedan_hot_enkod): n_batches = 5 valjane_značajke = [] valjane_znake = [] za šarža_i u domet(jedan, n_batches + jedan): značajke, oznake = load_cfar10_batch(cifar10_dataset_folder_path, šarža_i) # pronađi indeks kao točku kao podatke za provjeru valjanosti u cijelom skupu podataka serije (10%) indeks_validacije = int(len(značajke) * 0,1) # unaprijed obradite 90% cijelog skupa podataka serije # - normalizira značajke # - one_hot_encode šifre # - spremite u novu datoteku pod nazivom 'preprocess_batch_' + batch_number # - svaka datoteka za svaku seriju _preproces_i_spremiti(normalizirati, jedan_hot_enkod, značajke[:-indeks_validacije], oznake[:-indeks_validacije], 'preprocess_batch_' + str(šarža_i) + '.p') # za razliku od skupa podataka o obuci, niz podataka za provjeru valjanosti bit će dodan kroz sve skupove podataka # - uzmite 10% cjelovitog skupa podataka serije # - dodajte ih na popis # - valjane_značajke # - važeće_znake valjane_značajke.produžiti(značajke[-indeks_validacije:]) valjane_znake.produžiti(oznake[-indeks_validacije:]) # pretprocesira sve naslagane skupove podataka za provjeru _preproces_i_spremiti(normalizirati, jedan_hot_enkod, npr..niz(valjane_značajke), npr..niz(valjane_znake), 'pretproces_validation.p') # učitavanje testnog skupa podataka s otvoren(cifar10_dataset_folder_path + '/ test_batch', način rada='rb') kao datoteka: šarža = kiseli krastavac.opterećenje(datoteka, kodiranje='latin1') # unaprijed obraditi podatke o testiranju značajke_testa = šarža['podaci'].preoblikovati((len(šarža['podaci']), 3, 32, 32)).transponirati(0, 2, 3, jedan) test_labels = šarža['oznake'] # Predprocesirajte i spremite sve podatke o testiranju _preproces_i_spremiti(normalizirati, jedan_hot_enkod, npr..niz(značajke_testa), npr..niz(test_labels), 'pretproces_training.p')
pretproces_i_spremiti_podatke(cifar10_dataset_folder_path, normalizirati, jedan_hot_enkod)
  • Kontrolna točka
uvoz kiseli krastavac valjane_značajke, valjane_znake = kiseli krastavac.opterećenje(otvoren('pretproces_validation.p', način rada='rb'))
  • Izgradnja mreže

Cijeli se model sastoji od ukupno 14 slojeva.

uvoz tenzor tok kao tf def conv_net(x, čuvaj_prob): conv1_filter = tf.Promjenjiva(tf.skraćeno_normalno(oblik=[3, 3, 3, 64], znači=0, stddev=0,08)) conv2_filter = tf.Promjenjiva(tf.skraćeno_normalno(oblik=[3, 3, 64, 128], znači=0, stddev=0,08)) conv3_filter = tf.Promjenjiva(tf.skraćeno_normalno(oblik=[5, 5, 128, 256], znači=0, stddev=0,08)) conv4_filter = tf.Promjenjiva(tf.skraćeno_normalno(oblik=[5, 5, 256, 512], znači=0, stddev=0,08)) # 1, 2 konv1 = tf.br.conv2d(x, conv1_filter, koraka=[jedan,jedan,jedan,jedan], podmetanje='ISTI') konv1 = tf.br.relu(konv1) conv1_pool = tf.br.max_pool(konv1, ksize=[jedan,2,2,jedan], koraka=[jedan,2,2,jedan], podmetanje='ISTI') conv1_bn = tf.slojevi.serija_normalizacija(conv1_pool) # 3. 4 konv2 = tf.br.conv2d(conv1_bn, conv2_filter, koraka=[jedan,jedan,jedan,jedan], podmetanje='ISTI') konv2 = tf.br.relu(konv2) conv2_pool = tf.br.max_pool(konv2, ksize=[jedan,2,2,jedan], koraka=[jedan,2,2,jedan], podmetanje='ISTI') conv2_bn = tf.slojevi.serija_normalizacija(conv2_pool) # 5, 6 conv3 = tf.br.conv2d(conv2_bn, conv3_filter, koraka=[jedan,jedan,jedan,jedan], podmetanje='ISTI') conv3 = tf.br.relu(conv3) conv3_pool = tf.br.max_pool(conv3, ksize=[jedan,2,2,jedan], koraka=[jedan,2,2,jedan], podmetanje='ISTI') conv3_bn = tf.slojevi.serija_normalizacija(conv3_pool) # 7, 8 konv.4 = tf.br.conv2d(conv3_bn, conv4_filter, koraka=[jedan,jedan,jedan,jedan], podmetanje='ISTI') konv.4 = tf.br.relu(konv.4) conv4_pool = tf.br.max_pool(konv.4, ksize=[jedan,2,2,jedan], koraka=[jedan,2,2,jedan], podmetanje='ISTI') conv4_bn = tf.slojevi.serija_normalizacija(conv4_pool) # 9 ravan = tf.doprinos.slojevi.izravnati(conv4_bn) # 10 pun1 = tf.doprinos.slojevi.potpuno_povezana(ulazi=ravan, broj_izlaza=128, aktivacija_fn=tf.br.relu) pun1 = tf.br.napustiti(pun1, čuvaj_prob) pun1 = tf.slojevi.serija_normalizacija(pun1) # jedanaest pun2 = tf.doprinos.slojevi.potpuno_povezana(ulazi=pun1, broj_izlaza=256, aktivacija_fn=tf.br.relu) pun2 = tf.br.napustiti(pun2, čuvaj_prob) pun2 = tf.slojevi.serija_normalizacija(pun2) # 12 puna3 = tf.doprinos.slojevi.potpuno_povezana(ulazi=pun2, broj_izlaza=512, aktivacija_fn=tf.br.relu) puna3 = tf.br.napustiti(puna3, čuvaj_prob) puna3 = tf.slojevi.serija_normalizacija(puna3) # 13 puna4 = tf.doprinos.slojevi.potpuno_povezana(ulazi=puna3, broj_izlaza=1024, aktivacija_fn=tf.br.relu) puna4 = tf.br.napustiti(puna4, čuvaj_prob) puna4 = tf.slojevi.serija_normalizacija(puna4) # 14 van = tf.doprinos.slojevi.potpuno_povezana(ulazi=puna3, broj_izlaza=10, aktivacija_fn=Nijedna) povratak van
  • Hiperparametri
epohe = 10 veličina serije = 128 zadržati_vjerojatnost = 0,7 stopa_učenja = 0,001
logiti = conv_net(x, čuvaj_prob) model = tf.identitet(logiti, Ime='logits') # Name logits Tensor, tako da se može učiti s diska nakon treninga # Gubitak i optimizator trošak = tf.smanjiti_značiti(tf.br.softmax_cross_entropy_with_logits(logiti=logiti, oznake=Y)) optimizator = tf.vlak.AdamOptimizer(stopa_učenja=stopa_učenja).minimizirati(trošak) # Točnost ispravan_pred = tf.jednak(tf.argmax(logiti, jedan), tf.argmax(Y, jedan)) točnost = tf.smanjiti_značiti(tf.cast(ispravan_pred, tf.float32), Ime='točnost')
  • Trenirajte neuronsku mrežu
# Jednokratna optimizacija 
def
vlak_neurolska_ mreža(sjednica, optimizator, zadržati_vjerojatnost, feature_batch, label_batch): sjednica.trčanje(optimizator, feed_dict={ x: feature_batch, Y: label_batch, čuvaj_prob: zadržati_vjerojatnost })
#Prikazivanje statistike def print_stats(sjednica, feature_batch, label_batch, trošak, točnost): gubitak = sess.trčanje(trošak, feed_dict={ x: feature_batch, Y: label_batch, čuvaj_prob: jedan. }) važeći_acc = sess.trčanje(točnost, feed_dict={ x: valjane_značajke, Y: valjane_znake, čuvaj_prob: jedan. }) ispis('Gubitak:{:> 10.4f}Točnost provjere valjanosti:{: .6f}'.format(gubitak, važeći_acc))
  • Potpuna obuka i spremanje modela
def batch_features_labels(značajke, oznake, veličina serije): '' Podijelite značajke i naljepnice u serije '' za početak u domet(0, len(značajke), veličina serije): kraj = min(početak + veličina serije, len(značajke)) prinos značajke[početak:kraj], oznake[početak:kraj] def load_preprocess_training_batch(batch_id, veličina serije): '' Učitajte podatke o obrađenoj obuci i vratite ih u serijama ili manje '' naziv datoteke = 'preprocess_batch_' + str(batch_id) + '.p' značajke, oznake = kiseli krastavac.opterećenje(otvoren(naziv datoteke, način rada='rb')) # Vratite podatke o treningu u serijama veličine ili manje povratak batch_features_labels(značajke, oznake, veličina serije)
# Spremanje modela i putanje 
spremi_model_put
= './klasifikacija_slike' ispis('Trening...') s tf.Sjednica() kao sess: # Inicijalizacija varijabli sess.trčanje(tf.global_variables_inicializer()) # Ciklus treninga za epoha u domet(epohe): # Prelistajte sve serije n_batches = 5 za šarža_i u domet(jedan, n_batches + jedan): za batch_features, oznake_serije u load_preprocess_training_batch(šarža_i, veličina serije): vlak_neurolska_ mreža(sess, optimizator, zadržati_vjerojatnost, batch_features, oznake_serije) ispis('Epoha{:> 2}, Serija CIFAR-10{}: '.format(epoha + jedan, šarža_i), kraj=') print_stats(sess, batch_features, oznake_serije, trošak, točnost) # Spremi model štediša = tf.vlak.Saver() spremi_put = štediša.uštedjeti(sess, spremi_model_put)

java pronaći najvišu vrijednost u polju

Sada je završen važan dio Tensorflow klasifikacije slika. Sada je vrijeme za testiranje modela.

  • Testiranje modela
uvoz kiseli krastavac uvoz numpy kao npr. uvoz matplotlib.pyplot kao plt iz sklearn.prerada uvoz LabelBinarizer def batch_features_labels(značajke, oznake, veličina serije): '' Podijelite značajke i naljepnice u serije '' za početak u domet(0, len(značajke), veličina serije): kraj = min(početak + veličina serije, len(značajke)) prinos značajke[početak:kraj], oznake[početak:kraj] def prikaz_slika_predviđanja(značajke, oznake, predviđanja, top_n_ predviđanja): n_razredi = 10 imena_naznaka = load_label_names() oznaka_binarizer = LabelBinarizer() oznaka_binarizer.pristajati(domet(n_razredi)) oznake_id = oznaka_binarizer.inverzna_transformacija(npr..niz(oznake)) sl, sjekire = plt.podzavjere(nrows=top_n_ predviđanja, ncols=2, shvatiti=(dvadeset, 10)) sl.tijesni_ raspored() sl.suptitle('Softmax predviđanja', veličina fonta=dvadeset, Y=1.1) n_predviđanja = 3 margina = 0,05 ind = npr..aranžirati(n_predviđanja) širina = (jedan. - 2. * margina) / n_predviđanja za slika_i, (značajka, oznaka_id, pred_indicies, pred_vrijednosti) u nabrojati(zip(značajke, oznake_id, predviđanja.indeksi, predviđanja.vrijednosti)): ako (slika_i < top_n_ predviđanja): pred_nazivi = [imena_naznaka[pred_i] za pred_i u pred_indicies] ispravno_ime = imena_naznaka[oznaka_id] sjekire[slika_i] [0].imshow((značajka*255).astype(npr..int32, kopirati=Lažno)) sjekire[slika_i] [0].set_title(ispravno_ime) sjekire[slika_i] [0].postavljeno_os_isključeno() sjekire[slika_i] [jedan].barh(ind + margina, pred_vrijednosti[:3], širina) sjekire[slika_i] [jedan].set_yticks(ind + margina) sjekire[slika_i] [jedan].set_yticklabels(pred_nazivi[::-jedan])) sjekire[slika_i] [jedan].set_xticks([0, 0,5, 1.0]))
%matplotlib u redu %konfiguracija InlineBackend.lik_format = 'Mrežnica' uvoz tenzor tok kao tf uvoz kiseli krastavac uvoz slučajno spremi_model_put = './klasifikacija_slike' veličina serije = 64 n_uzorci = 10 top_n_ predviđanja = 5 def test_model(): značajke_testa, test_labels = kiseli krastavac.opterećenje(otvoren('pretproces_training.p', način rada='rb')) loaded_graph = tf.Grafikon() s tf.Sjednica(graf=loaded_graph) kao sess: # Učitaj model utovarivač = tf.vlak.import_meta_graph(spremi_model_put + '.meta') utovarivač.vratiti(sess, spremi_model_put) # Nabavite tenzore iz učitanog modela loaded_x = loaded_graph.get_tensor_by_name('input_x: 0') učitana_y = loaded_graph.get_tensor_by_name('output_y: 0') loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob: 0') loaded_logits = loaded_graph.get_tensor_by_name('logits: 0') loaded_acc = loaded_graph.get_tensor_by_name('točnost: 0') # Dobijte točnost u serijama radi ograničenja memorije test_batch_acc_total = 0 test_batch_count = 0 za train_feature_batch, train_label_batch u batch_features_labels(značajke_testa, test_labels, veličina serije): test_batch_acc_total + = sess.trčanje( loaded_acc, feed_dict={loaded_x: train_feature_batch, učitana_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = jedan ispis('Ispitivanje točnosti:{} '.format(test_batch_acc_total/test_batch_count)) # Ispis slučajnih uzoraka random_test_features, random_test_labels = korijen(zip(*slučajno.uzorak(popis(zip(značajke_testa, test_labels)), n_uzorci))) random_test_ predviđanja = sess.trčanje( tf.br.top_k(tf.br.softmax(loaded_logits), top_n_ predviđanja), feed_dict={loaded_x: random_test_features, učitana_y: random_test_labels, loaded_keep_prob: 1.0}) prikaz_slika_predviđanja(random_test_features, random_test_labels, random_test_ predviđanja, top_n_ predviđanja) test_model()

Izlaz: Točnost ispitivanja: 0,5882762738853503

Ako trenirate svoju neuronsku mrežu za više epoha ili promijenite funkciju aktivacije, možda ćete dobiti drugačiji rezultat koji može imati bolju točnost.

Dakle, ovim smo došli do kraja ovog članka o klasifikaciji slika TensorFlow. Siguran sam da sada možete koristiti iste za klasificiranje bilo koje vrste slika, a niste početnik u klasifikaciji slika.

Edureka’s s Python certifikacijskim treningom kuriraju profesionalci u skladu s industrijskim zahtjevima i zahtjevima. Svladati ćete koncepte kao što su SoftMax funkcija, Neuronske mreže automatskog kodiranja, Ograničeni Boltzmannov stroj (RBM), Keras i TFLearn. Tečaj su posebno pripremili industrijski stručnjaci sa studijama slučajeva u stvarnom vremenu.