Klasifikácia obrázkov TensorFlow: Všetko, čo potrebujete vedieť o klasifikátoroch budov

Klasifikácia obrázkov je úloha, ktorú zvládne aj dieťa za pár sekúnd, ale pre stroj bola až do nedávneho pokroku v a Hlboké učenie . Samoriadiace autá dokážu detekovať objekty a vykonať potrebné kroky v reálnom čase, čo je väčšinou možné z dôvodu Klasifikácia obrázkov. V tomto článku vás prevediem nasledujúcimi témami:

• Čo je TensorFlow?
• Čo je to klasifikácia obrázkov?
• Klasifikácia obrázkov TensorFlow: Fashion MNIST
• CIFAR 10: CNN

Čo je TensorFlow?

TensorFlow je rámec otvoreného strojového učenia spoločnosti Google pre programovanie toku údajov v celom rade úloh. Uzly v grafe predstavujú matematické operácie, zatiaľ čo okraje grafu predstavujú mnohorozmerné dátové polia komunikované medzi nimi.

Tenzory sú iba multidimenzionálne polia, rozšírenie dvojrozmerných tabuliek o údaje s vyššou dimenziou. Existuje veľa funkcií Tensorflow, vďaka ktorým je vhodný pre Deep Learning a jeho hlavná otvorená knižnica zdrojov vám pomáha vyvíjať a trénovať modely ML.

Čo je to klasifikácia obrázkov?

Účelom klasifikácie obrázkov je roztriediť všetky pixely v digitálnom obraze do jedného z niekoľkých krajinná pokrývka triedy alebo témy . Tieto kategorizované údaje sa potom môžu použiť na výrobu tematické mapy krajinnej pokrývky prítomnej na obrázku.

Teraz V závislosti od interakcie medzi analytikom a počítačom počas klasifikácie existujú dva typy klasifikácie:

• Dohľad a
• Bez dozoru

Bez toho, aby sme zbytočne míňali čas, prejdime na klasifikáciu obrázkov TensorFlow. Mám 2 príklady: ľahký a ťažký. Poďme k ľahkej.

Klasifikácia obrázkov TensorFlow: Fashion MNIST

Módny súbor údajov MNIST

Tu použijeme dataset Fashion MNIST, ktorý obsahuje 70 000 obrázkov v odtieňoch sivej v 10 kategóriách. 60000 použijeme na školenie a zvyšných 10 000 na testovacie účely. K nástroju Fashion MNIST máte prístup priamo z TensorFlow, stačí importovať a načítať údaje.

• Najprv importujme knižnice

z __future__ import absolútny_import, rozdelenie, print_function # TensorFlow a tf.keras import tensorflow ako tf z tensorflow import keras # pomocné knižnice import numpy ako np import matplotlib.pyplot ako plt

• Načítajme údaje

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

• Ďalej ideme mapovať obrázky do tried

class_names = ['Tričko / top', 'Nohavice', 'Pulóver', 'Šaty', 'Kabát', 'Sandál', 'Košeľa', 'Tenisky', 'Taška', 'Členková topánka']

• Skúmanie údajov

vlak_obrazy.tvar 
# Každý štítok je v rozmedzí 0-9

vlakové_štítky 
test_images.tvar 

• Teraz je čas údaje vopred spracovať.

plt.obrázok() plt.ukáž(vlak_obrazy[0]) plt.farebná lišta() plt.mriežka(Falošné) plt.šou() 
#Ak skontrolujete prvý obrázok v cvičnej sade, uvidíte, že hodnoty pixelov klesajú v rozmedzí od 0 do 255. 

• Musíme škálovať obrázky od 0 do 1, aby sme ich vložili do neurónovej siete

vlak_obrazy = vlak_obrazy / 255,0 test_images = test_images / 255,0

• Poďme si zobraziť nejaké obrázky.

plt.obrázok(figsize=(10,10)) pre i v rozsah(25): plt.čiastkový graf(5,5,i+jeden) plt.xticks([]) plt.yticks([]) plt.mriežka(Falošné) plt.ukáž(vlak_obrazy[i], cmap=plt.cm.binárne) plt.xlabel(názvy_tried[vlakové_štítky[i]])) plt.šou()

• Nastavte vrstvy

Model = ťažko.Postupné([ ťažko.vrstiev.Sploštiť(input_shape=(28, 28)), ťažko.vrstiev.Husté(128, aktivácia=tf.nos.relu), ťažko.vrstiev.Husté(10, aktivácia=tf.nos.softmax) ])

• Zostavte model

Model.zostaviť(optimalizátor='adam', strata='sparse_categorical_crossentropy', metriky=[„presnosť“])

• Model Training

Model.fit(vlak_obrazy, vlakové_štítky, epochy=10)

• Vyhodnocovanie presnosti

test_loss, test_acc = Model.ohodnotiť(test_images, štítky_testu) tlačiť(„Presnosť skúšky:“, test_acc)

• Vytváranie predpovedí

predpovede = Model.predvídať(test_images)

predpovede[0]

Predikcia je pole 10 čísel. Tieto opisujú „istotu“ modelu, že obraz zodpovedá každému z 10 rôznych odevných výrobkov. Vidíme, ktorá značka má najvyššiu hodnotu spoľahlivosti.

napr..argmax(predpovede[0])#Model si je istý, že ide o členkovú obuv. Uvidíme, či je to správne

Výstup: 9

štítky_testu[0]

Výstup: 9

• Teraz je čas pozrieť sa na celú sadu 10 kanálov

def plot_image(i, predictions_array, true_label, obr): predictions_array, true_label, obr = predictions_array[i], true_label[i], obr[i] plt.mriežka(Falošné) plt.xticks([]) plt.yticks([]) plt.ukáž(obr, cmap=plt.cm.binárne) predikovaný_štítok = napr..argmax(predictions_array) ak predikovaný_štítok == true_label: farba = 'zelená' inak: farba = „net“ plt.xlabel(„{} {: 2.0f}% ({}) “.formát(názvy_tried[predikovaný_štítok], 100*napr..max(predictions_array), názvy_tried[true_label]), farba=farba) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.mriežka(Falošné) plt.xticks([]) plt.yticks([]) tento pozemok = plt.bar(rozsah(10), predictions_array, farba=„# 777777“) plt.ylim([0, jeden]) predikovaný_štítok = napr..argmax(predictions_array) tento pozemok[predikovaný_štítok].set_color(„net“) tento pozemok[true_label].set_color('zelená')

• Najprv sa pozrime na 0. a 10. obrázok

i = 0 plt.obrázok(figsize=(6,3)) plt.čiastkový graf(jeden,2,jeden) plot_image(i, predpovede, štítky_testu, test_images) plt.čiastkový graf(jeden,2,2) plot_value_array(i, predpovede, štítky_testu) plt.šou()

i = 10 plt.obrázok(figsize=(6,3)) plt.čiastkový graf(jeden,2,jeden) plot_image(i, predpovede, štítky_testu, test_images) plt.čiastkový graf(jeden,2,2) plot_value_array(i, predpovede, štítky_testu) plt.šou()

• Pozrime sa teraz na niekoľko obrázkov a ich predpovede. Správne sú zelené, zatiaľ čo nesprávne sú červené.

num_rows = 5 num_cols = 3 počet_obrázkov = num_rows*num_cols plt.obrázok(figsize=(2*2*num_cols, 2*num_rows)) pre i v rozsah(počet_obrázkov): plt.čiastkový graf(num_rows, 2*num_cols, 2*i+jeden) plot_image(i, predpovede, štítky_testu, test_images) plt.čiastkový graf(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, predpovede, štítky_testu) plt.šou()

• Nakoniec použijeme trénovaný model na predpovedanie jedného obrázka.

# Chyťte obrázok z testovacej dátovej sady obr = test_images[0] tlačiť(obr.tvar)

# Pridajte obrázok do dávky, kde je jediným členom. obr = (napr..expand_dims(obr,0)) tlačiť(obr.tvar)

predictions_single = Model.predvídať(obr) tlačiť(predictions_single)

plot_value_array(0, predictions_single, štítky_testu) plt.xticks(rozsah(10), názvy_tried, rotácia=Štyri, päť) plt.šou()

• Ako vidíte predpoveď pre náš jediný hromadný obrázok.

predikcia_výsledok = napr..argmax(predictions_single[0])

Výstup: 9

CIFAR-10: CNN

Súbor údajov CIFAR-10 pozostáva z lietadiel, psov, mačiek a iných objektov. Predpracujete obrázky a potom nacvičíte konvolučnú neurónovú sieť na všetkých vzorkách. Obrázky musia byť normalizované a štítky musia byť kódované za horúca. Tento prípad použitia určite vyčistí vaše pochybnosti o klasifikácii obrázkov TensorFlow.

• Sťahovanie údajov

od urllib.žiadosť dovoz urlretrieve od os.cesta dovoz isfile, sú sadze od tqdm dovoz tqdm dovoz tarfile cifar10_dataset_folder_path = „cifar-10-batches-py“ trieda DownloadProgress(tqdm): last_block = 0 def háčik(ja, block_num=jeden, block_size=jeden, Celková velkosť=Žiadne): ja.Celkom = Celková velkosť ja.aktualizovať(((block_num - ja.last_block) * block_size) ja.last_block = block_num '' ' skontrolujte, či je dátový (zip) súbor už stiahnutý ak nie, stiahnite si ho z adresy „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“ a uložte ako cifar-10-python.tar.gz '' ' ak nie isfile(„cifar-10-python.tar.gz“): s DownloadProgress(jednotka=„B“, jednotka_škála=Pravdaže, minitery=jeden, popis=„Dátová sada CIFAR-10“) ako pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“, „cifar-10-python.tar.gz“, pbar.háčik) ak nie sú sadze(cifar10_dataset_folder_path): s tarfile.otvorené(„cifar-10-python.tar.gz“) ako decht: decht.extrahovať všetko() decht.Zavrieť()

• Import potrebných knižníc

dovoz nálev dovoz numpy ako napr. dovoz matplotlib.pyplot ako plt

• Pochopenie údajov

Pôvodná dávka dát je 10 000 × 3072 tenzorov vyjadrených v početnom poli, kde 10 000 predstavuje počet vzorových údajov. Obrázok je farebný a má veľkosť 32 × 32. Kŕmenie je možné vykonať buď vo formáte (šírka x výška x počet_kanál) alebo (počet_kanál x šírka x výška). Definujme štítky.

def load_label_names(): návrat [„lietadlo“, „automobil“, 'vták', „mačka“, „jeleň“, 'pes', „žaba“, „kôň“, „loď“, „nákladné auto“]

• Zmena tvaru údajov

Údaje zmeníme v dvoch fázach

Najskôr rozdeľte vektor riadku (3072) na 3 kúsky. Každý kus zodpovedá každému kanálu. Výsledkom je (3 x 1024) rozmer tenzora. Potom vydelte výsledný tenzor z predchádzajúceho kroku číslom 32. 32 tu znamená šírku obrázka. Výsledkom je (3x32x32).

Po druhé, musíme transponovať údaje z (num_channel, width, height) do (width, height, num_channel). Na to použijeme funkciu transpozície.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): s otvorené(cifar10_dataset_folder_path + „/ data_batch_“ + p(batch_id), režim=„rb“) ako spis: # všimnite si, že typ kódovania je 'latin1' šarža = nálev.naložiť(spis, kódovanie='latin1') Vlastnosti = šarža[„data“].pretvarovať(((len(šarža[„data“]), 3, 32, 32)).transponovať(0, 2, 3, jeden) štítky = šarža[„štítky“] návrat Vlastnosti, štítok

• Skúmanie údajov

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Vlastnosti, štítky = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ak nie (0 <= sample_id < len(Vlastnosti)): tlačiť(„{}vzorky v dávke{}.{}je mimo rozsahu. “.formát(len(Vlastnosti), batch_id, sample_id)) návrat Žiadne tlačiť(„ Štatistiky dávky #{}: '.formát(batch_id)) tlačiť(„počet vzoriek:{} „.formát(len(Vlastnosti))) štítok_názvy = load_label_names() štítok_účty = diktát(PSČ(*napr..jedinečný(štítky, návratové_účty=Pravdaže))) pre kľúč, hodnotu v štítok_účty.položky(): tlačiť(„Počty štítkov [{}] ({}):{}„.formát(kľúč, štítok_názvy[kľúč].horný(), hodnotu)) sample_image = Vlastnosti[sample_id] sample_label = štítky[sample_id] tlačiť(„ Príklad obrázka{}: '.formát(sample_id)) tlačiť(„Obrázok - minimálna hodnota:{}Maximálna hodnota:{}„.formát(sample_image.min(), sample_image.max())) tlačiť(„Obrázok - tvar:{}„.formát(sample_image.tvar)) tlačiť(„Štítok - ID štítku:{}Názov:{}„.formát(sample_label, štítok_názvy[sample_label])) plt.ukáž(sample_image)

%matplotlib v rade %konfigur InlineBackend.postava_formát = „sietnica“ dovoz numpy ako napr. # Preskúmajte množinu údajov batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Implementácia funkcií predspracovania

Chystáme sa normalizovať údaje pomocou normalizácie Min-Max. Toto jednoducho urobí všetky hodnoty x v rozmedzí od 0 do 1.
y = (x-min) / (max-min)

def normalizovať(X): '' ' argument - x: vstupné obrazové údaje v číselnom poli [32, 32, 3] návrat - normalizované x '' ' min_val = napr..min(X) max_val = napr..max(X) X = (X-min_val) / (max_val-min_val) návrat X

• Kódovanie One-Hot

def one_hot_encode(X): '' ' argument - x: zoznam štítkov návrat - jedna horúca kódovacia matica (počet štítkov, počet tried) '' ' zakódovaný = napr..nuly(((len(X), 10)) pre idx, hod v vymenovať(X): zakódovaný[idx] [hod] = jeden návrat zakódovaný

• Predbežné spracovanie a uloženie údajov

def _preproces_a_uložiť(normalizovať, one_hot_encode, Vlastnosti, štítky, názov súboru): Vlastnosti = normalizovať(Vlastnosti) štítky = one_hot_encode(štítky) nálev.skládka(((Vlastnosti, štítky), otvorené(názov súboru, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizovať, one_hot_encode): n_batches = 5 valid_features = [] platné_štítky = [] pre batch_i v rozsah(jeden, n_batches + jeden): Vlastnosti, štítky = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # nájsť index, ktorý bude bodom ako overovacie údaje v celom súbore údajov dávky (10%) index_of_validation = int(len(Vlastnosti) * 0,1) # predbežne spracujte 90% celého súboru údajov dávky # - normalizovať funkcie # - one_hot_encode štítky # - uložiť do nového súboru s názvom „preprocess_batch_“ + batch_number # - každý súbor pre každú dávku _preproces_a_uložiť(normalizovať, one_hot_encode, Vlastnosti[:-index_of_validation], štítky[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + „.p“) # na rozdiel od tréningovej dátovej sady, overovacia dátová sada bude pridaná cez všetky dávkové dátové sady # - vezmite 10% z celého súboru údajov dávky # - pridajte ich do zoznamu # - platné_funkcie # - platné_štítky valid_features.predĺžiť(Vlastnosti[-index_of_validation:]) platné_štítky.predĺžiť(štítky[-index_of_validation:]) # predspracovať všetky naukladané súbory overovacích údajov _preproces_a_uložiť(normalizovať, one_hot_encode, napr..pole(valid_features), napr..pole(platné_štítky), 'preprocess_validation.p') # načítajte testovaciu množinu údajov s otvorené(cifar10_dataset_folder_path + „/ test_batch“, režim=„rb“) ako spis: šarža = nálev.naložiť(spis, kódovanie='latin1') # predbežné spracovanie testovacích údajov test_features = šarža[„data“].pretvarovať(((len(šarža[„data“]), 3, 32, 32)).transponovať(0, 2, 3, jeden) štítky_testu = šarža[„štítky“] # Predbežné spracovanie a uloženie všetkých testovacích údajov _preproces_a_uložiť(normalizovať, one_hot_encode, napr..pole(test_features), napr..pole(štítky_testu), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normalizovať, one_hot_encode)

• Kontrolný bod

dovoz nálev valid_features, platné_štítky = nálev.naložiť(otvorené('preprocess_validation.p', režim=„rb“))

• Budovanie siete

Celý model pozostáva celkovo z 14 vrstiev.

dovoz tensorflow ako tf def conv_net(X, keep_prob): conv1_filter = tf.Variabilné(tf.skrátený_normálny(tvar=[3, 3, 3, 64], znamenajú=0, stddev=0,08)) conv2_filter = tf.Variabilné(tf.skrátený_normálny(tvar=[3, 3, 64, 128], znamenajú=0, stddev=0,08)) conv3_filter = tf.Variabilné(tf.skrátený_normálny(tvar=[5, 5, 128, 256], znamenajú=0, stddev=0,08)) conv4_filter = tf.Variabilné(tf.skrátený_normálny(tvar=[5, 5, 256, 512], znamenajú=0, stddev=0,08)) # 1, 2 konv1 = tf.nos.konv2d(X, conv1_filter, kroky=[jeden,jeden,jeden,jeden], vypchávka=„ROVNAKÝ“) konv1 = tf.nos.relu(konv1) conv1_pool = tf.nos.max_pool(konv1, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], vypchávka=„ROVNAKÝ“) conv1_bn = tf.vrstiev.batch_normisation(conv1_pool) # 3. 4 konv2 = tf.nos.konv2d(conv1_bn, conv2_filter, kroky=[jeden,jeden,jeden,jeden], vypchávka=„ROVNAKÝ“) konv2 = tf.nos.relu(konv2) conv2_pool = tf.nos.max_pool(konv2, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], vypchávka=„ROVNAKÝ“) conv2_bn = tf.vrstiev.batch_normisation(conv2_pool) # 5, 6 konv3 = tf.nos.konv2d(conv2_bn, conv3_filter, kroky=[jeden,jeden,jeden,jeden], vypchávka=„ROVNAKÝ“) konv3 = tf.nos.relu(konv3) conv3_pool = tf.nos.max_pool(konv3, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], vypchávka=„ROVNAKÝ“) conv3_bn = tf.vrstiev.batch_normisation(conv3_pool) # 7, 8 konv4 = tf.nos.konv2d(conv3_bn, conv4_filter, kroky=[jeden,jeden,jeden,jeden], vypchávka=„ROVNAKÝ“) konv4 = tf.nos.relu(konv4) conv4_pool = tf.nos.max_pool(konv4, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], vypchávka=„ROVNAKÝ“) conv4_bn = tf.vrstiev.batch_normisation(conv4_pool) # 9 plochý = tf.prispieť.vrstiev.sploštiť(conv4_bn) # 10 plný1 = tf.prispieť.vrstiev.úplne_pripojené(vstupy=plochý, počet_výstupov=128, Activation_fn=tf.nos.relu) plný1 = tf.nos.vypadnúť(plný1, keep_prob) plný1 = tf.vrstiev.batch_normisation(plný1) # jedenásť plný2 = tf.prispieť.vrstiev.úplne_pripojené(vstupy=plný1, počet_výstupov=256, Activation_fn=tf.nos.relu) plný2 = tf.nos.vypadnúť(plný2, keep_prob) plný2 = tf.vrstiev.batch_normisation(plný2) # 12 plný3 = tf.prispieť.vrstiev.úplne_pripojené(vstupy=plný2, počet_výstupov=512, Activation_fn=tf.nos.relu) plný3 = tf.nos.vypadnúť(plný3, keep_prob) plný3 = tf.vrstiev.batch_normisation(plný3) # 13 plný4 = tf.prispieť.vrstiev.úplne_pripojené(vstupy=plný3, počet_výstupov=1024, Activation_fn=tf.nos.relu) plný4 = tf.nos.vypadnúť(plný4, keep_prob) plný4 = tf.vrstiev.batch_normisation(plný4) # 14 von = tf.prispieť.vrstiev.úplne_pripojené(vstupy=plný3, počet_výstupov=10, Activation_fn=Žiadne) návrat von

• Hyperparametre

epochy = 10 batch_size = 128 keep_probability = 0,7 rýchlosť učenia = 0,001

logity = conv_net(X, keep_prob) Model = tf.identita(logity, názov=„logity“) # Názov logits Tensor, aby sa dal po tréningu načítať z disku # Strata a optimalizácia náklady = tf.znížiť_priečinok(tf.nos.softmax_cross_entropy_with_logits(logity=logity, štítky=Y)) optimalizátor = tf.vlak.AdamOptimizer(rýchlosť učenia=rýchlosť učenia).minimalizovať(náklady) # Presnosť správne_pred = tf.rovný(tf.argmax(logity, jeden), tf.argmax(Y, jeden)) presnosť = tf.znížiť_priečinok(tf.obsadenie(správne_pred, tf.float32), názov=„presnosť“)

• Trénujte neurónovú sieť

# Jediná optimalizácia 
def train_neural_network(zasadanie, optimalizátor, keep_probability, feature_batch, label_batch): zasadanie.bežať(optimalizátor, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: keep_probability })

# Zobrazenie štatistík def print_stats(zasadanie, feature_batch, label_batch, náklady, presnosť): strata = sess.bežať(náklady, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: jeden. }) valid_acc = sess.bežať(presnosť, feed_dict={ X: valid_features, Y: platné_štítky, keep_prob: jeden. }) tlačiť(„Strata:{:> 10.4f}Presnosť overenia:{: .6f}„.formát(strata, valid_acc))

• Plné zaškolenie a uloženie modelu

def batch_features_labels(Vlastnosti, štítky, batch_size): '' ' Rozdelte funkcie a štítky do dávok '' ' pre začať v rozsah(0, len(Vlastnosti), batch_size): koniec = min(začať + batch_size, len(Vlastnosti)) výnos Vlastnosti[začať:koniec], štítky[začať:koniec] def load_preprocess_training_batch(batch_id, batch_size): '' ' Načítajte vopred pripravené dáta tréningu a vráťte ich v dávkach alebo menej '' ' názov súboru = 'preprocess_batch_' + p(batch_id) + „.p“ Vlastnosti, štítky = nálev.naložiť(otvorené(názov súboru, režim=„rb“)) # Vráťte údaje o tréningu v dávkach alebo menších návrat batch_features_labels(Vlastnosti, štítky, batch_size)

# Uloženie modelu a cesty 
save_model_path = „./image_classification“ tlačiť(„Školenie ...“) s tf.Session() ako sess: # Inicializácia premenných sess.bežať(tf.global_variables_initializer()) # Tréningový cyklus pre epocha v rozsah(epochy): # Smyčkujte všetky dávky n_batches = 5 pre batch_i v rozsah(jeden, n_batches + jeden): pre batch_features, batch_labels v load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, optimalizátor, keep_probability, batch_features, batch_labels) tlačiť(„Epocha{:> 2}, Šarža CIFAR-10{}: '.formát(epocha + jeden, batch_i), koniec='') print_stats(sess, batch_features, batch_labels, náklady, presnosť) # Uložiť model šetrič = tf.vlak.Šetrič() save_path = šetrič.uložiť(sess, save_model_path)

čo je premenlivé v Jave

Teraz je dôležitá časť klasifikácie obrázkov Tensorflow hotová. Teraz je čas model otestovať.

• Testovanie modelu

dovoz nálev dovoz numpy ako napr. dovoz matplotlib.pyplot ako plt od sklearn.spracovanie dovoz LabelBinarizer def batch_features_labels(Vlastnosti, štítky, batch_size): '' ' Rozdelte funkcie a štítky do dávok '' ' pre začať v rozsah(0, len(Vlastnosti), batch_size): koniec = min(začať + batch_size, len(Vlastnosti)) výnos Vlastnosti[začať:koniec], štítky[začať:koniec] def display_image_predictions(Vlastnosti, štítky, predpovede, top_n_predictions): n_triedy = 10 štítok_názvy = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.fit(rozsah(n_triedy)) label_ids = label_binarizer.inverzná_transformácia(napr..pole(štítky)) obr, osy = plt.subploty(nrow=top_n_predictions, ncols=2, figsize=(dvadsať, 10)) obr.tight_layout() obr.nadpis(„Predpovede Softmax“, veľkosť písma=dvadsať, Y=1.1) n_predpovede = 3 rozpätie = 0,05 ind = napr..divný(n_predpovede) šírka = (jeden. - 2. * rozpätie) / n_predpovede pre obrázok_i, (vlastnosť, label_id, pred_indicies, pred_hodnoty) v vymenovať(PSČ(Vlastnosti, label_ids, predpovede.indexy, predpovede.hodnoty)): ak (obrázok_i < top_n_predictions): pred_names = [štítok_názvy[pred_i] pre pred_i v pred_indicies] správne_názov = štítok_názvy[label_id] osy[obrázok_i] [0].ukáž(((vlastnosť*255).astype(napr..int32, kópia=Falošné)) osy[obrázok_i] [0].set_title(správne_názov) osy[obrázok_i] [0].set_axis_off() osy[obrázok_i] [jeden].barh(ind + rozpätie, pred_hodnoty[:3], šírka) osy[obrázok_i] [jeden].set_yticks(ind + rozpätie) osy[obrázok_i] [jeden].set_yticklabels(pred_names[::-jeden]) osy[obrázok_i] [jeden].set_xticks([0, 0,5, 1.0])

%matplotlib v rade %konfigur InlineBackend.postava_formát = „sietnica“ dovoz tensorflow ako tf dovoz nálev dovoz náhodný save_model_path = „./image_classification“ batch_size = 64 n_vzorky = 10 top_n_predictions = 5 def test_model(): test_features, štítky_testu = nálev.naložiť(otvorené('preprocess_training.p', režim=„rb“)) naložený_graf = tf.Graf() s tf.Session(graf=naložený_graf) ako sess: # Načítanie modelu nakladač = tf.vlak.import_meta_graph(save_model_path + „.meta“) nakladač.obnoviť(sess, save_model_path) # Získajte tenzory z načítaného modelu naložené_x = naložený_graf.get_tensor_by_name('input_x: 0') naložený_r = 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(„presnosť: 0“) # Získajte presnosť v dávkach, aby ste obmedzili pamäť test_batch_acc_total = 0 test_batch_count = 0 pre train_feature_batch, train_label_batch v batch_features_labels(test_features, štítky_testu, batch_size): test_batch_acc_total + = sess.bežať( loaded_acc, feed_dict={naložené_x: train_feature_batch, naložený_r: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = jeden tlačiť(„Presnosť testovania:{} „.formát(test_batch_acc_total/test_batch_count)) # Tlač náhodných vzoriek random_test_features, random_test_labels = násobný(PSČ(*náhodný.vzorka(zoznam(PSČ(test_features, štítky_testu)), n_vzorky))) random_test_predictions = sess.bežať( tf.nos.top_k(tf.nos.softmax(loaded_logits), top_n_predictions), feed_dict={naložené_x: random_test_features, naložený_r: 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()

Výkon: Presnosť testovania: 0,5882762738853503

Teraz, ak trénujete svoju neurónovú sieť na ďalšie epochy alebo zmeníte aktivačnú funkciu, môžete získať iný výsledok, ktorý môže mať lepšiu presnosť.

Týmto sa teda dostávame na koniec tohto článku o klasifikácii obrázkov TensorFlow. Som si istý, že teraz môžete použiť to isté na klasifikáciu akýchkoľvek druhov obrázkov a nie ste začiatočník v klasifikácii obrázkov.

Edureka’s s certifikáciou Python Certification Training je zostavovaný profesionálmi v odbore podľa priemyselných požiadaviek a požiadaviek. Osvojíte si pojmy ako funkcia SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kurz bol špeciálne zostavený odborníkmi v odbore s prípadovými štúdiami v reálnom čase.