Klasifikacija slik TensorFlow: Vse, kar morate vedeti o klasifikatorjih zgradb

Klasifikacija slik naloga, ki jo lahko dojenček opravi v nekaj sekundah, toda za stroj je bila težka naloga do nedavnega napredka v in Globoko učenje . Samovozeči avtomobili lahko zaznajo predmete in v realnem času izvedejo zahtevane ukrepe, večina tega pa je možna zaradi Klasifikacija slik. V tem članku vas bom vodil skozi naslednje teme:

• Kaj je TensorFlow?
• Kaj je klasifikacija slik?
• Klasifikacija slik TensorFlow: Fashion MNIST
• CIFAR 10: CNN

Kaj je TensorFlow?

TensorFlow je Googlov okvir za odprtokodno strojno učenje za programiranje pretoka podatkov za različne naloge. Vozlišča v grafu predstavljajo matematične operacije, robovi grafa pa predstavljajo večdimenzionalne matrike podatkov, ki so med njimi sporočene.

Tenzorji so le večdimenzionalni nizi, razširitev dvodimenzionalnih tabel na podatke z višjo dimenzijo. Obstaja veliko funkcij Tensorflowa, zaradi česar je primeren za globoko učenje, in osnovna odprtokodna knjižnica vam pomaga razviti in usposobiti modele ML.

Kaj je klasifikacija slik?

Namen klasifikacije slik je kategorizirati vse slikovne pike na digitalni sliki v eno od več pokrovnost zemlje razredih ali teme . Te kategorizirane podatke lahko nato uporabimo za izdelavo tematske zemljevide prisotnosti na sliki.

Zdaj, odvisno od interakcije med analitikom in računalnikom med razvrščanjem, obstajata dve vrsti razvrščanja:

• Nadzorovan &
• Brez nadzora

Torej, brez zapravljanja časa, pojdimo na TensorFlow Image Classification. Imam 2 primera: enostavno in težko. Nadaljujmo z enostavnim.

Klasifikacija slik TensorFlow: Fashion MNIST

Modni nabor podatkov MNIST

Tu bomo uporabili nabor podatkov Fashion MNIST, ki vsebuje 70.000 slik v sivih lestvicah v 10 kategorijah. 60000 bomo uporabili za trening, preostalih 10000 pa za namene testiranja. Do Fashion MNIST lahko dostopate neposredno iz TensorFlowa, samo uvozite in naložite podatke.

• Najprej uvozimo knjižnice

iz __future__ import absolute_import, division, print_function # TensorFlow in tf.keras uvoz tensorflow kot tf iz tensorflow import keras # Pomožne knjižnice uvozijo numpy kot np import matplotlib.pyplot kot plt

• Naložimo podatke

fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()

• Nato bomo slike preslikali v razrede

class_names = ['Majica / vrh', 'Hlače', 'Pulover', 'Obleka', 'Plašč', 'Sandali', 'Srajca', 'Superge', 'Torba', 'Gleženj']

• Raziskovanje podatkov

train_images.obliko 
# Vsaka oznaka je med 0-9

train_labels 
test_images.obliko 

• Zdaj je čas za predhodno obdelavo podatkov.

plt.slika() plt.imshow(train_images[0]) plt.barvna vrstica() plt.mreža(Lažno) plt.oddaja() 
#Če pregledate prvo sliko v nizu vadb, boste videli, da se vrednosti slikovnih pik gibljejo v območju od 0 do 255. 

pojdi na funkcijo c ++

• Slike moramo prilagoditi od 0-1, da jih pošljemo v nevronsko mrežo

train_images = train_images / 255,0 test_images = test_images / 255,0

• Pokažimo nekaj slik.

plt.slika(figsize=(10.,10.)) za jaz v obseg(25.): plt.subplot(5.,5.,jaz+eno) plt.xticks([]) plt.yticks([]) plt.mreža(Lažno) plt.imshow(train_images[jaz], cmap=plt.cm.binarno) plt.xlabel(imena_razredov[train_labels[jaz]]) plt.oddaja()

• Nastavite sloje

model = težko.Zaporedni([ težko.plasti.Poravnajte(vhodna_oblika=(28., 28.)), težko.plasti.Gosta(128, aktivacija=tf.št.relu), težko.plasti.Gosta(10., aktivacija=tf.št.softmax) ])

• Sestavite model

model.sestavi(optimizator='adam', izguba='sparse_categorical_crossentropy', metrike=['natančnost'])

• Izobraževanje modelov

model.fit(train_images, train_labels, epohe=10.)

• Ocenjevanje natančnosti

test_loss, test_acc = model.oceniti(test_images, test_labels) natisni(„Preskus natančnosti:“, test_acc)

• Napovedovanje

napovedi = model.napovedovati(test_images)

napovedi[0]

matrični program za množenje v javi

Napovedovanje je niz 10 številk. Ti opisujejo 'samozavest' modela, da slika ustreza vsakemu od 10 različnih oblačil. Vidimo lahko, katera etiketa ima najvišjo vrednost zaupanja.

npr..argmax(napovedi[0])#Model je najbolj prepričan, da gre za gleženj. Poglejmo, ali je pravilno

Izhod: 9

test_labels[0]

Izhod: 9

• Zdaj je čas, da si ogledamo celoten nabor 10 kanalov

def plot_image(jaz, napoved_niz, true_label, img): napoved_niz, true_label, img = napoved_niz[jaz], true_label[jaz], img[jaz] plt.mreža(Lažno) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binarno) predviden_znak = npr..argmax(napoved_niz) če predviden_znak == true_label: barva = 'zelena' drugače: barva = 'mreža' plt.xlabel('{} {: 2.0f}% ({}) '.format(imena_razredov[predviden_znak], 100*npr..maks(napoved_niz), imena_razredov[true_label]), barva=barva) def plot_value_array(jaz, napoved_niz, true_label): napoved_niz, true_label = napoved_niz[jaz], true_label[jaz] plt.mreža(Lažno) plt.xticks([]) plt.yticks([]) ta ploskev = plt.bar(obseg(10.), napoved_niz, barva='# 777777') plt.ylim([0, eno]) predviden_znak = npr..argmax(napoved_niz) ta ploskev[predviden_znak].set_color('mreža') ta ploskev[true_label].set_color('zelena')

• Najprej si oglejmo 0. in 10. sliko

jaz = 0 plt.slika(figsize=(6.,3.)) plt.subplot(eno,2.,eno) plot_image(jaz, napovedi, test_labels, test_images) plt.subplot(eno,2.,2.) plot_value_array(jaz, napovedi, test_labels) plt.oddaja()

jaz = 10. plt.slika(figsize=(6.,3.)) plt.subplot(eno,2.,eno) plot_image(jaz, napovedi, test_labels, test_images) plt.subplot(eno,2.,2.) plot_value_array(jaz, napovedi, test_labels) plt.oddaja()

• Zdaj pa narišimo več slik in njihove napovedi. Pravilni so zeleni, nepravilni pa rdeči.

število_vrstic = 5. num_cols = 3. število_slik = število_vrstic*num_cols plt.slika(figsize=(2.*2.*num_cols, 2.*število_vrstic)) za jaz v obseg(število_slik): plt.subplot(število_vrstic, 2.*num_cols, 2.*jaz+eno) plot_image(jaz, napovedi, test_labels, test_images) plt.subplot(število_vrstic, 2.*num_cols, 2.*jaz+2.) plot_value_array(jaz, napovedi, test_labels) plt.oddaja()

• Na koncu bomo z izurjenim modelom napovedovali posamezno sliko.

# Zgrabi sliko iz testnega nabora podatkov img = test_images[0] natisni(img.obliko)

# Sliko dodajte v paket, kjer je edini član. img = (npr..Razširi_dims(img,0)) natisni(img.obliko)

napovedi_samo = model.napovedovati(img) natisni(napovedi_samo)

plot_value_array(0, napovedi_samo, test_labels) plt.xticks(obseg(10.), imena_razredov, rotacija=Štiri, pet) plt.oddaja()

• Kot lahko vidite napoved za našo edino sliko v seriji.

rezultat napovedi = npr..argmax(napovedi_samo[0])

Izhod: 9

CIFAR-10: CNN

Podatkovni niz CIFAR-10 sestavljajo letala, psi, mačke in drugi predmeti. Slike boste predhodno obdelali, nato pa na vseh vzorcih usposobili konvolucijsko nevronsko mrežo. Slike je treba normalizirati in nalepke morajo biti vroče kodirane. Ta primer uporabe bo zagotovo odpravil vaše dvome o klasifikaciji slik TensorFlow.

• Prenos podatkov

iz urllib.request uvoz urlretrieve iz os.pot uvoz isfile, je saja iz tqdm uvoz tqdm uvoz tarfile cifar10_dataset_folder_path = 'cifar-10-batch-py' razred DownloadProgress(tqdm): last_block = 0 def kavelj(sebe, blok_številka=eno, velikost_bloka=eno, celotna_velika=Nobenega): sebe.skupaj = celotna_velika sebe.nadgradnja((blok_številka - sebe.last_block) * velikost_bloka) sebe.last_block = blok_številka '' preverite, ali je datoteka zip že prenesena v nasprotnem primeru ga prenesite s spletnega mesta https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz in shranite kot cifar-10-python.tar.gz '' če ne isfile('cifar-10-python.tar.gz'): s DownloadProgress(enota='B', enota_scale=Prav, miniters=eno, desc='Nabor podatkov CIFAR-10') kot pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.kavelj) če ne je saja(cifar10_dataset_folder_path): s tarfile.odprto('cifar-10-python.tar.gz') kot katran: katran.ekstraktall() katran.blizu()

• Uvoz potrebnih knjižnic

uvoz kumarica uvoz numpy kot npr. uvoz matplotlib.pyplot kot plt

• Razumevanje podatkov

Prvotna serija podatkov je 10000 × 3072 tenzorja, izražena v matrični matriki, kjer je 10000 število vzorčnih podatkov. Slika je barvna in velikosti 32 × 32. Hranjenje je mogoče v obliki (širina x višina x število_kanal) ali (število_kanal x širina x višina). Določimo oznake.

def load_label_names(): vrnitev ['letalo', 'avtomobil', 'ptica', 'mačka', 'jelen', 'pes', 'žaba', 'konj', 'ladja', 'tovornjak']

• Preoblikovanje podatkov

Podatke bomo preoblikovali v dveh fazah

Najprej razdelite vrstni vektor (3072) na 3 dele. Vsak kos ustreza vsakemu kanalu. Rezultat tega je (3 x 1024) dimenzija tenzorja. Nato dobljeni tenzor iz prejšnjega koraka razdelite na 32. 32 tukaj pomeni širino slike. Rezultat je (3x32x32).

Drugič, podatke moramo prenesti iz (num_channel, width, height) v (width, height, num_channel). Za to bomo uporabili funkcijo prenosa.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): s odprto(cifar10_dataset_folder_path + '/ data_batch_' + str(batch_id), način='rb') kot mapa: # upoštevajte, da je vrsta kodiranja 'latin1' serija = kumarica.obremenitev(mapa, kodiranje='latin1') Lastnosti = serija['podatki'].preoblikovati((len(serija['podatki']), 3., 32, 32)).prenesti(0, 2., 3., eno) nalepke = serija['nalepke'] vrnitev Lastnosti, nalepko

• Raziskovanje podatkov

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Lastnosti, nalepke = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) če ne (0 <= sample_id < len(Lastnosti)): natisni('{}vzorci v seriji{}.{}je izven dosega. '.format(len(Lastnosti), batch_id, sample_id)) vrnitev Nobenega natisni(' Statistika serije #{}: '.format(batch_id)) natisni('Število vzorcev:{} '.format(len(Lastnosti))) imena_nalepk = load_label_names() label_counts = dict(zadrgo(*npr..edinstven(nalepke, return_counts=Prav))) za tipko, vrednost v label_counts.predmetov(): natisni('Število oznak [{}] ({}):{}'.format(tipko, imena_nalepk[tipko].zgornji(), vrednost)) sample_image = Lastnosti[sample_id] sample_label = nalepke[sample_id] natisni(' Primer slike{}: '.format(sample_id)) natisni('Slika - Minimalna vrednost:{}Najvišja vrednost:{}'.format(sample_image.min(), sample_image.maks())) natisni('Slika - oblika:{}'.format(sample_image.obliko)) natisni('Oznaka - ID nalepke:{}Ime:{}'.format(sample_label, imena_nalepk[sample_label])) plt.imshow(sample_image)

%matplotlib v vrsti %konfig InlineBackend.slika_format = 'mrežnica' uvoz numpy kot npr. # Raziščite nabor podatkov batch_id = 3. sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Izvajanje funkcij predobdelave

Podatke bomo normalizirali z normalizacijo Min-Max. Tako se vse vrednosti x gibljejo med 0 in 1.
y = (x-min) / (max-min)

def normalizirati(x): '' prepir - x: vnos slikovnih podatkov v matrično polje [32, 32, 3] vrnitev - normaliziran x '' min_val = npr..min(x) max_val = npr..maks(x) x = (x-min_val) / (max_val-min_val) vrnitev x

• Enkratno kodiranje

def ena_hotna_koda(x): '' prepir - x: seznam nalepk vrnitev - ena matrika vročega kodiranja (število nalepk, število razredov) '' kodirano = npr..ničle((len(x), 10.)) za idx, ure v naštevati(x): kodirano[idx] [ure] = eno vrnitev kodirano

• Predobdelava in shranjevanje podatkov

def _preprocess_and_save(normalizirati, ena_hotna_koda, Lastnosti, nalepke, Ime datoteke): Lastnosti = normalizirati(Lastnosti) nalepke = ena_hotna_koda(nalepke) kumarica.smetišče((Lastnosti, nalepke), odprto(Ime datoteke, 'wb')) def predprocesni_in_prihrani_podatke(cifar10_dataset_folder_path, normalizirati, ena_hotna_koda): n_batches = 5. veljavne_značilnosti = [] veljavne_nalepke = [] za serija_i v obseg(eno, n_batches + eno): Lastnosti, nalepke = load_cfar10_batch(cifar10_dataset_folder_path, serija_i) # najdi indeks kot točko kot podatke za preverjanje veljavnosti v celotnem naboru podatkov serije (10%) index_of_validation = int(len(Lastnosti) * 0,1) # predobdelajte 90% celotnega nabora podatkov o paketu # - normalizira funkcije # - one_hot_encode oznake # - shrani v novo datoteko z imenom 'preprocess_batch_' + batch_number # - vsaka datoteka za vsako serijo _preprocess_and_save(normalizirati, ena_hotna_koda, Lastnosti[:-index_of_validation], nalepke[:-index_of_validation], 'preprocess_batch_' + str(serija_i) + '.p') # v nasprotju z naborom podatkov o vadbi bo validacijski nabor dodan skozi vse nabore podatkov # - vzemite 10% celotnega nabora podatkov serije # - jih dodajte na seznam # - veljavne_značilnosti # - veljavne_nalepke veljavne_značilnosti.podaljšati(Lastnosti[-index_of_validation:]) veljavne_nalepke.podaljšati(nalepke[-index_of_validation:]) # predobdelaj vse zložene validacijske nabore podatkov _preprocess_and_save(normalizirati, ena_hotna_koda, npr..matriko(veljavne_značilnosti), npr..matriko(veljavne_nalepke), 'preprocess_validation.p') # naložite testni nabor podatkov s odprto(cifar10_dataset_folder_path + '/ test_batch', način='rb') kot mapa: serija = kumarica.obremenitev(mapa, kodiranje='latin1') # predobdelajte podatke o testiranju test_features = serija['podatki'].preoblikovati((len(serija['podatki']), 3., 32, 32)).prenesti(0, 2., 3., eno) test_labels = serija['nalepke'] # Predobdelava in shranjevanje vseh podatkov o testiranju _preprocess_and_save(normalizirati, ena_hotna_koda, npr..matriko(test_features), npr..matriko(test_labels), 'preprocess_training.p')

predprocesni_in_prihrani_podatke(cifar10_dataset_folder_path, normalizirati, ena_hotna_koda)

• Kontrolna točka

uvoz kumarica veljavne_značilnosti, veljavne_nalepke = kumarica.obremenitev(odprto('preprocess_validation.p', način='rb'))

• Izgradnja mreže

Celoten model je sestavljen iz 14 plasti.

kako uporabiti zamenjavo v javi -

uvoz tensorflow kot tf def conv_net(x, keep_prob): conv1_filter = tf.Spremenljiv(tf.okrnjeno_normalno(obliko=[3., 3., 3., 64], pomeni=0, stddev=0,08)) conv2_filter = tf.Spremenljiv(tf.okrnjeno_normalno(obliko=[3., 3., 64, 128], pomeni=0, stddev=0,08)) conv3_filter = tf.Spremenljiv(tf.okrnjeno_normalno(obliko=[5., 5., 128, 256], pomeni=0, stddev=0,08)) conv4_filter = tf.Spremenljiv(tf.okrnjeno_normalno(obliko=[5., 5., 256, 512], pomeni=0, stddev=0,08)) # 1, 2 konv = tf.št.conv2d(x, conv1_filter, koraki=[eno,eno,eno,eno], oblazinjenje='ENAKO') konv = tf.št.relu(konv) conv1_pool = tf.št.max_pool(konv, ksize=[eno,2.,2.,eno], koraki=[eno,2.,2.,eno], oblazinjenje='ENAKO') conv1_bn = tf.plasti.serijska_normalizacija(conv1_pool) # 3. 4 konv = tf.št.conv2d(conv1_bn, conv2_filter, koraki=[eno,eno,eno,eno], oblazinjenje='ENAKO') konv = tf.št.relu(konv) conv2_pool = tf.št.max_pool(konv, ksize=[eno,2.,2.,eno], koraki=[eno,2.,2.,eno], oblazinjenje='ENAKO') conv2_bn = tf.plasti.serijska_normalizacija(conv2_pool) # 5, 6 konv.3 = tf.št.conv2d(conv2_bn, conv3_filter, koraki=[eno,eno,eno,eno], oblazinjenje='ENAKO') konv.3 = tf.št.relu(konv.3) conv3_pool = tf.št.max_pool(konv.3, ksize=[eno,2.,2.,eno], koraki=[eno,2.,2.,eno], oblazinjenje='ENAKO') conv3_bn = tf.plasti.serijska_normalizacija(conv3_pool) # 7, 8 konv.4 = tf.št.conv2d(conv3_bn, conv4_filter, koraki=[eno,eno,eno,eno], oblazinjenje='ENAKO') konv.4 = tf.št.relu(konv.4) conv4_pool = tf.št.max_pool(konv.4, ksize=[eno,2.,2.,eno], koraki=[eno,2.,2.,eno], oblazinjenje='ENAKO') conv4_bn = tf.plasti.serijska_normalizacija(conv4_pool) # 9 stanovanje = tf.prispevek.plasti.poravnati(conv4_bn) # 10 polno1 = tf.prispevek.plasti.popolnoma_povezani(vhodi=stanovanje, število_izhodov=128, activation_fn=tf.št.relu) polno1 = tf.št.osip(polno1, keep_prob) polno1 = tf.plasti.serijska_normalizacija(polno1) # enajst polno2 = tf.prispevek.plasti.popolnoma_povezani(vhodi=polno1, število_izhodov=256, activation_fn=tf.št.relu) polno2 = tf.št.osip(polno2, keep_prob) polno2 = tf.plasti.serijska_normalizacija(polno2) # 12 polno3 = tf.prispevek.plasti.popolnoma_povezani(vhodi=polno2, število_izhodov=512, activation_fn=tf.št.relu) polno3 = tf.št.osip(polno3, keep_prob) polno3 = tf.plasti.serijska_normalizacija(polno3) # 13 polno4 = tf.prispevek.plasti.popolnoma_povezani(vhodi=polno3, število_izhodov=1024, activation_fn=tf.št.relu) polno4 = tf.št.osip(polno4, keep_prob) polno4 = tf.plasti.serijska_normalizacija(polno4) # 14 ven = tf.prispevek.plasti.popolnoma_povezani(vhodi=polno3, število_izhodov=10., activation_fn=Nobenega) vrnitev ven

• Hiperparametri

epohe = 10. velikost_serije = 128 keep_probability = 0,7 hitrost_učenja = 0,001

logits = conv_net(x, keep_prob) model = tf.identiteta(logits, ime='logits') # Name logits Tensor, tako da ga je mogoče po treningu naložiti z diska # Izguba in optimizator stroškov = tf.zmanjšaj_pomini(tf.št.softmax_cross_entropy_wit_logits(logits=logits, nalepke=Y.)) optimizator = tf.vlak.AdamOptimizer(hitrost_učenja=hitrost_učenja).minimizirati(stroškov) # Natančnost pravilno_pred = tf.enako(tf.argmax(logits, eno), tf.argmax(Y., eno)) natančnost = tf.zmanjšaj_pomini(tf.igralska zasedba(pravilno_pred, tf.float32), ime='natančnost')

• Vadite nevronsko mrežo

# Enkratna optimizacija 
def train_neural_network(sejo, optimizator, keep_probability, feature_batch, label_batch): sejo.teči(optimizator, feed_dict={ x: feature_batch, Y.: label_batch, keep_prob: keep_probability })

#Showing Stats def print_stats(sejo, feature_batch, label_batch, stroškov, natančnost): izguba = sess.teči(stroškov, feed_dict={ x: feature_batch, Y.: label_batch, keep_prob: eno. }) veljaven_acc = sess.teči(natančnost, feed_dict={ x: veljavne_značilnosti, Y.: veljavne_nalepke, keep_prob: eno. }) natisni('Izguba:{:> 10.4f}Natančnost preverjanja:{: .6f}'.format(izguba, veljaven_acc))

• Popolno usposabljanje in shranjevanje modela

def batch_features_labels(Lastnosti, nalepke, velikost_serije): '' Funkcije in nalepke razdelite na serije '' za začetek v obseg(0, len(Lastnosti), velikost_serije): konec = min(začetek + velikost_serije, len(Lastnosti)) donos Lastnosti[začetek:konec], nalepke[začetek:konec] def load_preprocess_training_batch(batch_id, velikost_serije): '' Naložite podatke o predhodno obdelanem treningu in jih vrnite v serijah ali manj '' Ime datoteke = 'preprocess_batch_' + str(batch_id) + '.p' Lastnosti, nalepke = kumarica.obremenitev(odprto(Ime datoteke, način='rb')) # Vrnite podatke o vadbi v velikostih ali manj vrnitev batch_features_labels(Lastnosti, nalepke, velikost_serije)

# Shranjevanje modela in poti 
shrani_model_pot = './image_classification' natisni('Izobraževanje ...') s tf.Seja() kot sess: # Inicializacija spremenljivk sess.teči(tf.global_variables_initializer()) # Vadbeni cikel za epoha v obseg(epohe): # Preglejte vse serije n_batches = 5. za serija_i v obseg(eno, n_batches + eno): za batch_features, batch_labels v load_preprocess_training_batch(serija_i, velikost_serije): train_neural_network(sess, optimizator, keep_probability, batch_features, batch_labels) natisni('Epoha{:> 2}, Serija CIFAR-10{}: '.format(epoha + eno, serija_i), konec=') print_stats(sess, batch_features, batch_labels, stroškov, natančnost) # Shrani model varčevalnik = tf.vlak.Varčevanje() shrani_pot = varčevalnik.shrani(sess, shrani_model_pot)

Zdaj je končan pomemben del klasifikacije slik Tensorflow. Zdaj je čas, da preizkusite model.

• Testiranje modela

uvoz kumarica uvoz numpy kot npr. uvoz matplotlib.pyplot kot plt iz sklearn.predelava uvoz LabelBinarizer def batch_features_labels(Lastnosti, nalepke, velikost_serije): '' Funkcije in nalepke razdelite na serije '' za začetek v obseg(0, len(Lastnosti), velikost_serije): konec = min(začetek + velikost_serije, len(Lastnosti)) donos Lastnosti[začetek:konec], nalepke[začetek:konec] def display_image_predictions(Lastnosti, nalepke, napovedi, top_n_predictions): n_razredi = 10. imena_nalepk = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.fit(obseg(n_razredi)) label_ids = label_binarizer.inverse_transform(npr..matriko(nalepke)) sl, osi = plt.podplosk(nrows=top_n_predictions, ncols=2., figsize=(dvajset, 10.)) sl.tesna postavitev() sl.suptitle('Napovedi Softmax', velikost pisave=dvajset, Y.=1.1) n_predvidevanja = 3. marža = 0,05 ind = npr..arange(n_predvidevanja) premer = (eno. - 2. * marža) / n_predvidevanja za image_i, (funkcija, label_id, pred_indicies, pred_vrednosti) v naštevati(zadrgo(Lastnosti, label_ids, napovedi.indeksi, napovedi.vrednote)): če (image_i < top_n_predictions): pred_imena = [imena_nalepk[pred_i] za pred_i v pred_indicies] pravilno_ime = imena_nalepk[label_id] osi[image_i] [0].imshow((funkcija*255).astype(npr..int32, kopirati=Lažno)) osi[image_i] [0].set_title(pravilno_ime) osi[image_i] [0].set_axis_off() osi[image_i] [eno].barh(ind + marža, pred_vrednosti[:3.], premer) osi[image_i] [eno].set_yticks(ind + marža) osi[image_i] [eno].set_yticklabels(pred_imena[::-eno]) osi[image_i] [eno].set_xticks([0, 0,5, 1.0])

%matplotlib v vrsti %konfig InlineBackend.slika_format = 'mrežnica' uvoz tensorflow kot tf uvoz kumarica uvoz naključen shrani_model_pot = './image_classification' velikost_serije = 64 n_vzorci = 10. top_n_predictions = 5. def test_model(): test_features, test_labels = kumarica.obremenitev(odprto('preprocess_training.p', način='rb')) naložen_graf = tf.Graf() s tf.Seja(graf=naložen_graf) kot sess: # Naloži model nakladalnik = tf.vlak.import_meta_graph(shrani_model_pot + '.meta') nakladalnik.obnoviti(sess, shrani_model_pot) # Pridobite tenzorje iz naloženega modela naložen_x = naložen_graf.get_tensor_by_name('input_x: 0') naložen_y = naložen_graf.get_tensor_by_name('output_y: 0') loaded_keep_prob = naložen_graf.get_tensor_by_name('keep_prob: 0') loaded_logits = naložen_graf.get_tensor_by_name('logits: 0') loaded_acc = naložen_graf.get_tensor_by_name('natančnost: 0') # Pridobite natančnost v serijah zaradi omejitev pomnilnika test_batch_acc_total = 0 test_batch_count = 0 za train_feature_batch, train_label_batch v batch_features_labels(test_features, test_labels, velikost_serije): test_batch_acc_total + = sess.teči( loaded_acc, feed_dict={naložen_x: train_feature_batch, naložen_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = eno natisni(„Natančnost preskušanja:{} '.format(test_batch_acc_total/test_batch_count)) # Natisnite naključne vzorce random_test_features, random_test_labels = tuple(zadrgo(*naključen.vzorec(seznam(zadrgo(test_features, test_labels)), n_vzorci))) random_test_predictions = sess.teči( tf.št.top_k(tf.št.softmax(loaded_logits), top_n_predictions), feed_dict={naložen_x: random_test_features, naložen_y: random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()

Izhod: Natančnost preskušanja: 0,5882762738853503

Zdaj, če nevronsko mrežo trenirate več obdobij ali spremenite funkcijo aktiviranja, boste morda dobili drugačen rezultat, ki bo morda bolj natančen.

S tem smo prišli do konca tega članka o klasifikaciji slik TensorFlow. Prepričan sem, da lahko zdaj isto uporabite za razvrščanje kakršnih koli slik in niste začetnik pri razvrščanju slik.

Edureka s Python Certification Training pripravijo strokovnjaki iz panoge v skladu z zahtevami in zahtevami panoge. Obvladali boste koncepte, kot so funkcija SoftMax, nevronske mreže samodejnega kodiranja, omejeni stroj Boltzmann (RBM), Keras in TFLearn. Tečaj so posebej pripravili strokovnjaki iz industrije s študijami primerov v realnem času.