Classificazione delle immagini TensorFlow: tutto ciò che devi sapere sui classificatori di edifici

Classificazione delle immagini un compito che anche un bambino può svolgere in pochi secondi, ma per una macchina è stato un compito difficile fino ai recenti progressi e Apprendimento approfondito . Le auto a guida autonoma possono rilevare oggetti e intraprendere l'azione richiesta in tempo reale e la maggior parte di ciò è possibile grazie a Classificazione delle immagini. In questo articolo, ti guiderò attraverso i seguenti argomenti:

• Cos'è TensorFlow?
• Cos'è la classificazione delle immagini?
• Classificazione delle immagini TensorFlow: Fashion MNIST
• CIFAR 10: CNN

Cos'è TensorFlow?

TensorFlow è il framework di machine learning open source di Google per la programmazione del flusso di dati in una serie di attività. I nodi nel grafico rappresentano operazioni matematiche, mentre i bordi del grafico rappresentano le matrici di dati multidimensionali comunicate tra di loro.

I tensori sono solo array multidimensionali, un'estensione di tabelle bidimensionali a dati con una dimensione superiore. Ci sono molte funzionalità di Tensorflow che lo rendono appropriato per il Deep Learning e la sua libreria open source di base ti aiuta a sviluppare e addestrare modelli ML.

Cos'è la classificazione delle immagini?

Lo scopo della classificazione delle immagini è classificare tutti i pixel di un'immagine digitale in uno dei tanti copertura del suolo classi o temi . Questi dati classificati possono quindi essere utilizzati per produrre mappe tematiche della copertura del suolo presente in un'immagine.

Ora A seconda dell'interazione tra l'analista e il computer durante la classificazione, esistono due tipi di classificazione:

• Supervisionato e
• Senza supervisione

Quindi, senza perdere tempo, passiamo alla classificazione di immagini TensorFlow. Ho 2 esempi: facile e difficile. Procediamo con quello facile.

Classificazione delle immagini TensorFlow: Fashion MNIST

Dataset Fashion MNIST

quali sono i vincoli in sql

Qui utilizzeremo Fashion MNIST Dataset, che contiene 70.000 immagini in scala di grigi in 10 categorie. Useremo 60000 per la formazione e il resto 10000 per scopi di test. Puoi accedere a Fashion MNIST direttamente da TensorFlow, basta importare e caricare i dati.

• Importiamo prima le librerie

from __future__ import absolute_import, division, print_function # TensorFlow e tf.keras importano tensorflow come tf da tensorflow import keras # Librerie helper importano numpy come np import matplotlib.pyplot come plt

• Carichiamo i dati

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

• Successivamente, mapperemo le immagini in classi

class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

• Esplorare i dati

immagini_treno.forma 
#Ogni etichetta è compreso tra 0 e 9

train_labels 
test_images.forma 

• Ora è il momento di pre-elaborare i dati.

plt.figura() plt.imshow(immagini_treno[0]) plt.colorbar() plt.griglia(Falso) plt.spettacolo() 
#Se esamini la prima immagine nel set di addestramento, vedrai che i valori dei pixel rientrano nell'intervallo da 0 a 255. 

• Dobbiamo scalare le immagini da 0 a 1 per inserirle nella rete neurale

immagini_treno = immagini_treno / 255.0 test_images = test_images / 255.0

• Mostriamo alcune immagini.

plt.figura(figsize=(10,10)) per io nel gamma(25): plt.sottotrama(5,5,io+uno) plt.xticks([]) plt.yticks([]) plt.griglia(Falso) plt.imshow(immagini_treno[io], cmap=plt.cm.binario) plt.xlabel(class_names[train_labels[io]]) plt.spettacolo()

• Imposta i livelli

modello = difficile.Sequenziale([ difficile.strati.Appiattire(input_shape=(28, 28)), difficile.strati.Denso(128, Attivazione=tf.nn.relu), difficile.strati.Denso(10, Attivazione=tf.nn.softmax) ])

• Compila il modello

modello.compilare(ottimizzatore='Adamo', perdita='sparse_categorical_crossentropy', metrica=['precisione'])

• Modello di formazione

modello.in forma(immagini_treno, train_labels, epoche=10)

• Valutazione dell'accuratezza

test_loss, test_acc = modello.valutare(test_images, test_labels) Stampa('Precisione del test:', test_acc)

• Fare previsioni

predizioni = modello.prevedere(test_images)

predizioni[0]

Una previsione è una matrice di 10 numeri. Questi descrivono la 'fiducia' del modello che l'immagine corrisponde a ciascuno dei 10 diversi articoli di abbigliamento. Possiamo vedere quale etichetta ha il valore di confidenza più alto.

per esempio..argmax(predizioni[0])#Model è più convinto che sia uno stivaletto. Vediamo se è corretto

Uscita: 9

test_labels[0]

Uscita: 9

• Ora è il momento di esaminare il set completo di 10 canali

def plot_image(io, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[io], true_label[io], img[io] plt.griglia(Falso) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binario) predicted_label = per esempio..argmax(predictions_array) Se predicted_label == true_label: colore = 'verde' altro: colore = 'netto' plt.xlabel('{} {: 2.0f}% ({}) '.formato(class_names[predicted_label], 100*per esempio..max(predictions_array), class_names[true_label]), colore=colore) def plot_value_array(io, predictions_array, true_label): predictions_array, true_label = predictions_array[io], true_label[io] plt.griglia(Falso) plt.xticks([]) plt.yticks([]) thisplot = plt.bar(gamma(10), predictions_array, colore='# 777777') plt.ylim([0, uno]) predicted_label = per esempio..argmax(predictions_array) thisplot[predicted_label].set_color('netto') thisplot[true_label].set_color('verde')

• Esaminiamo prima la 0a e la 10a immagine

io = 0 plt.figura(figsize=(6,3)) plt.sottotrama(uno,2,uno) plot_image(io, predizioni, test_labels, test_images) plt.sottotrama(uno,2,2) plot_value_array(io, predizioni, test_labels) plt.spettacolo()

io = 10 plt.figura(figsize=(6,3)) plt.sottotrama(uno,2,uno) plot_image(io, predizioni, test_labels, test_images) plt.sottotrama(uno,2,2) plot_value_array(io, predizioni, test_labels) plt.spettacolo()

• Ora tracciamo diverse immagini e le loro previsioni. Quelle corrette sono verdi, mentre quelle sbagliate sono rosse.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figura(figsize=(2*2*num_cols, 2*num_rows)) per io nel gamma(num_images): plt.sottotrama(num_rows, 2*num_cols, 2*io+uno) plot_image(io, predizioni, test_labels, test_images) plt.sottotrama(num_rows, 2*num_cols, 2*io+2) plot_value_array(io, predizioni, test_labels) plt.spettacolo()

• Infine, utilizzeremo il modello addestrato per fare una previsione su una singola immagine.

# Prendi un'immagine dal set di dati di prova img = test_images[0] Stampa(img.forma)

# Aggiungi l'immagine a un batch in cui è l'unico membro. img = (per esempio..expand_dims(img,0)) Stampa(img.forma)

predictions_single = modello.prevedere(img) Stampa(predictions_single)

plot_value_array(0, predictions_single, test_labels) plt.xticks(gamma(10), class_names, rotazione=Quattro cinque) plt.spettacolo()

• Come puoi vedere la previsione per la nostra unica immagine in batch.

prediction_result = per esempio..argmax(predictions_single[0])

Uscita: 9

CIFAR-10: CNN

Il set di dati CIFAR-10 è costituito da aeroplani, cani, gatti e altri oggetti. Pre-elaborerai le immagini, quindi addestrerai una rete neurale convoluzionale su tutti i campioni. Le immagini devono essere normalizzate e le etichette devono essere codificate a caldo. Questo caso d'uso chiarirà sicuramente i tuoi dubbi sulla classificazione delle immagini TensorFlow.

• Download dei dati

a partire dal urllib.request importare urlretrieve a partire dal os.path importare isfile, è fuliggine a partire dal tqdm importare tqdm importare tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' classe DownloadProgress(tqdm): last_block = 0 def gancio(se stesso, block_num=uno, misura del blocco=uno, dimensione totale=Nessuna): se stesso.totale = dimensione totale se stesso.aggiornare((block_num - se stesso.last_block) * misura del blocco) se stesso.last_block = block_num '' ' controlla se il file di dati (zip) è già stato scaricato in caso contrario, scaricarlo da 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' e salvarlo come cifar-10-python.tar.gz '' ' Se non isfile('cifar-10-python.tar.gz'): con DownloadProgress(unità='B', scala_unità=Vero, miniters=uno, disc='Set di dati CIFAR-10') come pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.gancio) Se non è fuliggine(cifar10_dataset_folder_path): con tarfile.Aperto('cifar-10-python.tar.gz') come catrame: catrame.estrai tutto() catrame.vicino()

• Importazione delle librerie necessarie

importare salamoia importare insensibile come per esempio. importare matplotlib.pyplot come plt

• Comprensione dei dati

Il batch originale di dati è un tensore 10000 × 3072 espresso in un array numpy, dove 10000 è il numero di dati campione. L'immagine è colorata e di dimensione 32 × 32. L'alimentazione può essere effettuata in un formato di (larghezza x altezza x num_channel) o (num_channel x larghezza x altezza). Definiamo le etichette.

def load_label_names(): ritorno ['aereo', 'automobile', 'uccello', 'gatto', 'cervo', 'cane', 'rana', 'cavallo', 'nave', 'camion']

• Rimodellare i dati

Riorganizzeremo i dati in due fasi

Per prima cosa, dividi il vettore riga (3072) in 3 pezzi. Ogni brano corrisponde a ciascun canale. Ciò si traduce in (3 x 1024) dimensione di un tensore. Quindi dividere il tensore risultante dal passaggio precedente con 32. 32 qui significa la larghezza di un'immagine. Ciò si traduce in (3x32x32).

In secondo luogo, dobbiamo trasporre i dati da (num_channel, width, height) a (width, height, num_channel). Per questo, useremo la funzione di trasposizione.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): con Aperto(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), modalità='rb') come file: # nota che il tipo di codifica è 'latin1' lotto = salamoia.caricare(file, codifica='latin1') Caratteristiche = lotto['dati'].rimodellare((len(lotto['dati']), 3, 32, 32)).trasporre(0, 2, 3, uno) etichette = lotto['etichette'] ritorno Caratteristiche, etichetta

• Esplorare i dati

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Caratteristiche, etichette = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) Se non (0 <= sample_id < len(Caratteristiche)): Stampa('{}campioni in batch{}.{}è fuori portata. '.formato(len(Caratteristiche), batch_id, sample_id)) ritorno Nessuna Stampa(' Statistiche del lotto n.{}: '.formato(batch_id)) Stampa('# di campioni:{} '.formato(len(Caratteristiche))) label_names = load_label_names() label_counts = dict(cerniera lampo(*per esempio..unico(etichette, return_counts=Vero))) per chiave, valore nel label_counts.elementi(): Stampa('Conteggi etichetta di [{}] ({}):{}'.formato(chiave, label_names[chiave].superiore(), valore)) sample_image = Caratteristiche[sample_id] sample_label = etichette[sample_id] Stampa(' Esempio di immagine{}: '.formato(sample_id)) Stampa('Immagine - Valore minimo:{}Valore massimo:{}'.formato(sample_image.min(), sample_image.max())) Stampa('Immagine - Forma:{}'.formato(sample_image.forma)) Stampa('Etichetta - ID etichetta:{}Nome:{}'.formato(sample_label, label_names[sample_label])) plt.imshow(sample_image)

%matplotlib in linea %config InlineBackend.figure_format = 'retina' importare insensibile come per esempio. # Esplora il set di dati batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Implementazione delle funzioni di pre-elaborazione

Normalizzeremo i dati tramite la normalizzazione Min-Max. Questo fa semplicemente sì che tutti i valori x siano compresi tra 0 e 1.
y = (x-min) / (max-min)

def normalizzare(X): '' ' discussione - x: input dei dati dell'immagine in array numpy [32, 32, 3] ritorno - normalizzato x '' ' min_val = per esempio..min(X) max_val = per esempio..max(X) X = (X-min_val) / (max_val-min_val) ritorno X

• Codifica One-Hot

def one_hot_encode(X): '' ' discussione - x: un elenco di etichette ritorno - una matrice di codifica a caldo (numero di etichette, numero di classe) '' ' codificato = per esempio..zeri((len(X), 10)) per idx, ore nel enumerare(X): codificato[idx] [ore] = uno ritorno codificato

• Pre-elaborazione e salvataggio dei dati

def _preprocess_and_save(normalizzare, one_hot_encode, Caratteristiche, etichette, nome del file): Caratteristiche = normalizzare(Caratteristiche) etichette = one_hot_encode(etichette) salamoia.discarica((Caratteristiche, etichette), Aperto(nome del file, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizzare, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] per batch_i nel gamma(uno, n_batches + uno): Caratteristiche, etichette = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # trova l'indice come punto dei dati di convalida nell'intero set di dati del batch (10%) index_of_validation = int(len(Caratteristiche) * 0.1) # preelabora il 90% dell'intero set di dati del batch # - normalizza le caratteristiche # - one_hot_encode le etichette # - salva in un nuovo file chiamato 'preprocess_batch_' + batch_number # - ogni file per ogni batch _preprocess_and_save(normalizzare, one_hot_encode, Caratteristiche[:-index_of_validation], etichette[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # a differenza del set di dati di addestramento, il set di dati di convalida verrà aggiunto tramite tutto il set di dati batch # - prende il 10% dell'intero set di dati del batch # - aggiungili a un elenco di file # - funzioni_valide # - valid_labels valid_features.estendere(Caratteristiche[-index_of_validation:]) valid_labels.estendere(etichette[-index_of_validation:]) # preelabora il set di dati di convalida in pila _preprocess_and_save(normalizzare, one_hot_encode, per esempio..Vettore(valid_features), per esempio..Vettore(valid_labels), 'preprocess_validation.p') # carica il set di dati di prova con Aperto(cifar10_dataset_folder_path + '/ test_batch', modalità='rb') come file: lotto = salamoia.caricare(file, codifica='latin1') # preelabora i dati di test test_features = lotto['dati'].rimodellare((len(lotto['dati']), 3, 32, 32)).trasporre(0, 2, 3, uno) test_labels = lotto['etichette'] # Pre-elabora e salva tutti i dati di test _preprocess_and_save(normalizzare, one_hot_encode, per esempio..Vettore(test_features), per esempio..Vettore(test_labels), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normalizzare, one_hot_encode)

• Checkpoint

importare salamoia valid_features, valid_labels = salamoia.caricare(Aperto('preprocess_validation.p', modalità='rb'))

• Costruire la rete

L'intero modello è composto da 14 strati in totale.

importare tensorflow come tf def conv_net(X, keep_prob): conv1_filter = tf.Variabile(tf.truncated_normal(forma=[3, 3, 3, 64], significare=0, stddev=0,08)) conv2_filter = tf.Variabile(tf.truncated_normal(forma=[3, 3, 64, 128], significare=0, stddev=0,08)) conv3_filter = tf.Variabile(tf.truncated_normal(forma=[5, 5, 128, 256], significare=0, stddev=0,08)) conv4_filter = tf.Variabile(tf.truncated_normal(forma=[5, 5, 256, 512], significare=0, stddev=0,08)) # 1, 2 conv1 = tf.nn.conv2d(X, conv1_filter, passi=[uno,uno,uno,uno], imbottitura='STESSO') conv1 = tf.nn.relu(conv1) conv1_pool = tf.nn.max_pool(conv1, ksize=[uno,2,2,uno], passi=[uno,2,2,uno], imbottitura='STESSO') conv1_bn = tf.strati.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.nn.conv2d(conv1_bn, conv2_filter, passi=[uno,uno,uno,uno], imbottitura='STESSO') conv2 = tf.nn.relu(conv2) conv2_pool = tf.nn.max_pool(conv2, ksize=[uno,2,2,uno], passi=[uno,2,2,uno], imbottitura='STESSO') conv2_bn = tf.strati.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.nn.conv2d(conv2_bn, conv3_filter, passi=[uno,uno,uno,uno], imbottitura='STESSO') conv3 = tf.nn.relu(conv3) conv3_pool = tf.nn.max_pool(conv3, ksize=[uno,2,2,uno], passi=[uno,2,2,uno], imbottitura='STESSO') conv3_bn = tf.strati.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.nn.conv2d(conv3_bn, conv4_filter, passi=[uno,uno,uno,uno], imbottitura='STESSO') conv4 = tf.nn.relu(conv4) conv4_pool = tf.nn.max_pool(conv4, ksize=[uno,2,2,uno], passi=[uno,2,2,uno], imbottitura='STESSO') conv4_bn = tf.strati.batch_normalization(conv4_pool) # 9 piatto = tf.contrib.strati.appiattire(conv4_bn) # 10 full1 = tf.contrib.strati.fully_connected(ingressi=piatto, num_outputs=128, activation_fn=tf.nn.relu) full1 = tf.nn.ritirarsi(full1, keep_prob) full1 = tf.strati.batch_normalization(full1) # undici full2 = tf.contrib.strati.fully_connected(ingressi=full1, num_outputs=256, activation_fn=tf.nn.relu) full2 = tf.nn.ritirarsi(full2, keep_prob) full2 = tf.strati.batch_normalization(full2) # 12 pieno3 = tf.contrib.strati.fully_connected(ingressi=full2, num_outputs=512, activation_fn=tf.nn.relu) pieno3 = tf.nn.ritirarsi(pieno3, keep_prob) pieno3 = tf.strati.batch_normalization(pieno3) # 13 pieno4 = tf.contrib.strati.fully_connected(ingressi=pieno3, num_outputs=1024, activation_fn=tf.nn.relu) pieno4 = tf.nn.ritirarsi(pieno4, keep_prob) pieno4 = tf.strati.batch_normalization(pieno4) # 14 su = tf.contrib.strati.fully_connected(ingressi=pieno3, num_outputs=10, activation_fn=Nessuna) ritorno su

• Iperparametri

epoche = 10 dimensione del lotto = 128 keep_probability = 0.7 learning_rate = 0.001

logit = conv_net(X, keep_prob) modello = tf.identità(logit, nome='logits') # Nome logits Tensor, in modo che possa essere caricato dal disco dopo l'allenamento # Perdita e ottimizzatore costo = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logit=logit, etichette=Y)) ottimizzatore = tf.treno.AdamOptimizer(learning_rate=learning_rate).minimizzare(costo) # Precisione corretto_pred = tf.pari(tf.argmax(logit, uno), tf.argmax(Y, uno)) precisione = tf.reduce_mean(tf.cast(corretto_pred, tf.float32), nome='precisione')

• Addestra la rete neurale

#Single Optimization 
def train_neural_network(sessione, ottimizzatore, keep_probability, feature_batch, label_batch): sessione.correre(ottimizzatore, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: keep_probability })

#Showing Stats def print_stats(sessione, feature_batch, label_batch, costo, precisione): perdita = sess.correre(costo, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: uno. }) valid_acc = sess.correre(precisione, feed_dict={ X: valid_features, Y: valid_labels, keep_prob: uno. }) Stampa('Perdita:{:> 10.4f}Accuratezza della convalida:{: .6f}'.formato(perdita, valid_acc))

• Addestramento completo e salvataggio del modello

def batch_features_labels(Caratteristiche, etichette, dimensione del lotto): '' ' Suddividi le caratteristiche e le etichette in batch '' ' per inizio nel gamma(0, len(Caratteristiche), dimensione del lotto): fine = min(inizio + dimensione del lotto, len(Caratteristiche)) dare la precedenza Caratteristiche[inizio:fine], etichette[inizio:fine] def load_preprocess_training_batch(batch_id, dimensione del lotto): '' ' Carica i dati di addestramento preelaborati e restituiscili in batch di o meno '' ' nome del file = 'preprocess_batch_' + p(batch_id) + '.p' Caratteristiche, etichette = salamoia.caricare(Aperto(nome del file, modalità='rb')) # Restituisce i dati di addestramento in batch di dimensioni o meno ritorno batch_features_labels(Caratteristiche, etichette, dimensione del lotto)

#Salvataggio di modello e percorso 
save_model_path = './image_classification' Stampa('Formazione...') con tf.Sessione() come sess: # Inizializzazione delle variabili sess.correre(tf.global_variables_initializer()) # Ciclo di formazione per epoca nel gamma(epoche): # Esegue il ciclo su tutti i batch n_batches = 5 per batch_i nel gamma(uno, n_batches + uno): per batch_features, batch_labels nel load_preprocess_training_batch(batch_i, dimensione del lotto): train_neural_network(sess, ottimizzatore, keep_probability, batch_features, batch_labels) Stampa('Epoca{:> 2}, CIFAR-10 Batch{}: '.formato(epoca + uno, batch_i), fine='') print_stats(sess, batch_features, batch_labels, costo, precisione) # Salva modello risparmiatore = tf.treno.Saver() save_path = risparmiatore.Salva(sess, save_model_path)

Ora, la parte importante della classificazione delle immagini di Tensorflow è terminata. Ora è il momento di testare il modello.

• Testare il modello

importare salamoia importare insensibile come per esempio. importare matplotlib.pyplot come plt a partire dal sklearn.preprocessing importare LabelBinarizer def batch_features_labels(Caratteristiche, etichette, dimensione del lotto): '' ' Suddividi le caratteristiche e le etichette in batch '' ' per inizio nel gamma(0, len(Caratteristiche), dimensione del lotto): fine = min(inizio + dimensione del lotto, len(Caratteristiche)) dare la precedenza Caratteristiche[inizio:fine], etichette[inizio:fine] def display_image_predictions(Caratteristiche, etichette, predizioni, previsioni del tempo): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.in forma(gamma(n_classes)) label_ids = label_binarizer.inverse_transform(per esempio..Vettore(etichette)) Figura, axies = plt.sottotrame(nrows=previsioni del tempo, ncols=2, figsize=(venti, 10)) Figura.tight_layout() Figura.suptitle('Previsioni Softmax', dimensione del font=venti, Y=1.1) n_predictions = 3 margine = 0,05 ind = per esempio..arange(n_predictions) larghezza = (uno. - 2. * margine) / n_predictions per immagine_i, (caratteristica, label_id, pred_indicies, pred_values) nel enumerare(cerniera lampo(Caratteristiche, label_ids, predizioni.indici, predizioni.valori)): Se (immagine_i < previsioni del tempo): pred_names = [label_names[pred_i] per pred_i nel pred_indicies] nome_esatto = label_names[label_id] axies[immagine_i] [0].imshow((caratteristica*255).astype(per esempio..int32, copia=Falso)) axies[immagine_i] [0].set_title(nome_esatto) axies[immagine_i] [0].set_axis_off() axies[immagine_i] [uno].barh(ind + margine, pred_values[:3], larghezza) axies[immagine_i] [uno].set_yticks(ind + margine) axies[immagine_i] [uno].set_yticklabels(pred_names[::-uno]) axies[immagine_i] [uno].set_xticks([0, 0,5, 1.0])

%matplotlib in linea %config InlineBackend.figure_format = 'retina' importare tensorflow come tf importare salamoia importare casuale save_model_path = './image_classification' dimensione del lotto = 64 n_samples = 10 previsioni del tempo = 5 def test_model(): test_features, test_labels = salamoia.caricare(Aperto('preprocess_training.p', modalità='rb')) grafico_caricato = tf.Grafico() con tf.Sessione(grafico=grafico_caricato) come sess: # Carica il modello caricatore = tf.treno.import_meta_graph(save_model_path + '.meta') caricatore.ristabilire(sess, save_model_path) # Ottieni tensori dal modello caricato load_x = grafico_caricato.get_tensor_by_name('input_x: 0') load_y = grafico_caricato.get_tensor_by_name('output_y: 0') load_keep_prob = grafico_caricato.get_tensor_by_name('keep_prob: 0') load_logits = grafico_caricato.get_tensor_by_name('logits: 0') load_acc = grafico_caricato.get_tensor_by_name('precisione: 0') # Ottieni la precisione in batch per i limiti di memoria test_batch_acc_total = 0 test_batch_count = 0 per train_feature_batch, train_label_batch nel batch_features_labels(test_features, test_labels, dimensione del lotto): test_batch_acc_total + = sess.correre( load_acc, feed_dict={load_x: train_feature_batch, load_y: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = uno Stampa('Precisione del test:{} '.formato(test_batch_acc_total/test_batch_count)) # Stampa campioni casuali random_test_features, random_test_labels = tupla(cerniera lampo(*casuale.campione(elenco(cerniera lampo(test_features, test_labels)), n_samples))) random_test_predictions = sess.correre( tf.nn.top_k(tf.nn.softmax(load_logits), previsioni del tempo), feed_dict={load_x: random_test_features, load_y: random_test_labels, load_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, previsioni del tempo) test_model()

Produzione: Precisione del test: 0,5882762738853503

Ora, se alleni la tua rete neurale per più epoche o modifichi la funzione di attivazione, potresti ottenere un risultato diverso che potrebbe avere una migliore precisione.

Quindi, con questo, arriviamo alla fine di questo articolo sulla classificazione delle immagini di TensorFlow. Sono sicuro che ora puoi usare lo stesso per classificare qualsiasi tipo di immagine e non sei un principiante nella classificazione delle immagini.

Edureka's con Python Certification Training è curato da professionisti del settore secondo i requisiti e le richieste del settore. Potrai padroneggiare concetti come la funzione SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras e TFLearn. Il corso è stato appositamente curato da esperti del settore con casi di studio in tempo reale.