Klasifikace obrazu TensorFlow: Vše, co potřebujete vědět o vytváření klasifikátorů budov



Tento článek o klasifikaci obrázků TensorFlow vám poskytne podrobné a komplexní znalosti o klasifikaci obrázků.

Klasifikace obrazu úkol, který zvládne i dítě během několika sekund, ale pro stroj to byl těžký úkol až do nedávného pokroku v a Hluboké učení . Samořiditelná auta mohou detekovat objekty a provádět požadovaná opatření v reálném čase, což je většinou možné z důvodu Klasifikace obrazu. V tomto článku vás provedu následujícími tématy:

Co je TensorFlow?

TensorFlow je Open Source Machine Learning Framework společnosti Google pro programování toku dat v celé řadě úkolů. Uzly v grafu představují matematické operace, zatímco hrany grafu představují vícerozměrná datová pole komunikovaná mezi nimi.





TensorFlow-Image-Recognition
Tenzory jsou jen vícerozměrná pole, rozšíření 2rozměrných tabulek na data s vyšší dimenzí. Existuje mnoho funkcí Tensorflow, díky nimž je vhodný pro Deep Learning a jeho hlavní knihovna otevřeného zdroje vám pomůže vyvíjet a trénovat modely ML.

Co je klasifikace obrazu?

Účelem klasifikace obrazu je roztřídit všechny pixely v digitálním obrazu do jednoho z několika krajinná pokrývka třídy nebo témata . Tato kategorizovaná data mohou být poté použita k výrobě tematické mapy krajinného krytu přítomného na obrázku.



Nyní V závislosti na interakci mezi analytikem a počítačem během klasifikace existují dva typy klasifikace:



  • Pod dohledem
  • Bez dozoru

Takže bez ztráty času se vrhneme na klasifikaci obrazu TensorFlow. Mám 2 příklady: snadné a obtížné. Pojďme k té jednoduché.

Klasifikace obrazu TensorFlow: Fashion MNIST

Módní datová sada MNIST

Zde použijeme datovou sadu Fashion MNIST, která obsahuje 70 000 obrázků ve stupních šedi v 10 kategoriích. 60000 použijeme pro trénink a zbytek 10 000 pro účely testování. K Fashion MNIST můžete přistupovat přímo z TensorFlow, stačí importovat a načíst data.

  • Nejprve importujeme knihovny
z __future__ import absolutní_import, dělení, print_function # TensorFlow a tf.keras import tensorflow jako tf z tensorflow import keras # Pomocné knihovny importovat numpy jako np import matplotlib.pyplot jako plt
  • Načtěte data
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
  • Dále budeme mapovat obrázky do tříd
class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
  • Zkoumání dat
train_images.tvar 
# Každý štítek je mezi 0-9
vlakové_štítky 
test_images.tvar
  • Nyní je čas údaje předem zpracovat.
plt.postava() plt.ukázat(train_images[0]) plt.barevný pruh() plt.mřížka(Nepravdivé) plt.ukázat() 
#Pokud zkontrolujete první obrázek v tréninkové sadě, uvidíte, že hodnoty pixelů spadají do rozsahu 0 až 255.

  • Musíme měřítko obrázků od 0 do 1, abychom je přenesli do neuronové sítě
train_images = train_images / 255,0 test_images = test_images / 255,0
  • Podívejme se na pár obrázků.
plt.postava(figsize=(10,10)) pro i v rozsah(25): plt.subplot(5,5,i+jeden) plt.xticks([]) plt.yticks([]) plt.mřížka(Nepravdivé) plt.ukázat(train_images[i], cmap=plt.cm.binární) plt.xlabel(názvy tříd[vlakové_štítky[i]])) plt.ukázat()
 

  • Nastavit vrstvy
Modelka = tvrdý.Sekvenční([ tvrdý.vrstvy.Zploštit(input_shape=(28, 28)), tvrdý.vrstvy.Hustý(128, aktivace=tf.nos.relu), tvrdý.vrstvy.Hustý(10, aktivace=tf.nos.softmax) ])
  • Zkompilujte model
Modelka.kompilovat(optimalizátor='adam', ztráta='sparse_categorical_crossentropy', metriky=['přesnost'])
  • Model Training
Modelka.vejít se(train_images, vlakové_štítky, epochy=10)

  • Vyhodnocení přesnosti
test_loss, test_acc = Modelka.vyhodnotit(test_images, test_labels) vytisknout(„Přesnost zkoušky:“, test_acc)

  • Vytváření předpovědí
předpovědi = Modelka.předpovědět(test_images)
předpovědi[0]

Predikce je pole 10 čísel. Ty popisují „jistotu“ modelu, že obraz odpovídá každému z 10 různých oděvních předmětů. Vidíme, který štítek má nejvyšší hodnotu spolehlivosti.

např..argmax(předpovědi[0])#Model si je jistý, že jde o kotníkové boty. Uvidíme, jestli je to správné

Výstup: 9

test_labels[0]

Výstup: 9

  • Nyní je čas podívat se na celou sadu 10 kanálů
def plot_image(i, predictions_array, true_label, obr): predictions_array, true_label, obr = predictions_array[i], true_label[i], obr[i] plt.mřížka(Nepravdivé) plt.xticks([]) plt.yticks([]) plt.ukázat(obr, cmap=plt.cm.binární) predikovaný_štítek = např..argmax(predictions_array) -li predikovaný_štítek == true_label: barva = 'zelený' jiný: barva = 'síť' plt.xlabel(''{} {: 2,0f}% ({}) '.formát(názvy tříd[predikovaný_štítek], 100*např..max(predictions_array), názvy tříd[true_label]), barva=barva) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.mřížka(Nepravdivé) plt.xticks([]) plt.yticks([]) tento obrázek = plt.bar(rozsah(10), predictions_array, barva=„# 777777“) plt.ylim([0, jeden]) predikovaný_štítek = např..argmax(predictions_array) tento obrázek[predikovaný_štítek].set_color('síť') tento obrázek[true_label].set_color('zelený')
  • Nejprve se podívejme na 0. a 10. obrázek
i = 0 plt.postava(figsize=(6,3)) plt.subplot(jeden,2,jeden) plot_image(i, předpovědi, test_labels, test_images) plt.subplot(jeden,2,2) plot_value_array(i, předpovědi, test_labels) plt.ukázat()

i = 10 plt.postava(figsize=(6,3)) plt.subplot(jeden,2,jeden) plot_image(i, předpovědi, test_labels, test_images) plt.subplot(jeden,2,2) plot_value_array(i, předpovědi, test_labels) plt.ukázat()

  • Nyní nakreslíme několik obrázků a jejich předpovědi. Správné jsou zelené, zatímco nesprávné jsou červené.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.postava(figsize=(2*2*num_cols, 2*num_rows)) pro i v rozsah(num_images): plt.subplot(num_rows, 2*num_cols, 2*i+jeden) plot_image(i, předpovědi, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, předpovědi, test_labels) plt.ukázat()

  • Nakonec použijeme trénovaný model k vytvoření předpovědi o jediném obrázku.
# Pořiďte obrázek z testovací datové sady obr = test_images[0] vytisknout(obr.tvar)
# Přidejte obrázek do dávky, kde je jediným členem. obr = (např..expand_dims(obr,0)) vytisknout(obr.tvar)
predictions_single = Modelka.předpovědět(obr) vytisknout(predictions_single)

plot_value_array(0, predictions_single, test_labels) plt.xticks(rozsah(10), názvy tříd, otáčení=Čtyři pět) plt.ukázat()

  • Jak vidíte předpověď pro náš jediný dávkový obrázek.
prediction_result = např..argmax(predictions_single[0])

Výstup: 9

CIFAR-10: CNN

Datová sada CIFAR-10 se skládá z letadel, psů, koček a dalších předmětů. Předpracujete obrázky a poté na všech vzorcích trénujete konvoluční neuronovou síť. Obrázky musí být normalizovány a štítky musí být kódovány za horka. Tento případ použití jistě vymaže vaše pochybnosti o klasifikaci obrazu TensorFlow.

  • Stahování dat
z urllib.request import urlretrieve z os. cesta import isfile, jsou saze z tqdm import tqdm import tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' třída DownloadProgress(tqdm): last_block = 0 def háček(, block_num=jeden, block_size=jeden, Celková velikost=Žádný): .celkový = Celková velikost .Aktualizace(((block_num - .last_block) * block_size) .last_block = block_num '' ' zkontrolujte, zda je datový (zip) soubor již stažen pokud ne, stáhněte si jej z 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' a uložte jej jako cifar-10-python.tar.gz '' ' -li ne isfile('cifar-10-python.tar.gz'): s DownloadProgress(jednotka='B', unit_scale=Skutečný, minitery=jeden, popis=‚Datová sada CIFAR-10 ') tak jako pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“, 'cifar-10-python.tar.gz', pbar.háček) -li ne jsou saze(cifar10_dataset_folder_path): s tarfile.otevřeno('cifar-10-python.tar.gz') tak jako dehet: dehet.extrahovat vše() dehet.zavřít()
  • Import nezbytných knihoven
import lák import numpy tak jako např. import matplotlib.pyplot tak jako plt
  • Porozumění datům

Původní dávka dat je 10 000 × 3072 tenzorů vyjádřených v numpy poli, kde 10 000 je počet ukázkových dat. Obrázek je barevný a má velikost 32 × 32. Krmení lze provádět buď ve formátu (šířka x výška x počet_kanálů) nebo (počet_kanálů x šířka x výška). Pojďme definovat štítky.

def load_label_names(): vrátit se ['letoun', 'automobil', 'pták', 'kočka', 'Jelen', 'Pes', 'žába', 'kůň', 'loď', 'kamion']
  • Přetváření dat

Data změníme ve dvou fázích

Nejprve rozdělte vektor řádků (3072) na 3 kusy. Každý kus odpovídá každému kanálu. Výsledkem je (3 x 1024) rozměr tenzoru. Potom rozdělte výsledný tenzor z předchozího kroku číslem 32. 32 zde znamená šířku obrázku. Výsledkem je (3x32x32).

Za druhé, musíme převést data z (num_channel, width, height) do (width, height, num_channel). K tomu použijeme funkci transpozice.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): s otevřeno(cifar10_dataset_folder_path + '/ data_batch_' + str(batch_id), režimu='rb') tak jako soubor: # všimněte si, že typ kódování je 'latin1' šarže = lák.zatížení(soubor, kódování='latin1') funkce = šarže['data'].přetvarovat(((jen(šarže['data']), 3, 32, 32)).přemístit(0, 2, 3, jeden) štítky = šarže['štítky'] vrátit se funkce, označení
  • Zkoumání dat
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): funkce, štítky = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) -li ne (0 <= sample_id < jen(funkce)): vytisknout(''{}vzorky v dávce{}.{}je mimo dosah. “.formát(jen(funkce), batch_id, sample_id)) vrátit se Žádný vytisknout('' Statistiky dávky #{}: '.formát(batch_id)) vytisknout('Počet vzorků:{} ''.formát(jen(funkce))) label_names = load_label_names() label_counts = diktát(zip(*např..unikátní(štítky, návratové_účty=Skutečný))) pro klíč, hodnota v label_counts.položky(): vytisknout(„Počty štítků [{}] ({}):{}''.formát(klíč, label_names[klíč].horní(), hodnota)) sample_image = funkce[sample_id] sample_label = štítky[sample_id] vytisknout('' Příklad obrázku{}: '.formát(sample_id)) vytisknout(„Obrázek - minimální hodnota:{}Maximální hodnota:{}''.formát(sample_image.min(), sample_image.max())) vytisknout(„Obrázek - tvar:{}''.formát(sample_image.tvar)) vytisknout(„Štítek - ID štítku:{}Název:{}''.formát(sample_label, label_names[sample_label])) plt.ukázat(sample_image)
%matplotlib v souladu %konfigurace InlineBackend.formát_formátu = 'sítnice' import numpy tak jako např. # Prozkoumejte datovou sadu batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

  • Implementace funkcí předzpracování

Budeme normalizovat data pomocí Min-Max normalizace. Díky tomu se všechny hodnoty x jednoduše pohybují mezi 0 a 1.
y = (x-min) / (max-min)

def normalizovat(X): '' ' argument - x: vstupní obrazová data v numpy poli [32, 32, 3] vrátit se - normalizováno x '' ' min_val = např..min(X) max_val = např..max(X) X = (X-min_val) / (max_val-min_val) vrátit se X
  • One-Hot Encode
def one_hot_encode(X): '' ' argument - x: seznam štítků vrátit se - jedna horká kódovací matice (počet štítků, počet tříd) '' ' kódovaný = např..nuly(((jen(X), 10)) pro idx, hod v vyjmenovat(X): kódovaný[idx] [hod] = jeden vrátit se kódovaný
  • Předběžné zpracování a uložení dat
def _preproces_a_uložit(normalizovat, one_hot_encode, funkce, štítky, název souboru): funkce = normalizovat(funkce) štítky = one_hot_encode(štítky) lák.skládka(((funkce, štítky), otevřeno(název souboru, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizovat, one_hot_encode): n_batches = 5 valid_features = [] platné_štítky = [] pro batch_i v rozsah(jeden, n_batches + jeden): funkce, štítky = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # find index to the point as validation data in the whole dataset of the batch (10%) index_of_validation = int(jen(funkce) * 0,1) # předzpracovat 90% celého datového souboru dávky # - normalizovat funkce # - one_hot_encode štítky # - uložit do nového souboru s názvem 'preprocess_batch_' + batch_number # - každý soubor pro každou dávku _preproces_a_uložit(normalizovat, one_hot_encode, funkce[:-index_of_validation], štítky[:-index_of_validation], 'preprocess_batch_' + str(batch_i) + '.p') # na rozdíl od tréninkové datové sady bude validační datová sada přidána do všech dávkových datových sad # - vezměte 10% z kompletního datového souboru dávky # - přidejte je do seznamu # - valid_features # - platné_štítky valid_features.rozšířit(funkce[-index_of_validation:]) platné_štítky.rozšířit(štítky[-index_of_validation:]) # předzpracovat všechny naskládané datové sady ověření _preproces_a_uložit(normalizovat, one_hot_encode, např..pole(valid_features), např..pole(platné_štítky), 'preprocess_validation.p') # načtěte testovací datovou sadu s otevřeno(cifar10_dataset_folder_path + '/ test_batch', režimu='rb') tak jako soubor: šarže = lák.zatížení(soubor, kódování='latin1') # předzpracovat testovací data test_features = šarže['data'].přetvarovat(((jen(šarže['data']), 3, 32, 32)).přemístit(0, 2, 3, jeden) test_labels = šarže['štítky'] # Předběžné zpracování a uložení všech testovacích dat _preproces_a_uložit(normalizovat, one_hot_encode, např..pole(test_features), např..pole(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalizovat, one_hot_encode)
  • Kontrolní bod
import lák valid_features, platné_štítky = lák.zatížení(otevřeno('preprocess_validation.p', režimu='rb'))
  • Budování sítě

Celý model se skládá celkem ze 14 vrstev.

import tensorflow tak jako tf def conv_net(X, keep_prob): conv1_filter = tf.Variabilní(tf.zkrácený_normální(tvar=[3, 3, 3, 64], znamenat=0, stddev=0,08)) conv2_filter = tf.Variabilní(tf.zkrácený_normální(tvar=[3, 3, 64, 128], znamenat=0, stddev=0,08)) conv3_filter = tf.Variabilní(tf.zkrácený_normální(tvar=[5, 5, 128, 256], znamenat=0, stddev=0,08)) conv4_filter = tf.Variabilní(tf.zkrácený_normální(tvar=[5, 5, 256, 512], znamenat=0, stddev=0,08)) # 1, 2 konv1 = tf.nos.conv2d(X, conv1_filter, kroky=[jeden,jeden,jeden,jeden], polstrování='STEJNÝ') konv1 = tf.nos.relu(konv1) conv1_pool = tf.nos.max_pool(konv1, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], polstrování='STEJNÝ') conv1_bn = tf.vrstvy.batch_normalization(conv1_pool) # 3. 4 konv2 = tf.nos.conv2d(conv1_bn, conv2_filter, kroky=[jeden,jeden,jeden,jeden], polstrování='STEJNÝ') konv2 = tf.nos.relu(konv2) conv2_pool = tf.nos.max_pool(konv2, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], polstrování='STEJNÝ') conv2_bn = tf.vrstvy.batch_normalization(conv2_pool) # 5, 6 konv3 = tf.nos.conv2d(conv2_bn, conv3_filter, kroky=[jeden,jeden,jeden,jeden], polstrování='STEJNÝ') konv3 = tf.nos.relu(konv3) conv3_pool = tf.nos.max_pool(konv3, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], polstrování='STEJNÝ') conv3_bn = tf.vrstvy.batch_normalization(conv3_pool) # 7, 8 konv4 = tf.nos.conv2d(conv3_bn, conv4_filter, kroky=[jeden,jeden,jeden,jeden], polstrování='STEJNÝ') konv4 = tf.nos.relu(konv4) conv4_pool = tf.nos.max_pool(konv4, ksize=[jeden,2,2,jeden], kroky=[jeden,2,2,jeden], polstrování='STEJNÝ') conv4_bn = tf.vrstvy.batch_normalization(conv4_pool) # 9 byt = tf.přispět.vrstvy.zploštit(conv4_bn) # 10 plný1 = tf.přispět.vrstvy.plně_připojeno(vstupy=byt, num_outputs=128, Activation_fn=tf.nos.relu) plný1 = tf.nos.výpadek(plný1, keep_prob) plný1 = tf.vrstvy.batch_normalization(plný1) # jedenáct plný2 = tf.přispět.vrstvy.plně_připojeno(vstupy=plný1, num_outputs=256, Activation_fn=tf.nos.relu) plný2 = tf.nos.výpadek(plný2, keep_prob) plný2 = tf.vrstvy.batch_normalization(plný2) # 12 plný3 = tf.přispět.vrstvy.plně_připojeno(vstupy=plný2, num_outputs=512, Activation_fn=tf.nos.relu) plný3 = tf.nos.výpadek(plný3, keep_prob) plný3 = tf.vrstvy.batch_normalization(plný3) # 13 plný4 = tf.přispět.vrstvy.plně_připojeno(vstupy=plný3, num_outputs=1024, Activation_fn=tf.nos.relu) plný4 = tf.nos.výpadek(plný4, keep_prob) plný4 = tf.vrstvy.batch_normalization(plný4) # 14 ven = tf.přispět.vrstvy.plně_připojeno(vstupy=plný3, num_outputs=10, Activation_fn=Žádný) vrátit se ven
  • Hyperparametry
epochy = 10 objem várky = 128 keep_probability = 0,7 rychlost učení = 0,001
logity = conv_net(X, keep_prob) Modelka = tf.identita(logity, název='logits') # Název logitů Tensor, který lze po tréninku načíst z disku # Ztráta a optimalizátor náklady = tf.snížit_průměr(tf.nos.softmax_cross_entropy_with_logits(logity=logity, štítky=Y)) optimalizátor = tf.vlak.AdamOptimizer(rychlost učení=rychlost učení).minimalizovat(náklady) # Přesnost correct_pred = tf.rovnat se(tf.argmax(logity, jeden), tf.argmax(Y, jeden)) přesnost = tf.snížit_průměr(tf.obsazení(correct_pred, tf.float32), název='přesnost')
  • Trénujte neuronovou síť
# Jediná optimalizace 
def
train_neural_network(zasedání, optimalizátor, keep_probability, feature_batch, štítek_batch): zasedání.běh(optimalizátor, feed_dict={ X: feature_batch, Y: štítek_batch, keep_prob: keep_probability })
# Zobrazování statistik def print_stats(zasedání, feature_batch, štítek_batch, náklady, přesnost): ztráta = sess.běh(náklady, feed_dict={ X: feature_batch, Y: štítek_batch, keep_prob: jeden. }) valid_acc = sess.běh(přesnost, feed_dict={ X: valid_features, Y: platné_štítky, keep_prob: jeden. }) vytisknout('Ztráta:{:> 10.4f}Přesnost ověření:{: .6f}''.formát(ztráta, valid_acc))
  • Plné školení a uložení modelu
def batch_features_labels(funkce, štítky, objem várky): '' ' Rozdělte funkce a štítky do dávek '' ' pro Start v rozsah(0, jen(funkce), objem várky): konec = min(Start + objem várky, jen(funkce)) výtěžek funkce[Start:konec], štítky[Start:konec] def load_preprocess_training_batch(batch_id, objem várky): '' ' Načtěte předzpracovaná data školení a vraťte je v dávkách nebo méně '' ' název souboru = 'preprocess_batch_' + str(batch_id) + '.p' funkce, štítky = lák.zatížení(otevřeno(název souboru, režimu='rb')) # Vraťte tréninková data v dávkách nebo méně vrátit se batch_features_labels(funkce, štítky, objem várky)
# Uložení modelu a cesty 
save_model_path
= './image_classification' vytisknout('Výcvik...') s tf.Zasedání() tak jako sess: # Inicializace proměnných sess.běh(tf.global_variables_initializer()) # Tréninkový cyklus pro epocha v rozsah(epochy): # Smyčkujte všechny dávky n_batches = 5 pro batch_i v rozsah(jeden, n_batches + jeden): pro batch_features, batch_labels v load_preprocess_training_batch(batch_i, objem várky): train_neural_network(sess, optimalizátor, keep_probability, batch_features, batch_labels) vytisknout('Epocha{:> 2}, Dávka CIFAR-10{}: '.formát(epocha + jeden, batch_i), konec='') print_stats(sess, batch_features, batch_labels, náklady, přesnost) # Uložit model spořič = tf.vlak.Spořič() save_path = spořič.Uložit(sess, save_model_path)

co je proměnlivé v Javě

Nyní je důležitá část klasifikace obrazu Tensorflow hotová. Nyní je čas model otestovat.

  • Testování modelu
import lák import numpy tak jako např. import matplotlib.pyplot tak jako plt z sklearn.zpracování import LabelBinarizer def batch_features_labels(funkce, štítky, objem várky): '' ' Rozdělte funkce a štítky do dávek '' ' pro Start v rozsah(0, jen(funkce), objem várky): konec = min(Start + objem várky, jen(funkce)) výtěžek funkce[Start:konec], štítky[Start:konec] def display_image_predictions(funkce, štítky, předpovědi, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.vejít se(rozsah(n_classes)) label_ids = label_binarizer.inverzní_transformace(např..pole(štítky)) obr, osy = plt.subploty(nrow=top_n_predictions, ncols=2, figsize=(dvacet, 10)) obr.tight_layout() obr.nadpis(„Softmax předpovědi“, velikost písma=dvacet, Y=1.1) n_předpovědi = 3 okraj = 0,05 ind = např..divný(n_předpovědi) šířka = (jeden. - 2. * okraj) / n_předpovědi pro image_i, (Vlastnosti, label_id, pred_indicies, pred_values) v vyjmenovat(zip(funkce, label_ids, předpovědi.indexy, předpovědi.hodnoty)): -li (image_i < top_n_predictions): pred_names = [label_names[pred_i] pro pred_i v pred_indicies] správné_jméno = label_names[label_id] osy[image_i] [0].ukázat(((Vlastnosti*255).astype(např..int32, kopírovat=Nepravdivé)) osy[image_i] [0].set_title(správné_jméno) osy[image_i] [0].set_axis_off() osy[image_i] [jeden].barh(ind + okraj, pred_values[:3], šířka) osy[image_i] [jeden].set_yticks(ind + okraj) osy[image_i] [jeden].set_yticklabels(pred_names[::-jeden]) osy[image_i] [jeden].set_xticks([0, 0,5, 1.0])
%matplotlib v souladu %konfigurace InlineBackend.formát_formátu = 'sítnice' import tensorflow tak jako tf import lák import náhodný save_model_path = './image_classification' objem várky = 64 n_vzorky = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = lák.zatížení(otevřeno('preprocess_training.p', režimu='rb')) loaded_graph = tf.Graf() s tf.Zasedání(graf=loaded_graph) tak jako sess: # Načíst model nakladač = tf.vlak.import_meta_graph(save_model_path + '.meta') nakladač.obnovit(sess, save_model_path) # Získejte tenzory z načteného modelu loaded_x = loaded_graph.get_tensor_by_name('input_x: 0') naloženo_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('přesnost: 0') # Získejte přesnost v dávkách pro omezení paměti test_batch_acc_total = 0 test_batch_count = 0 pro train_feature_batch, train_label_batch v batch_features_labels(test_features, test_labels, objem várky): test_batch_acc_total + = sess.běh( loaded_acc, feed_dict={loaded_x: train_feature_batch, naloženo_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = jeden vytisknout(„Přesnost testování:{} ''.formát(test_batch_acc_total/test_batch_count)) # Tisk náhodných vzorků random_test_features, random_test_labels = n-tice(zip(*náhodný.vzorek(seznam(zip(test_features, test_labels)), n_vzorky))) random_test_predictions = sess.běh( tf.nos.top_k(tf.nos.softmax(loaded_logits), top_n_predictions), feed_dict={loaded_x: random_test_features, naloženo_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()

Výstup: Přesnost testování: 0,5882762738853503

Nyní, když trénujete svou neurální síť na více epoch nebo měníte aktivační funkci, můžete získat jiný výsledek, který může mít lepší přesnost.

Tímto jsme tedy dosáhli konce tohoto článku o klasifikaci obrázků TensorFlow. Jsem si jist, že nyní můžete použít stejné ke klasifikaci jakéhokoli druhu obrázků a nejste začátečník klasifikace obrázků.

Edureka s certifikací Python Training je kurátorem profesionálů v oboru podle požadavků a požadavků odvětví. Osvojíte si pojmy jako funkce SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kurz byl speciálně připraven odborníky z oboru s případovými studiemi v reálném čase.