Clasificarea imaginilor TensorFlow: Tot ce trebuie să știți despre clasificatoarele de clădiri

Clasificarea imaginilor o sarcină pe care chiar și un bebeluș o poate face în câteva secunde, dar pentru o mașină, a fost o sarcină grea până la progresele recente în și Invatare profunda . Autovehiculele care conduc singuri pot detecta obiecte și pot lua măsurile necesare în timp real, iar cele mai multe dintre acestea sunt posibile din cauza Clasificarea imaginilor. În acest articol, vă voi ghida prin următoarele subiecte:

• Ce este TensorFlow?
• Ce este clasificarea imaginilor?
• Clasificarea imaginilor TensorFlow: Fashion MNIST
• CIFAR 10: CNN

Ce este TensorFlow?

TensorFlow este Open Source Machine Learning Framework de la Google pentru programarea fluxului de date într-o serie de sarcini. Nodurile din grafic reprezintă operații matematice, în timp ce marginile graficului reprezintă matricile de date multidimensionale comunicate între ele.

Tensorii sunt doar tablouri multidimensionale, o extensie a tabelelor bidimensionale la date cu o dimensiune mai mare. Există multe caracteristici ale Tensorflow, ceea ce îl face adecvat pentru Deep Learning și biblioteca principală open source vă ajută să dezvoltați și să instruiți modele ML.

Ce este clasificarea imaginilor?

Intenția Clasificării imaginilor este de a clasifica toți pixelii dintr-o imagine digitală într-unul din mai mulți acoperirea terenului clase sau teme . Aceste date clasificate pot fi apoi utilizate pentru a produce hărți tematice a acoperirii terenurilor prezente într-o imagine.

Acum În funcție de interacțiunea dintre analist și computer în timpul clasificării, există două tipuri de clasificare:

• Supravegheat &
• Fără supraveghere

Așadar, fără a pierde timp, să trecem la clasificarea TensorFlow Image. Am 2 exemple: ușor și dificil. Să continuăm cu cea ușoară.

Clasificarea imaginilor TensorFlow: Fashion MNIST

argumente pro și contra hacking-ului

Set de date Fashion MNIST

Aici vom folosi setul de date Fashion MNIST, care conține 70.000 de imagini în tonuri de gri în 10 categorii. Vom folosi 60000 pentru antrenament, iar restul 10000 pentru testare. Puteți accesa Fashion MNIST direct din TensorFlow, trebuie doar să importați și să încărcați datele.

• Să importăm mai întâi bibliotecile

din __future__ import absolut_import, diviziune, print_function # TensorFlow și tf.keras importă tensorflow ca tf din tensorflow keras # Bibliotecile de asistență importă numpy ca np import matplotlib.pyplot ca plt

• Să încărcăm datele

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

• Apoi, vom mapa imaginile în clase

class_names = ['Tricou / top', 'Pantaloni', 'Pulover', 'Rochie', 'Palton', 'Sandală', 'Cămașă', 'Adidași', 'Geantă', 'Botină']

• Explorarea datelor

imagini_tren.formă 
# Fiecare etichetă este între 0-9

etichete_tren 
imagini_test.formă 

• Acum, este timpul să pre-procesăm datele.

plt.figura() plt.imshow(imagini_tren[0]) plt.bara de culori() plt.grilă(Fals) plt.spectacol() 
#Dacă inspectați prima imagine din setul de antrenament, veți vedea că valorile pixelilor se încadrează în intervalul 0 - 255. 

• Trebuie să redimensionăm imaginile de la 0 la 1 pentru a le alimenta în rețeaua neuronală

imagini_tren = imagini_tren / 255,0 imagini_test = imagini_test / 255,0

• Să afișăm câteva imagini.

plt.figura(figsize=(10,10))) pentru eu în gamă(25): plt.subtrama(5,5,eu+unu) plt.xticks([]) plt.yticks([]) plt.grilă(Fals) plt.imshow(imagini_tren[eu], cmap=plt.cm.binar) plt.xlabel(nume_clasă[etichete_tren[eu]]) plt.spectacol()

• Configurați straturile

model = greu.Secvențial([ greu.straturi.Aplatiza(input_shape=(28, 28)), greu.straturi.Dens(128, activare=tf.nr.relu), greu.straturi.Dens(10, activare=tf.nr.softmax) ])

• Compilați modelul

model.compila(optimizator=„Adam”, pierderi=„sparse_categorical_crossentropy”, valori=['precizie'])

• Antrenament model

model.potrivi(imagini_tren, etichete_tren, epoci=10)

• Evaluarea exactității

test_loss, test_acc = model.a evalua(imagini_test, etichete_test) imprimare(„Precizia testului:”, test_acc)

• Făcând predicții

predicții = model.prezice(imagini_test)

predicții[0]

O predicție este o matrice de 10 numere. Acestea descriu „încrederea” modelului că imaginea corespunde fiecăruia dintre cele 10 articole de îmbrăcăminte diferite. Putem vedea care etichetă are cea mai mare valoare de încredere.

de exemplu..argmax(predicții[0])#Model este cel mai încrezător că este o botină. Să vedem dacă este corect

Ieșire: 9

etichete_test[0]

Ieșire: 9

• Acum, este timpul să ne uităm la setul complet de 10 canale

def imagine_plot(eu, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[eu], true_label[eu], img[eu] plt.grilă(Fals) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binar) etichetă_prevăzută = de exemplu..argmax(predictions_array) dacă etichetă_prevăzută == true_label: culoare = 'verde' altceva: culoare = 'net' plt.xlabel('{} {: 2.0f}% ({}) '.format(nume_clasă[etichetă_prevăzută], 100*de exemplu..max(predictions_array), nume_clasă[true_label]), culoare=culoare) def plot_value_array(eu, predictions_array, true_label): predictions_array, true_label = predictions_array[eu], true_label[eu] plt.grilă(Fals) plt.xticks([]) plt.yticks([]) acest complot = plt.bar(gamă(10), predictions_array, culoare=„# 777777”) plt.ylim([0, unu]) etichetă_prevăzută = de exemplu..argmax(predictions_array) acest complot[etichetă_prevăzută].set_color('net') acest complot[true_label].set_color('verde')

• Să vedem mai întâi imaginea a 0-a și a 10-a

eu = 0 plt.figura(figsize=(6,3))) plt.subtrama(unu,2,unu) imagine_plot(eu, predicții, etichete_test, imagini_test) plt.subtrama(unu,2,2) plot_value_array(eu, predicții, etichete_test) plt.spectacol()

eu = 10 plt.figura(figsize=(6,3))) plt.subtrama(unu,2,unu) imagine_plot(eu, predicții, etichete_test, imagini_test) plt.subtrama(unu,2,2) plot_value_array(eu, predicții, etichete_test) plt.spectacol()

• Acum, să trasăm mai multe imagini și predicțiile lor. Cele corecte sunt verzi, în timp ce cele incorecte sunt roșii.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figura(figsize=(2*2*num_cols, 2*num_rows))) pentru eu în gamă(num_images): plt.subtrama(num_rows, 2*num_cols, 2*eu+unu) imagine_plot(eu, predicții, etichete_test, imagini_test) plt.subtrama(num_rows, 2*num_cols, 2*eu+2) plot_value_array(eu, predicții, etichete_test) plt.spectacol()

• În cele din urmă, vom folosi modelul instruit pentru a face o predicție despre o singură imagine.

# Prindeți o imagine din setul de date de testare img = imagini_test[0] imprimare(img.formă)

# Adăugați imaginea la un lot unde este singurul membru. img = (de exemplu..expand_dims(img,0))) imprimare(img.formă)

predicții_singur = model.prezice(img) imprimare(predicții_singur)

plot_value_array(0, predicții_singur, etichete_test) plt.xticks(gamă(10), nume_clasă, rotație=Patru cinci) plt.spectacol()

• După cum puteți vedea, predicția pentru singura noastră imagine în lot.

prezicere_rezultat = de exemplu..argmax(predicții_singur[0])

Ieșire: 9

CIFAR-10: CNN

Setul de date CIFAR-10 este format din avioane, câini, pisici și alte obiecte. Veți preprocesa imaginile, apoi veți antrena o rețea neuronală convoluțională pe toate eșantioanele. Imaginile trebuie normalizate, iar etichetele trebuie să fie codificate cu o singură temperatură. Acest caz de utilizare vă va clarifica cu siguranță îndoielile cu privire la clasificarea imaginilor TensorFlow.

• Descărcarea datelor

din urllib.solicitare import urlretrieve din os.path import este fișier, este funingine din tqdm import tqdm import tarfile cifar10_dataset_folder_path = „cifar-10-batches-py” clasă DownloadProgress(tqdm): last_block = 0 def cârlig(de sine, bloc_num=unu, block_size=unu, marimea totala=Nici unul): de sine.total = marimea totala de sine.Actualizați((bloc_num - de sine.last_block) * block_size) de sine.last_block = bloc_num '' ' verificați dacă fișierul de date (zip) este deja descărcat dacă nu, descărcați-l din „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz” și salvați ca cifar-10-python.tar.gz '' ' dacă nu este fișier(„cifar-10-python.tar.gz”): cu DownloadProgress(unitate=„B”, unitate_scală=Adevărat, minitere=unu, desc=„Set de date CIFAR-10”) la fel de pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz”, „cifar-10-python.tar.gz”, pbar.cârlig) dacă nu este funingine(cifar10_dataset_folder_path): cu tarfile.deschis(„cifar-10-python.tar.gz”) la fel de gudron: gudron.extrage tot() gudron.închide()

• Importul bibliotecilor necesare

import murături import neclintit la fel de de exemplu. import matplotlib.pyplot la fel de plt

• Înțelegerea datelor

Lotul original de date este 10000 × 3072 tensor exprimat într-o matrice numpy, unde 10000 este numărul de date eșantion. Imaginea este colorată și are dimensiunea 32 × 32. Alimentarea se poate face fie într-un format de (lățime x înălțime x num_canal), fie (num_canal x lățime x înălțime). Să definim etichetele.

def load_label_names(): întoarcere ['avion', 'auto', 'pasăre', 'pisică', 'cerb', 'câine', 'broască', 'cal', 'navă', 'camion']

• Remodelarea datelor

Vom remodela datele în două etape

În primul rând, împărțiți vectorul rând (3072) în 3 bucăți. Fiecare piesă corespunde fiecărui canal. Aceasta are ca rezultat dimensiunea (3 x 1024) a unui tensor. Apoi împărțiți tensorul rezultat de la pasul anterior cu 32. 32 aici înseamnă lățimea unei imagini. Acest lucru are ca rezultat (3x32x32).

În al doilea rând, trebuie să transpunem datele de la (num_canal, lățime, înălțime) la (lățime, înălțime, num_canal). Pentru aceasta, vom folosi funcția de transpunere.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): cu deschis(cifar10_dataset_folder_path + '/ data_batch_' + str(batch_id), modul=„rb”) la fel de fişier: # rețineți că tipul de codificare este „latin1” lot = murături.sarcină(fişier, codificare=„latin1”) Caracteristici = lot['date'].remodela((len(lot['date']), 3, 32, 32))).transpune(0, 2, 3, unu) etichete = lot[„etichete”] întoarcere Caracteristici, eticheta

• Explorarea datelor

def display_stats(cifar10_dataset_folder_path, batch_id, id_șantion): Caracteristici, etichete = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) dacă nu (0 <= id_șantion < len(Caracteristici)): imprimare('{}probe în lot{}.{}este în afara razei de acțiune. '.format(len(Caracteristici), batch_id, id_șantion))) întoarcere Nici unul imprimare(' Statistici ale lotului #{}: '.format(batch_id))) imprimare('# de probe:{} '.format(len(Caracteristici))) label_names = load_label_names() etichetă_conturi = dict(fermoar(*de exemplu..unic(etichete, return_counts=Adevărat))) pentru cheie, valoare în etichetă_conturi.obiecte(): imprimare(„Numărul de etichete pentru [{}] ({}):{}'.format(cheie, label_names[cheie].superior(), valoare))) imagine_eșantion = Caracteristici[id_șantion] sample_label = etichete[id_șantion] imprimare(' Exemplu de imagine{}: '.format(id_șantion))) imprimare('Imagine - Valoare minimă:{}Valoare maximă:{}'.format(imagine_eșantion.min(), imagine_eșantion.max())) imprimare(„Imagine - Formă:{}'.format(imagine_eșantion.formă))) imprimare(„Etichetă - Cod etichetă:{}Nume:{}'.format(sample_label, label_names[sample_label])) plt.imshow(imagine_eșantion)

%matplotlib in linie %config InlineBackend.figure_format = 'retină' import neclintit la fel de de exemplu. # Explorează setul de date batch_id = 3 id_șantion = 7000 display_stats(cifar10_dataset_folder_path, batch_id, id_șantion)

• Implementarea funcțiilor de preprocesare

Vom normaliza datele prin normalizarea Min-Max. Acest lucru face ca toate valorile x să fie cuprinse între 0 și 1.
y = (x-min) / (max-min)

def normaliza(X): '' ' argument - x: introducerea datelor de imagine în matrice numpy [32, 32, 3] întoarcere - x normalizat '' ' min_val = de exemplu..min(X) max_val = de exemplu..max(X) X = (X-min_val) / (max_val-min_val) întoarcere X

• One-Hot Encode

def one_hot_encode(X): '' ' argument - x: o listă de etichete întoarcere - o matrice de codare la cald (număr de etichete, număr de clase) '' ' codificat = de exemplu..zerouri((len(X), 10))) pentru idx, ore în enumerate(X): codificat[idx] [ore] = unu întoarcere codificat

• Preprocesați și salvați datele

def _preprocesare_și_salvare(normaliza, one_hot_encode, Caracteristici, etichete, nume de fișier): Caracteristici = normaliza(Caracteristici) etichete = one_hot_encode(etichete) murături.dump((Caracteristici, etichete), deschis(nume de fișier, „wb”))) def preprocess_and_save_data(cifar10_dataset_folder_path, normaliza, one_hot_encode): n_batches = 5 caracteristici_valide = [] etichete_valide = [] pentru lot_i în gamă(unu, n_batches + unu): Caracteristici, etichete = load_cfar10_batch(cifar10_dataset_folder_path, lot_i) # găsiți indexul pentru a fi punctul ca date de validare în întregul set de date al lotului (10%) index_de_validare = int(len(Caracteristici) * 0,1) # preprocesați 90% din întregul set de date al lotului # - normalizează caracteristicile # - one_hot_encode lables # - salvați într-un fișier nou numit, 'preprocess_batch_' + batch_number # - fiecare fișier pentru fiecare lot _prelucrare_și_salvare(normaliza, one_hot_encode, Caracteristici[:-index_de_validare], etichete[:-index_de_validare], „preprocess_batch_” + str(lot_i) + „.p”) # spre deosebire de setul de date de antrenament, setul de date de validare va fi adăugat prin toate seturile de date lot # - luați 10% din ansamblul setului de date al lotului # - adăugați-le într-o listă de # - caracteristici_valide # - valid_labels caracteristici_valide.extinde(Caracteristici[-index_de_validare:]) etichete_valide.extinde(etichete[-index_de_validare:]) # preprocesați setul de date de validare toate stivuite _preprocesare_și_salvare(normaliza, one_hot_encode, de exemplu..matrice(caracteristici_valide), de exemplu..matrice(etichete_valide), 'preprocess_validation.p') # încărcați setul de date de testare cu deschis(cifar10_dataset_folder_path + '/ test_batch', modul=„rb”) la fel de fişier: lot = murături.sarcină(fişier, codificare=„latin1”) # preprocesați datele de testare caracteristici_test = lot['date'].remodela((len(lot['date']), 3, 32, 32))).transpune(0, 2, 3, unu) etichete_test = lot[„etichete”] # Preprocesați și salvați toate datele de testare _preprocesare_și_salvare(normaliza, one_hot_encode, de exemplu..matrice(caracteristici_test), de exemplu..matrice(etichete_test), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normaliza, one_hot_encode)

• Punct de control

import murături caracteristici_valide, etichete_valide = murături.sarcină(deschis('preprocess_validation.p', modul=„rb”)))

• Construirea rețelei

Întregul model este format din 14 straturi în total.

c ++ sări la linie

import tensorflow la fel de tf def conv_net(X, keep_prob): conv1_filter = tf.Variabil(tf.trunchiat_normal(formă=[3, 3, 3, 64], Rău=0, stddev=0,08))) conv2_filter = tf.Variabil(tf.trunchiat_normal(formă=[3, 3, 64, 128], Rău=0, stddev=0,08))) conv3_filter = tf.Variabil(tf.trunchiat_normal(formă=[5, 5, 128, 256], Rău=0, stddev=0,08))) conv4_filter = tf.Variabil(tf.trunchiat_normal(formă=[5, 5, 256, 512], Rău=0, stddev=0,08))) # 1, 2 conv1 = tf.nr.conv2d(X, conv1_filter, pași=[unu,unu,unu,unu], căptușeală='LA FEL') conv1 = tf.nr.relu(conv1) conv1_pool = tf.nr.max_pool(conv1, ksize=[unu,2,2,unu], pași=[unu,2,2,unu], căptușeală='LA FEL') conv1_bn = tf.straturi.normalizare_baterie(conv1_pool) # 3. 4 conv2 = tf.nr.conv2d(conv1_bn, conv2_filter, pași=[unu,unu,unu,unu], căptușeală='LA FEL') conv2 = tf.nr.relu(conv2) conv2_pool = tf.nr.max_pool(conv2, ksize=[unu,2,2,unu], pași=[unu,2,2,unu], căptușeală='LA FEL') conv2_bn = tf.straturi.normalizare_baterie(conv2_pool) # 5, 6 conv3 = tf.nr.conv2d(conv2_bn, conv3_filter, pași=[unu,unu,unu,unu], căptușeală='LA FEL') conv3 = tf.nr.relu(conv3) conv3_pool = tf.nr.max_pool(conv3, ksize=[unu,2,2,unu], pași=[unu,2,2,unu], căptușeală='LA FEL') conv3_bn = tf.straturi.normalizare_baterie(conv3_pool) # 7, 8 conv4 = tf.nr.conv2d(conv3_bn, conv4_filter, pași=[unu,unu,unu,unu], căptușeală='LA FEL') conv4 = tf.nr.relu(conv4) conv4_pool = tf.nr.max_pool(conv4, ksize=[unu,2,2,unu], pași=[unu,2,2,unu], căptușeală='LA FEL') conv4_bn = tf.straturi.normalizare_baterie(conv4_pool) # 9 apartament = tf.contrib.straturi.aplatiza(conv4_bn) # 10 plin1 = tf.contrib.straturi.complet_conectat(intrări=apartament, num_outputs=128, activation_fn=tf.nr.relu) plin1 = tf.nr.renunța(plin1, keep_prob) plin1 = tf.straturi.normalizare_baterie(plin1) # unsprezece plin2 = tf.contrib.straturi.complet_conectat(intrări=plin1, num_outputs=256, activation_fn=tf.nr.relu) plin2 = tf.nr.renunța(plin2, keep_prob) plin2 = tf.straturi.normalizare_baterie(plin2) # 12 plin3 = tf.contrib.straturi.complet_conectat(intrări=plin2, num_outputs=512, activation_fn=tf.nr.relu) plin3 = tf.nr.renunța(plin3, keep_prob) plin3 = tf.straturi.normalizare_baterie(plin3) # 13 plin4 = tf.contrib.straturi.complet_conectat(intrări=plin3, num_outputs=1024, activation_fn=tf.nr.relu) plin4 = tf.nr.renunța(plin4, keep_prob) plin4 = tf.straturi.normalizare_baterie(plin4) # 14 afară = tf.contrib.straturi.complet_conectat(intrări=plin3, num_outputs=10, activation_fn=Nici unul) întoarcere afară

• Hiperparametrele

epoci = 10 batch_size = 128 keep_probability = 0,7 rata_învățării = 0,001

logit = conv_net(X, keep_prob) model = tf.identitate(logit, Nume=„logiți”) # Name logits Tensor, astfel încât să poată fi încărcat de pe disc după antrenament # Pierdere și Optimizator cost = tf.reduce_semn(tf.nr.softmax_cross_entropy_with_logits(logit=logit, etichete=Da))) optimizator = tf.tren.AdamOptimizer(rata_învățării=rata_învățării).minimiza(cost) # Precizie corect_pred = tf.egal(tf.argmax(logit, unu), tf.argmax(Da, unu))) precizie = tf.reduce_semn(tf.distribuție(corect_pred, tf.plutitor32), Nume='precizie')

• Antrenează rețeaua neuronală

#Optimizare simplă 
def rețea_neural_ tren(sesiune, optimizator, keep_probability, feature_batch, etichetă_batch): sesiune.alerga(optimizator, feed_dict={ X: feature_batch, Da: etichetă_batch, keep_prob: keep_probability })

#Showing Stats def print_stats(sesiune, feature_batch, etichetă_batch, cost, precizie): pierderi = ses.alerga(cost, feed_dict={ X: feature_batch, Da: etichetă_batch, keep_prob: unu. }) valid_acc = ses.alerga(precizie, feed_dict={ X: caracteristici_valide, Da: etichete_valide, keep_prob: unu. }) imprimare('Pierderi:{:> 10.4f}Precizia validării:{: .6f}'.format(pierderi, valid_acc)))

• Instruirea și salvarea completă a modelului

def batch_features_labels(Caracteristici, etichete, batch_size): '' ' Împărțiți caracteristicile și etichetele în loturi '' ' pentru start în gamă(0, len(Caracteristici), batch_size): Sfârșit = min(start + batch_size, len(Caracteristici))) Randament Caracteristici[start:Sfârșit], etichete[start:Sfârșit] def load_preprocess_training_batch(batch_id, batch_size): '' ' Încărcați datele de pregătire preprocesate și returnați-le în loturi de sau mai puțin '' ' nume de fișier = „preprocess_batch_” + str(batch_id) + „.p” Caracteristici, etichete = murături.sarcină(deschis(nume de fișier, modul=„rb”))) # Returnați datele de antrenament în loturi de dimensiuni sau mai mici întoarcere batch_features_labels(Caracteristici, etichete, batch_size)

#Salvarea modelului și a căii 
save_model_path = „./image_classification” imprimare('Instruire...') cu tf.Sesiune() la fel de ses: # Inițializarea variabilelor ses.alerga(tf.global_variables_initializer()) # Ciclul de instruire pentru epocă în gamă(epoci): # Buclați peste toate loturile n_batches = 5 pentru lot_i în gamă(unu, n_batches + unu): pentru caracteristici_baterie, batch_labels în load_preprocess_training_batch(lot_i, batch_size): rețea_neural_ tren(ses, optimizator, keep_probability, caracteristici_baterie, batch_labels) imprimare('Epocă{:> 2}, CIFAR-10 Lot{}: '.format(epocă + unu, lot_i), Sfârșit=') print_stats(ses, caracteristici_baterie, batch_labels, cost, precizie) # Salvați modelul economisitor = tf.tren.Economisitor() save_path = economisitor.salva(ses, save_model_path)

Acum, partea importantă a Clasificării imaginilor Tensorflow este realizată. Acum, este timpul să testați modelul.

• Testarea modelului

import murături import neclintit la fel de de exemplu. import matplotlib.pyplot la fel de plt din sklearn.preprocesare import LabelBinarizer def batch_features_labels(Caracteristici, etichete, batch_size): '' ' Împărțiți caracteristicile și etichetele în loturi '' ' pentru start în gamă(0, len(Caracteristici), batch_size): Sfârșit = min(start + batch_size, len(Caracteristici))) Randament Caracteristici[start:Sfârșit], etichete[start:Sfârșit] def display_image_predictions(Caracteristici, etichete, predicții, top_n_predictions): n_clase = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.potrivi(gamă(n_clase))) label_ids = label_binarizer.invers_transform(de exemplu..matrice(etichete))) Fig, axii = plt.subtrame(nrows=top_n_predictions, ncols=2, figsize=(douăzeci, 10))) Fig.strâns_layout() Fig.suptitlu(„Predicții Softmax”, marimea fontului=douăzeci, Da=1.1) n_predicții = 3 marjă = 0,05 ind = de exemplu..aranjează(n_predicții) lăţime = (unu. - 2. * marjă) / n_predicții pentru imagine_i, (caracteristică, label_id, indicii_pred, valori_pred) în enumerate(fermoar(Caracteristici, label_ids, predicții.indicii, predicții.valori)): dacă (imagine_i < top_n_predictions): nume_pred = [label_names[pred_i] pentru pred_i în indicii_pred] nume_corect = label_names[label_id] axii[imagine_i] [0].imshow((caracteristică*255).astype(de exemplu..int32, copie=Fals))) axii[imagine_i] [0].set_title(nume_corect) axii[imagine_i] [0].set_axis_off() axii[imagine_i] [unu].barh(ind + marjă, valori_pred[:3], lăţime) axii[imagine_i] [unu].set_yticks(ind + marjă) axii[imagine_i] [unu].set_yticklabels(nume_pred[::-unu]) axii[imagine_i] [unu].set_xticks([0, 0,5, 1.0])

%matplotlib in linie %config InlineBackend.figure_format = 'retină' import tensorflow la fel de tf import murături import Aleatoriu save_model_path = „./image_classification” batch_size = 64 n_probe = 10 top_n_predictions = 5 def model_test(): caracteristici_test, etichete_test = murături.sarcină(deschis('preprocess_training.p', modul=„rb”))) încărcat_graf = tf.Grafic() cu tf.Sesiune(grafic=încărcat_graf) la fel de ses: # Încărcați modelul încărcător = tf.tren.import_meta_graph(save_model_path + „.meta”) încărcător.restabili(ses, save_model_path) # Obțineți tensori din modelul încărcat încărcat_x = încărcat_graf.get_tensor_by_name(„input_x: 0”) încărcat_y = încărcat_graf.get_tensor_by_name(„output_y: 0”) încărcat_de_probare = încărcat_graf.get_tensor_by_name('keep_prob: 0') încărcat_logiți = încărcat_graf.get_tensor_by_name(„logits: 0”) încărcat_acc = încărcat_graf.get_tensor_by_name(„precizie: 0”) # Obțineți precizie în loturi pentru limitările memoriei test_batch_acc_total = 0 test_batch_count = 0 pentru train_feature_batch, train_label_batch în batch_features_labels(caracteristici_test, etichete_test, batch_size): test_batch_acc_total + = ses.alerga( încărcat_acc, feed_dict={încărcat_x: train_feature_batch, încărcat_y: train_label_batch, încărcat_de_probare: 1.0}) test_batch_count + = unu imprimare(„Precizia testării:{} '.format(test_batch_acc_total/test_batch_count))) # Imprimați probe aleatorii caracteristici_test_aleatorii, etichete_test_aleatorii = tuplu(fermoar(*Aleatoriu.probă(listă(fermoar(caracteristici_test, etichete_test)), n_probe))) predicții_test_aleatorii = ses.alerga( tf.nr.top_k(tf.nr.softmax(încărcat_logiți), top_n_predictions), feed_dict={încărcat_x: caracteristici_test_aleatorii, încărcat_y: etichete_test_aleatorii, încărcat_de_probare: 1.0}) display_image_predictions(caracteristici_test_aleatorii, etichete_test_aleatorii, predicții_test_aleatorii, top_n_predictions) model_test()

Ieșire: Precizia testării: 0,5882762738853503

Acum, dacă vă antrenați rețeaua neuronală pentru mai multe epoci sau modificați funcția de activare, s-ar putea să obțineți un rezultat diferit care ar putea avea o precizie mai bună.

Deci, odată cu aceasta, ajungem la sfârșitul acestui articol TensorFlow Image Classification. Sunt sigur că puteți utiliza acum același lucru pentru a clasifica orice fel de imagini și nu sunteți un începător în clasificarea imaginilor.

Edureka’s cu Python Certification Training este organizat de profesioniști din industrie conform cerințelor și cerințelor industriei. Veți stăpâni concepte precum funcția SoftMax, rețelele neuronale cu autocoder, mașina restricționată Boltzmann (RBM), Keras și TFLearn. Cursul a fost special organizat de experți din industrie cu studii de caz în timp real.