Classificació d'imatges TensorFlow: tot el que heu de saber sobre els classificadors d'edificis



Aquest article de Classificació d’imatges de TensorFlow us proporcionarà un coneixement detallat i complet de classificació d’imatges.

La classificació d’imatges és una tasca que fins i tot un bebè pot fer en qüestió de segons, però per a una màquina ha estat una tasca dura fins als darrers avenços en i Aprenentatge profund . Els cotxes que condueixen amb si mateixos poden detectar objectes i fer les accions necessàries en temps real i la major part d’això és possible Classificació d’imatges. En aquest article, us guiaré pels temes següents:

Què és TensorFlow?

TensorFlow és l’Open Framework Machine Learning Framework de Google per a la programació de flux de dades en diverses tasques. Els nodes del gràfic representen operacions matemàtiques, mentre que les vores del gràfic representen les matrius de dades multidimensionals comunicades entre ells.





TensorFlow-Image-Recognition
Els tensors són només matrius multidimensionals, una extensió de taules bidimensionals a dades amb una dimensió superior. Hi ha moltes funcions de Tensorflow que el fan adequat per a l’aprenentatge profund i la seva biblioteca bàsica de codi obert us ajuda a desenvolupar i formar models de ML.

Què és la classificació d'imatges?

La intenció de Classificació d’imatges és classificar tots els píxels d’una imatge digital en un de diversos cobertura del sòl classes o bé temes . Després es poden utilitzar aquestes dades classificades mapes temàtics de la coberta del terreny present en una imatge.



Ara, segons la interacció entre l'analista i l'ordinador durant la classificació, hi ha dos tipus de classificació:



  • Supervisat i
  • Sense supervisió

Per tant, sense perdre temps, anem a la classificació d’imatges TensorFlow. Tinc 2 exemples: fàcil i difícil. Continuem amb el més fàcil.

Classificació d'imatges TensorFlow: Fashion MNIST

per a què s’utilitza la ciència de dades

Conjunt de dades de moda MNIST

Aquí utilitzarem el conjunt de dades Fashion MNIST, que conté 70.000 imatges en escala de grisos en 10 categories. Utilitzarem 60000 per a la formació i la resta 10000 per a proves. Podeu accedir al Fashion MNIST directament des de TensorFlow, només cal que importeu i carregueu les dades.

  • Importem primer les biblioteques
des de __future__ importació absolute_import, divisió, funció_impressió # TensorFlow i tf.keras importen tensorflow com tf des de tensorflow keras # Les biblioteques d’ajuda importen numpy com a importació np matplotlib.pyplot com plt
  • Carregem les dades
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
  • A continuació, maparem les imatges en classes
class_names = ['Samarreta / samarreta', 'Pantaló', 'Jersei', 'Vestit', 'Abric', 'Sandàlia', 'Samarreta', 'Sneaker', 'Bossa', 'Botí']
  • Exploració de les dades
imatges_de tren.forma 
#Cada etiqueta oscil·la entre el 0 i el 9
etiquetes_tren 
imatges_prova.forma
  • Ara és el moment de processar prèviament les dades.
plt.figura() plt.imshow(imatges_de tren[0]) plt.barra de colors() plt.quadrícula(Fals) plt.espectacle() 
#Si inspeccioneu la primera imatge del conjunt d'entrenament, veureu que els valors dels píxels oscil·len entre 0 i 255.

  • Hem d’escalar les imatges de 0 a 1 per introduir-les a la xarxa neuronal
imatges_de tren = imatges_de tren / 255.0 imatges_prova = imatges_prova / 255.0
  • Mostrem algunes imatges.
plt.figura(mida de figs=(10,10)) per jo dins abast(25): plt.subtrama(5,5,jo+1) plt.xticks([]) plt.yticks([]) plt.quadrícula(Fals) plt.imshow(imatges_de tren[jo], cmap=plt.cm.binari) plt.xlabel(noms_classe[etiquetes_tren[jo]]) plt.espectacle()
 

  • Configureu les capes
model = dur.Seqüencial([ dur.capes.Aplanar(input_shape=(28, 28)), dur.capes.Dens(128, activació=tf.núm.relu), dur.capes.Dens(10, activació=tf.núm.softmax) ])
  • Compileu el model
model.compilar(optimitzador='Adam', pèrdua='sparse_categorical_crossentropy', mètriques=['precisió'])
  • Model Training
model.en forma(imatges_de tren, etiquetes_tren, èpoques=10)

  • Avaluació de la precisió
prova_pèrdua, test_acc = model.avaluar(imatges_prova, etiquetes_prova) imprimir('Precisió de la prova:', test_acc)

  • Fer prediccions
prediccions = model.predir(imatges_prova)
prediccions[0]

Una predicció és una matriu de 10 nombres. Aquests descriuen la 'confiança' del model que la imatge correspon a cadascun dels deu articles de roba diferents. Podem veure quina etiqueta té el valor de confiança més alt.

per exemple..argmax(prediccions[0])#Model confia molt en que es tracti d’un turmell. A veure si és correcte

Sortida: 9

etiquetes_prova[0]

Sortida: 9

  • Ara és el moment de veure el conjunt complet de 10 canals
def imatge_trama(jo, matriu_prediccions, etiqueta_veritable, img): matriu_prediccions, etiqueta_veritable, img = matriu_prediccions[jo], etiqueta_veritable[jo], img[jo] plt.quadrícula(Fals) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binari) etiqueta_predit = per exemple..argmax(matriu_prediccions) si etiqueta_predit == etiqueta_veritable: color = 'verd' en cas contrari: color = 'Xarxa' plt.xlabel('{} {: 2.0f}% ({}) '.format(noms_classe[etiqueta_predit], 100*per exemple..màx(matriu_prediccions), noms_classe[etiqueta_veritable]), color=color) def parcel_valor_trama(jo, matriu_prediccions, etiqueta_veritable): matriu_prediccions, etiqueta_veritable = matriu_prediccions[jo], etiqueta_veritable[jo] plt.quadrícula(Fals) plt.xticks([]) plt.yticks([]) aquesta trama = plt.barra(abast(10), matriu_prediccions, color='# 777.777') plt.ylim([0, 1]) etiqueta_predit = per exemple..argmax(matriu_prediccions) aquesta trama[etiqueta_predit].set_color('Xarxa') aquesta trama[etiqueta_veritable].set_color('verd')
  • Vegem primer la 0a i la 10a imatge
jo = 0 plt.figura(mida de figs=(6,3)) plt.subtrama(1,2,1) imatge_trama(jo, prediccions, etiquetes_prova, imatges_prova) plt.subtrama(1,2,2) parcel_valor_trama(jo, prediccions, etiquetes_prova) plt.espectacle()

jo = 10 plt.figura(mida de figs=(6,3)) plt.subtrama(1,2,1) imatge_trama(jo, prediccions, etiquetes_prova, imatges_prova) plt.subtrama(1,2,2) parcel_valor_trama(jo, prediccions, etiquetes_prova) plt.espectacle()

  • Ara, representem diverses imatges i les seves prediccions. Les correctes són de color verd, mentre que les incorrectes són de color vermell.
num_rows = 5 num_cols = 3 num_imatges = num_rows*num_cols plt.figura(mida de figs=(2*2*num_cols, 2*num_rows)) per jo dins abast(num_imatges): plt.subtrama(num_rows, 2*num_cols, 2*jo+1) imatge_trama(jo, prediccions, etiquetes_prova, imatges_prova) plt.subtrama(num_rows, 2*num_cols, 2*jo+2) parcel_valor_trama(jo, prediccions, etiquetes_prova) plt.espectacle()

  • Finalment, utilitzarem el model entrenat per fer una predicció sobre una sola imatge.
# Agafeu una imatge del conjunt de dades de prova img = imatges_prova[0] imprimir(img.forma)
# Afegiu la imatge a un lot on sigui l'únic membre. img = (per exemple..expand_dims(img,0)) imprimir(img.forma)
prediccions_sola = model.predir(img) imprimir(prediccions_sola)

parcel_valor_trama(0, prediccions_sola, etiquetes_prova) plt.xticks(abast(10), noms_classe, rotació=45) plt.espectacle()

  • Com podeu veure la predicció de la nostra única imatge per lots.
resultat_predicció = per exemple..argmax(prediccions_sola[0])

Sortida: 9

CIFAR-10: CNN

El conjunt de dades CIFAR-10 consta d’avions, gossos, gats i altres objectes. Preprocessareu les imatges i, a continuació, formareu una xarxa neuronal convolucional en totes les mostres. Les imatges s’han de normalitzar i les etiquetes han de ser codificades amb un sol text. Aquest cas d’ús segur que aclarirà els vostres dubtes sobre la classificació d’imatges de TensorFlow.

  • Descàrrega de les dades
des de urllib.solicitud importació recuperar url des de os.path importació isfile, és sutge des de tqdm importació tqdm importació arxiu tarf cifar10_dataset_folder_path = 'cifar-10-batches-py' classe DownloadProgress(tqdm): last_block = 0 def ganxo(jo, nombre_bloc=1, mida_bloc=1, mida_total=Cap): jo.total = mida_total jo.actualització((nombre_bloc - jo.last_block) * mida_bloc) jo.last_block = nombre_bloc '' ' comproveu si el fitxer de dades (zip) ja està descarregat en cas contrari, descarregueu-lo a 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' i deseu-lo com a cifar-10-python.tar.gz '' ' si no isfile('cifar-10-python.tar.gz'): amb DownloadProgress(unitat='B', escala_unitat=És cert, miniters=1, desc='Conjunt de dades CIFAR-10') com pbar: recuperar url( 'Https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.ganxo) si no és sutge(cifar10_dataset_folder_path): amb arxiu tarf.obert('cifar-10-python.tar.gz') com quitrà: quitrà.extractall() quitrà.Tanca()
  • Importació de biblioteques necessàries
importació escabetx importació numpy com per exemple. importació matplotlib.pyplot com plt
  • Comprensió de les dades

El lot original de dades és 10000 × 3072 tensor expressat en una matriu numpy, on 10000 és el nombre de dades de mostra. La imatge és de color i de mida 32 × 32. L'alimentació es pot fer en un format de (amplada x alçada x num_canal) o (num_canal x amplada x alçada). Definim les etiquetes.

def load_label_names(): tornar ['avió', 'automòbil', 'ocell', 'gat', 'cérvol', 'gos', 'granota', 'cavall', 'vaixell', 'camió']
  • Remodelació de les dades

Anem a reformular les dades en dues etapes

En primer lloc, dividiu el vector de fila (3072) en 3 trossos. Cada peça correspon a cada canal. Això resulta en una dimensió (3 x 1024) d’un tensor. A continuació, dividiu el tensor resultant del pas anterior amb 32. 32 aquí significa l'amplada d'una imatge. Això es tradueix en (3x32x32).

En segon lloc, hem de transposar les dades des de (num_channel, width, height) a (width, height, num_channel). Per a això, utilitzarem la funció de transposició.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): amb obert(cifar10_dataset_folder_path + '/ data_batch_' + pàg(batch_id), mode='rb') com dossier: # tingueu en compte que el tipus de codificació és 'latin1' lot = escabetx.càrrega(dossier, codificació='latin1') característiques = lot['dades'].remodelar((len(lot['dades']), 3, 32, 32)).transposar(0, 2, 3, 1) etiquetes = lot['etiquetes'] tornar característiques, etiqueta
  • Exploració de les dades
def mostrar_estadístiques(cifar10_dataset_folder_path, batch_id, id_mostra): característiques, etiquetes = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) si no (0 <= id_mostra < len(característiques)): imprimir('{}mostres per lots{}.{}està fora de rang. '.format(len(característiques), batch_id, id_mostra)) tornar Cap imprimir(' Estadístiques del lot #{}: '.format(batch_id)) imprimir(Nombre de mostres:{} '.format(len(característiques))) noms_etiqueta = load_label_names() etiquetes_comptes = dict(cremallera(*per exemple..únic(etiquetes, retorn_comptes=És cert))) per clau, valor dins etiquetes_comptes.articles(): imprimir('Nombre d'etiquetes de [{}] ({}):{}'.format(clau, noms_etiqueta[clau].superior(), valor)) imatge_mostra = característiques[id_mostra] etiqueta_mostra = etiquetes[id_mostra] imprimir(' Exemple d'imatge{}: '.format(id_mostra)) imprimir('Imatge - Valor mínim:{}Valor màxim:{}'.format(imatge_mostra.mín(), imatge_mostra.màx())) imprimir('Imatge - Forma:{}'.format(imatge_mostra.forma)) imprimir('Etiqueta - Identificador de l'etiqueta:{}Nom:{}'.format(etiqueta_mostra, noms_etiqueta[etiqueta_mostra])) plt.imshow(imatge_mostra)
%matplotlib en linia %config InlineBackend.figura_format = 'Retina' importació numpy com per exemple. # Exploreu el conjunt de dades batch_id = 3 id_mostra = 7000 mostrar_estadístiques(cifar10_dataset_folder_path, batch_id, id_mostra)

  • Implementació de funcions de preprocessament

Normalitzarem les dades mitjançant la normalització mínima-màxima. Això simplement fa que tots els valors x variïn entre 0 i 1.
i = (x-min) / (max-min)

def normalitzar(x): '' ' argument - x: dades d'imatge d'entrada en matriu numpy [32, 32, 3] tornar - x normalitzat '' ' min_val = per exemple..mín(x) max_val = per exemple..màx(x) x = (x-min_val) / (max_val-min_val) tornar x
  • Codificació One-Hot
def one_hot_encode(x): '' ' argument - x: una llista d'etiquetes tornar - una matriu de codificació en calent (nombre d'etiquetes, nombre de classes) '' ' codificat = per exemple..zeros((len(x), 10)) per idx, hores dins enumerar(x): codificat[idx] [hores] = 1 tornar codificat
  • Pre-processar i desar les dades
def _preprocessar_ i desar(normalitzar, one_hot_encode, característiques, etiquetes, nom de l'arxiu): característiques = normalitzar(característiques) etiquetes = one_hot_encode(etiquetes) escabetx.abocador((característiques, etiquetes), obert(nom de l'arxiu, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalitzar, one_hot_encode): n_batches = 5 funcions_vàlides = [] etiquetes_vàlides = [] per batch_i dins abast(1, n_batches + 1): característiques, etiquetes = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # troba l'índex com a punt de dades de validació de tot el conjunt de dades del lot (10%) índex_de_validació = int(len(característiques) * 0.1) # preprocessa el 90% de tot el conjunt de dades del lot # - normalitzar les funcions # - one_hot_encode els lables # - deseu en un fitxer nou anomenat, 'preprocess_batch_' + batch_number # - cada fitxer per a cada lot _preprocessar_ i desar(normalitzar, one_hot_encode, característiques[:-índex_de_validació], etiquetes[:-índex_de_validació], 'preprocess_batch_' + pàg(batch_i) + '.p') # a diferència del conjunt de dades d'entrenament, el conjunt de dades de validació s'afegirà a tot el conjunt de dades per lots #: agafeu el 10% del conjunt de dades del lot # - Afegiu-los a una llista de # - funcions_vàlides # - etiquetes_vàlides funcions_vàlides.estendre(característiques[-índex_de_validació:]) etiquetes_vàlides.estendre(etiquetes[-índex_de_validació:]) # preprocessa el conjunt de dades de validació apilat _preprocessar_ i desar(normalitzar, one_hot_encode, per exemple..matriu(funcions_vàlides), per exemple..matriu(etiquetes_vàlides), 'preprocess_validation.p') # carregueu el conjunt de dades de prova amb obert(cifar10_dataset_folder_path + '/ test_batch', mode='rb') com dossier: lot = escabetx.càrrega(dossier, codificació='latin1') # preprocessa les dades de les proves característiques_prova = lot['dades'].remodelar((len(lot['dades']), 3, 32, 32)).transposar(0, 2, 3, 1) etiquetes_prova = lot['etiquetes'] # Preprocesseu i deseu totes les dades de proves _preprocessar_ i desar(normalitzar, one_hot_encode, per exemple..matriu(característiques_prova), per exemple..matriu(etiquetes_prova), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalitzar, one_hot_encode)
  • Punt de control
importació escabetx funcions_vàlides, etiquetes_vàlides = escabetx.càrrega(obert('preprocess_validation.p', mode='rb'))
  • Construint la xarxa

Tot el model consta de 14 capes en total.

què és un hashset java

importació tensorflow com tf def conv_net(x, keep_prob): conv1_filter = tf.Variable(tf.truncat_normal(forma=[3, 3, 3, 64], significar=0, stddev=0.08)) conv2_filter = tf.Variable(tf.truncat_normal(forma=[3, 3, 64, 128], significar=0, stddev=0.08)) conv3_filter = tf.Variable(tf.truncat_normal(forma=[5, 5, 128, 256], significar=0, stddev=0.08)) conv4_filter = tf.Variable(tf.truncat_normal(forma=[5, 5, 256, 512], significar=0, stddev=0.08)) # 1, 2 conv1 = tf.núm.conv2d(x, conv1_filter, avenços=[1,1,1,1], encoixinat='MATEIX') conv1 = tf.núm.relu(conv1) conv1_pool = tf.núm.piscina_màxima(conv1, ksize=[1,2,2,1], avenços=[1,2,2,1], encoixinat='MATEIX') conv1_bn = tf.capes.normalització_ per lots(conv1_pool) # 3, 4 conv2 = tf.núm.conv2d(conv1_bn, conv2_filter, avenços=[1,1,1,1], encoixinat='MATEIX') conv2 = tf.núm.relu(conv2) conv2_pool = tf.núm.piscina_màxima(conv2, ksize=[1,2,2,1], avenços=[1,2,2,1], encoixinat='MATEIX') conv2_bn = tf.capes.normalització_ per lots(conv2_pool) # 5, 6 conv3 = tf.núm.conv2d(conv2_bn, conv3_filter, avenços=[1,1,1,1], encoixinat='MATEIX') conv3 = tf.núm.relu(conv3) conv3_pool = tf.núm.piscina_màxima(conv3, ksize=[1,2,2,1], avenços=[1,2,2,1], encoixinat='MATEIX') conv3_bn = tf.capes.normalització_ per lots(conv3_pool) # 7, 8 conv4 = tf.núm.conv2d(conv3_bn, conv4_filter, avenços=[1,1,1,1], encoixinat='MATEIX') conv4 = tf.núm.relu(conv4) conv4_pool = tf.núm.piscina_màxima(conv4, ksize=[1,2,2,1], avenços=[1,2,2,1], encoixinat='MATEIX') conv4_bn = tf.capes.normalització_ per lots(conv4_pool) # 9 plana = tf.contribució.capes.aplanar(conv4_bn) # 10 complet1 = tf.contribució.capes.totalment_conectat(entrades=plana, num_outputs=128, activation_fn=tf.núm.relu) complet1 = tf.núm.abandonament(complet1, keep_prob) complet1 = tf.capes.normalització_ per lots(complet1) # 11 complet2 = tf.contribució.capes.totalment_conectat(entrades=complet1, num_outputs=256, activation_fn=tf.núm.relu) complet2 = tf.núm.abandonament(complet2, keep_prob) complet2 = tf.capes.normalització_ per lots(complet2) # 12 complet3 = tf.contribució.capes.totalment_conectat(entrades=complet2, num_outputs=512, activation_fn=tf.núm.relu) complet3 = tf.núm.abandonament(complet3, keep_prob) complet3 = tf.capes.normalització_ per lots(complet3) # 13 complet4 = tf.contribució.capes.totalment_conectat(entrades=complet3, num_outputs=1024, activation_fn=tf.núm.relu) complet4 = tf.núm.abandonament(complet4, keep_prob) complet4 = tf.capes.normalització_ per lots(complet4) # 14 fora = tf.contribució.capes.totalment_conectat(entrades=complet3, num_outputs=10, activation_fn=Cap) tornar fora
  • Hiperparàmetres
èpoques = 10 Mida del lot = 128 keep_probability = 0.7 taxa_aprenentatge = 0.001
logits = conv_net(x, keep_prob) model = tf.identitat(logits, nom='logits') # Name registra Tensor, de manera que es pot carregar des del disc després de l'entrenament # Pèrdua i Optimitzador cost = tf.reduir_mig(tf.núm.softmax_cross_entropy_with_logits(logits=logits, etiquetes=i)) optimitzador = tf.tren.AdamOptimizer(taxa_aprenentatge=taxa_aprenentatge).minimitzar(cost) # Precisió correct_pred = tf.igual(tf.argmax(logits, 1), tf.argmax(i, 1)) precisió = tf.reduir_mig(tf.repartiment(correct_pred, tf.float32), nom='precisió')
  • Entrena la xarxa neuronal
#Optimització única 
def
xarxa_neural_ tren(sessió, optimitzador, keep_probability, feature_batch, label_batch): sessió.correr(optimitzador, feed_dict={ x: feature_batch, i: label_batch, keep_prob: keep_probability })
#Showing Stats def print_stats(sessió, feature_batch, label_batch, cost, precisió): pèrdua = sess.correr(cost, feed_dict={ x: feature_batch, i: label_batch, keep_prob: 1. }) valid_acc = sess.correr(precisió, feed_dict={ x: funcions_vàlides, i: etiquetes_vàlides, keep_prob: 1. }) imprimir('Pèrdua:{:> 10.4f}Precisió de la validació:{: .6f}'.format(pèrdua, valid_acc))
  • Formació total i salvació del model
def batch_features_labels(característiques, etiquetes, Mida del lot): '' ' Dividiu les funcions i les etiquetes en lots '' ' per començar dins abast(0, len(característiques), Mida del lot): final = mín(començar + Mida del lot, len(característiques)) rendiment característiques[començar:final], etiquetes[començar:final] def load_preprocess_training_batch(batch_id, Mida del lot): '' ' Carregueu les dades de formació prèviament processades i torneu-les per lots o menys '' ' nom de l'arxiu = 'preprocess_batch_' + pàg(batch_id) + '.p' característiques, etiquetes = escabetx.càrrega(obert(nom de l'arxiu, mode='rb')) # Torneu les dades de formació en lots de mida o inferior tornar batch_features_labels(característiques, etiquetes, Mida del lot)
#Saving Model and Path 
guarda_model_path
= './image_classification' imprimir('Entrenant ...') amb tf.Sessió() com sess: # Inicialització de les variables sess.correr(tf.global_variables_initializer()) # Cicle formatiu per època dins abast(èpoques): # Repetició de tots els lots n_batches = 5 per batch_i dins abast(1, n_batches + 1): per funcions_de lots, batch_labels dins load_preprocess_training_batch(batch_i, Mida del lot): xarxa_neural_ tren(sess, optimitzador, keep_probability, funcions_de lots, batch_labels) imprimir('Època{:> 2}, CIFAR-10 per lots{}: '.format(època + 1, batch_i), final='') print_stats(sess, funcions_de lots, batch_labels, cost, precisió) # Desa el model estalviador = tf.tren.Estalviador() ruta_de_estalvi = estalviador.guardar(sess, guarda_model_path)

Ara, ja està feta la part important de la classificació d’imatges de Tensorflow. Ara, és hora de provar el model.

  • Prova del model
importació escabetx importació numpy com per exemple. importació matplotlib.pyplot com plt des de sklearn.preprocessament importació LabelBinarizer def batch_features_labels(característiques, etiquetes, Mida del lot): '' ' Dividiu les funcions i les etiquetes en lots '' ' per començar dins abast(0, len(característiques), Mida del lot): final = mín(començar + Mida del lot, len(característiques)) rendiment característiques[començar:final], etiquetes[començar:final] def exhibició_imatge_prediccions(característiques, etiquetes, prediccions, top_n_predictions): n_classes = 10 noms_etiqueta = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.en forma(abast(n_classes)) etiquetes_id = label_binarizer.transformació_inversa(per exemple..matriu(etiquetes)) fig, axies = plt.subtrames(nrows=top_n_predictions, ncols=2, mida de figs=(20, 10)) fig.ajustament_estreny() fig.subtítol('Prediccions de Softmax', mida de la font=20, i=1.1) n_prediccions = 3 marge = 0.05 ind = per exemple..arange(n_prediccions) amplada = (1. - 2. * marge) / n_prediccions per imatge_i, (característica, identificador_etiqueta, indicacions_pred, valors_pred) dins enumerar(cremallera(característiques, etiquetes_id, prediccions.índexs, prediccions.valors)): si (imatge_i < top_n_predictions): noms_pred = [noms_etiqueta[pred_i] per pred_i dins indicacions_pred] nom_correcte = noms_etiqueta[identificador_etiqueta] axies[imatge_i] [0].imshow((característica*255).astype(per exemple..int32, còpia=Fals)) axies[imatge_i] [0].set_title(nom_correcte) axies[imatge_i] [0].set_axis_off() axies[imatge_i] [1].barh(ind + marge, valors_pred[:3], amplada) axies[imatge_i] [1].set_yticks(ind + marge) axies[imatge_i] [1].set_yticklabels(noms_pred[::-1]) axies[imatge_i] [1].set_xticks([0, 0.5, 1.0])
%matplotlib en linia %config InlineBackend.figura_format = 'Retina' importació tensorflow com tf importació escabetx importació aleatori guarda_model_path = './image_classification' Mida del lot = 64 n_mostres = 10 top_n_predictions = 5 def model_prova(): característiques_prova, etiquetes_prova = escabetx.càrrega(obert('preprocess_training.p', mode='rb')) carregat_graf = tf.Gràfic() amb tf.Sessió(gràfic=carregat_graf) com sess: # Carrega el model carregador = tf.tren.import_meta_graph(guarda_model_path + '.meta') carregador.restaurar(sess, guarda_model_path) # Obteniu tensors del model carregat carregat_x = carregat_graf.get_tensor_by_name('input_x: 0') carregat_y = carregat_graf.get_tensor_by_name('output_y: 0') carregat_prova_de_provis = carregat_graf.get_tensor_by_name('keep_prob: 0') carregats_logits = carregat_graf.get_tensor_by_name('logits: 0') carregat_acc = carregat_graf.get_tensor_by_name('precisió: 0') # Obteniu precisió en lots per limitar la memòria test_batch_acc_total = 0 test_batch_count = 0 per tren_funció_lot, tren_label_batch dins batch_features_labels(característiques_prova, etiquetes_prova, Mida del lot): test_batch_acc_total + = sess.correr( carregat_acc, feed_dict={carregat_x: tren_funció_lot, carregat_y: tren_label_batch, carregat_probació_de_ manteniment: 1.0}) test_batch_count + = 1 imprimir('Precisió de la prova:{} '.format(test_batch_acc_total/test_batch_count)) # Imprimeix mostres aleatòries funcions de prova_aleatòria, etiquetes_prova_atzar = tupla(cremallera(*aleatori.mostra(llista(cremallera(característiques_prova, etiquetes_prova)), n_mostres))) prediccions_test_atzar = sess.correr( tf.núm.top_k(tf.núm.softmax(carregats_logits), top_n_predictions), feed_dict={carregat_x: funcions de prova_aleatòria, carregat_y: etiquetes_prova_atzar, carregat_probació_de_ manteniment: 1.0}) exhibició_imatge_prediccions(funcions de prova_aleatòria, etiquetes_prova_atzar, prediccions_test_atzar, top_n_predictions) model_prova()

Sortida: Precisió de la prova: 0,5882762738853503

Ara, si entreneu la vostra xarxa neuronal per obtenir més èpoques o canvieu la funció d’activació, és possible que obtingueu un resultat diferent que pugui tenir una precisió millor.

Així, amb això, arribem al final d’aquest article de Classificació d’imatges de TensorFlow. Estic segur que ara podeu utilitzar el mateix per classificar qualsevol tipus d’imatges i no sou un principiant en la classificació d’imatges.

D’Edureka amb formació de certificació Python està comissariada per professionals de la indústria segons els requisits i requisits de la indústria. Dominarà conceptes com ara la funció SoftMax, les xarxes neuronals del codificador automàtic, la màquina restringida de Boltzmann (RBM), Keras i TFLearn. El curs ha estat especialment comissariat per experts del sector amb estudis de casos en temps real.