Clasificación de imágenes de TensorFlow: todo lo que necesita saber sobre los clasificadores de edificios

Clasificación de imágenes, una tarea que incluso un bebé puede hacer en segundos, pero para una máquina, ha sido una tarea difícil hasta los recientes avances en y Aprendizaje profundo . Los coches autónomos pueden detectar objetos y tomar las medidas necesarias en tiempo real y la mayor parte de esto es posible gracias a Clasificación de imágenes. En este artículo, lo guiaré a través de los siguientes temas:

• ¿Qué es TensorFlow?
• ¿Qué es la clasificación de imágenes?
• Clasificación de imágenes de TensorFlow: Moda MNIST
• CIFAR 10: CNN

¿Qué es TensorFlow?

TensorFlow es el marco de trabajo de aprendizaje automático de código abierto de Google para la programación del flujo de datos en una variedad de tareas. Los nodos en el gráfico representan operaciones matemáticas, mientras que los bordes del gráfico representan las matrices de datos multidimensionales comunicadas entre ellos.

Los tensores son simplemente matrices multidimensionales, una extensión de tablas bidimensionales a datos con una dimensión superior. Hay muchas características de Tensorflow que lo hacen apropiado para el aprendizaje profundo y su biblioteca central de código abierto lo ayuda a desarrollar y entrenar modelos de aprendizaje automático.

¿Qué es la clasificación de imágenes?

La intención de la clasificación de imágenes es categorizar todos los píxeles de una imagen digital en uno de varios cobertura terrestre clases o temas . Estos datos categorizados se pueden utilizar para producir mapas temáticos de la cobertura terrestre presente en una imagen.

Ahora bien, dependiendo de la interacción entre el analista y la computadora durante la clasificación, existen dos tipos de clasificación:

java es una relación

• Supervisado y
• Sin supervisión

Entonces, sin perder tiempo, pasemos a la clasificación de imágenes de TensorFlow. Tengo 2 ejemplos: fácil y difícil. Procedamos con el más fácil.

Clasificación de imágenes de TensorFlow: Moda MNIST

Conjunto de datos de moda MNIST

Aquí vamos a utilizar Fashion MNIST Dataset, que contiene 70.000 imágenes en escala de grises en 10 categorías. Usaremos 60000 para entrenamiento y el resto 10000 para propósitos de prueba. Puede acceder a Fashion MNIST directamente desde TensorFlow, solo importe y cargue los datos.

• Primero importemos las bibliotecas

from __future__ import absolute_import, division, print_function # TensorFlow y tf.keras importan tensorflow como tf de tensorflow import keras # Las bibliotecas auxiliares importan numpy as np import matplotlib.pyplot as plt

• Carguemos los datos

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

• A continuación, vamos a mapear las imágenes en clases.

class_names = ['Camiseta / top', 'Pantalón', 'Jersey', 'Vestido', 'Abrigo', 'Sandalia', 'Camisa', 'Zapatilla deportiva', 'Bolso', 'Botines']

• Explorando los datos

train_images.forma 
#Cada etiqueta está entre 0-9

train_labels 
test_images.forma 

• Ahora es el momento de preprocesar los datos.

plt.figura() plt.imshow(train_images[0]) plt.barra de color() plt.cuadrícula(Falso) plt.show() 
#Si inspecciona la primera imagen del conjunto de entrenamiento, verá que los valores de los píxeles se encuentran en el rango de 0 a 255. 

• Tenemos que escalar las imágenes de 0-1 para alimentarlas a la red neuronal.

train_images = train_images / 255.0 test_images = test_images / 255.0

• Muestremos algunas imágenes.

plt.figura(figsize=(10,10)) para yo en rango(25): plt.subtrama(5,5,yo+1) plt.xticks([]) plt.yticks([]) plt.cuadrícula(Falso) plt.imshow(train_images[yo], cmap=plt.cm.binario) plt.xlabel(class_names[train_labels[yo]]) plt.show()

• Configurar las capas

modelo = difícil.Secuencial([ difícil.capas.Aplanar(input_shape=(28, 28)), difícil.capas.Denso(128, activación=tf.nos.relu), difícil.capas.Denso(10, activación=tf.nos.softmax) ])

• Compilar el modelo

modelo.compilar(optimizador='Adán', pérdida='sparse_categorical_crossentropy', métrica=['exactitud'])

• Entrenamiento de modelos

modelo.ajuste(train_images, train_labels, épocas=10)

• Evaluación de la precisión

test_loss, test_acc = modelo.evaluar(test_images, test_labels) impresión('Exactitud de la prueba:', test_acc)

• Haciendo predicciones

predicciones = modelo.predecir(test_images)

predicciones[0]

Una predicción es una matriz de 10 números. Estos describen la “confianza” del modelo en que la imagen corresponde a cada una de las 10 diferentes prendas de vestir. Podemos ver qué etiqueta tiene el valor de confianza más alto.

p.ej..argmax(predicciones[0])#Model está más seguro de que es un botín. Veamos si es correcto

Salida: 9

test_labels[0]

Salida: 9

• Ahora es el momento de ver el conjunto completo de 10 canales.

def plot_image(yo, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[yo], true_label[yo], img[yo] plt.cuadrícula(Falso) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binario) predicted_label = p.ej..argmax(predictions_array) Si predicted_label == true_label: color = 'verde' más: color = 'red' plt.xlabel('{} {: 2.0f}% ({})'.formato(class_names[predicted_label], 100*p.ej..max(predictions_array), class_names[true_label]), color=color) def plot_value_array(yo, predictions_array, true_label): predictions_array, true_label = predictions_array[yo], true_label[yo] plt.cuadrícula(Falso) plt.xticks([]) plt.yticks([]) esta trama = plt.bar(rango(10), predictions_array, color='#777777') plt.ylim([0, 1]) predicted_label = p.ej..argmax(predictions_array) esta trama[predicted_label].set_color('red') esta trama[true_label].set_color('verde')

• Veamos primero las imágenes 0 y 10

yo = 0 plt.figura(figsize=(6,3)) plt.subtrama(1,2,1) plot_image(yo, predicciones, test_labels, test_images) plt.subtrama(1,2,2) plot_value_array(yo, predicciones, test_labels) plt.show()

yo = 10 plt.figura(figsize=(6,3)) plt.subtrama(1,2,1) plot_image(yo, predicciones, test_labels, test_images) plt.subtrama(1,2,2) plot_value_array(yo, predicciones, test_labels) plt.show()

• Ahora, tracemos varias imágenes y sus predicciones. Los correctos son verdes, mientras que los incorrectos son rojos.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figura(figsize=(2*2*num_cols, 2*num_rows)) para yo en rango(num_images): plt.subtrama(num_rows, 2*num_cols, 2*yo+1) plot_image(yo, predicciones, test_labels, test_images) plt.subtrama(num_rows, 2*num_cols, 2*yo+2) plot_value_array(yo, predicciones, test_labels) plt.show()

• Finalmente, usaremos el modelo entrenado para hacer una predicción sobre una sola imagen.

# Toma una imagen del conjunto de datos de prueba img = test_images[0] impresión(img.forma)

# Agrega la imagen a un lote donde es el único miembro. img = (p.ej..expand_dims(img,0)) impresión(img.forma)

predictions_single = modelo.predecir(img) impresión(predictions_single)

plot_value_array(0, predictions_single, test_labels) plt.xticks(rango(10), class_names, rotación=45) plt.show()

• Como puede ver, la predicción de nuestra única imagen en lote.

prediction_result = p.ej..argmax(predictions_single[0])

Salida: 9

CIFAR-10: CNN

El conjunto de datos CIFAR-10 consta de aviones, perros, gatos y otros objetos. Preprocesará las imágenes y luego entrenará una red neuronal convolucional en todas las muestras. Las imágenes deben normalizarse y las etiquetas deben codificarse en un solo uso. Este caso de uso seguramente aclarará sus dudas sobre la clasificación de imágenes de TensorFlow.

• Descarga de datos

de urllib.request importar urlretrieve de os.path importar isfile, es hollín de tqdm importar tqdm importar tarfile cifar10_dataset_folder_path = 'cifar-10-lotes-py' clase Progreso de descarga(tqdm): last_block = 0 def gancho(yo, block_num=1, tamaño de bloque=1, tamaño total=Ninguna): yo.total = tamaño total yo.actualizar((block_num - yo.last_block) * tamaño de bloque) yo.last_block = block_num ''' compruebe si el archivo de datos (zip) ya está descargado si no, descárguelo de 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' y guárdelo como cifar-10-python.tar.gz ''' Si no isfile('cifar-10-python.tar.gz'): con Progreso de descarga(unidad='B', unit_scale=Cierto, minitros=1, desc='Conjunto de datos CIFAR-10') como pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.gancho) Si no es hollín(cifar10_dataset_folder_path): con tarfile.abierto('cifar-10-python.tar.gz') como alquitrán: alquitrán.extraer todo() alquitrán.cerrar()

• Importación de bibliotecas necesarias

importar pepinillo importar numpy como p.ej. importar matplotlib.pyplot como plt

• Entendiendo los datos

El lote original de datos es un tensor de 10000 × 3072 expresado en una matriz numérica, donde 10000 es el número de datos de muestra. La imagen está coloreada y de tamaño 32 × 32. La alimentación se puede realizar en un formato de (ancho x alto x núm_canal) o (núm_canal x ancho x alto). Definamos las etiquetas.

def load_label_names(): regreso ['avión', 'automóvil', 'pájaro', 'gato', 'ciervo', 'perro', 'rana', 'caballo', 'Embarcacion', 'camión']

• Remodelando los datos

Vamos a remodelar los datos en dos etapas.

En primer lugar, divida el vector fila (3072) en 3 partes. Cada pieza corresponde a cada canal. Esto da como resultado una dimensión (3 x 1024) de un tensor. Luego Divida el tensor resultante del paso anterior por 32. 32 aquí significa el ancho de una imagen. Esto da como resultado (3x32x32).

En segundo lugar, tenemos que transponer los datos de (num_canal, ancho, alto) a (ancho, alto, num_canal). Para eso, usaremos la función de transposición.

def load_cfar10_batch(cifar10_dataset_folder_path, ID del lote): con abierto(cifar10_dataset_folder_path + '/ data_batch_' + pags(ID del lote), modo='rb') como archivo: # tenga en cuenta que el tipo de codificación es 'latin1' lote = pepinillo.carga(archivo, codificacion='latin1') Características = lote['datos'].remodelar((len(lote['datos']), 3, 32, 32)).transponer(0, 2, 3, 1) etiquetas = lote['etiquetas'] regreso Características, etiqueta

• Explorando los datos

def display_stats(cifar10_dataset_folder_path, ID del lote, ejemplo de identificacion): Características, etiquetas = load_cfar10_batch(cifar10_dataset_folder_path, ID del lote) Si no (0 <= ejemplo de identificacion < len(Características)): impresión('{}muestras en lote{}.{}está fuera de alcance..formato(len(Características), ID del lote, ejemplo de identificacion)) regreso Ninguna impresión(' Estadísticas del lote #{}:'.formato(ID del lote)) impresión('# de muestras:{} '.formato(len(Características))) label_names = load_label_names() label_counts = dictar(Código Postal(*p.ej..único(etiquetas, return_counts=Cierto))) para llave, valor en label_counts.artículos(): impresión('Recuento de etiquetas de [{}]({}) :{}'.formato(llave, label_names[llave].Superior(), valor)) Imagen de muestra = Características[ejemplo de identificacion] sample_label = etiquetas[ejemplo de identificacion] impresión(' Ejemplo de imagen{}:'.formato(ejemplo de identificacion)) impresión('Imagen - Valor mínimo:{}Valor máximo:{}'.formato(Imagen de muestra.min(), Imagen de muestra.max())) impresión('Imagen - Forma:{}'.formato(Imagen de muestra.forma)) impresión('Etiqueta - ID de etiqueta:{}Nombre:{}'.formato(sample_label, label_names[sample_label])) plt.imshow(Imagen de muestra)

%matplotlib en línea %config InlineBackend.figure_format = 'retina' importar numpy como p.ej. # Explore el conjunto de datos ID del lote = 3 ejemplo de identificacion = 7000 display_stats(cifar10_dataset_folder_path, ID del lote, ejemplo de identificacion)

• Implementación de funciones de preprocesamiento

Vamos a normalizar los datos a través de la normalización Min-Max. Esto simplemente hace que todos los valores de x oscilen entre 0 y 1.
y = (x-min) / (max-min)

def normalizar(x): ''' argumento - x: datos de imagen de entrada en una matriz numérica [32, 32, 3] regreso - normalizado x ''' min_val = p.ej..min(x) max_val = p.ej..max(x) x = (x-min_val) / (max_val-min_val) regreso x

• Codificación One-Hot

def one_hot_encode(x): ''' argumento - x: una lista de etiquetas regreso - una matriz de codificación en caliente (número de etiquetas, número de clase) ''' codificado = p.ej..ceros((len(x), 10)) para idx, horas en enumerar(x): codificado[idx][horas] = 1 regreso codificado

• Preprocesar y guardar los datos

def _preprocess_and_save(normalizar, one_hot_encode, Características, etiquetas, nombre del archivo): Características = normalizar(Características) etiquetas = one_hot_encode(etiquetas) pepinillo.tugurio((Características, etiquetas), abierto(nombre del archivo, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizar, one_hot_encode): n_botes = 5 valid_features = [] valid_labels = [] para batch_i en rango(1, n_botes + 1): Características, etiquetas = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # encuentre que el índice sea el punto como datos de validación en todo el conjunto de datos del lote (10%) index_of_validation = En t(len(Características) * 0.1) # preprocesar el 90% de todo el conjunto de datos del lote # - normaliza las características # - one_hot_encode las etiquetas # - guardar en un nuevo archivo llamado 'preprocess_batch_' + batch_number # - cada archivo para cada lote _preprocess_and_save(normalizar, one_hot_encode, Características[:-index_of_validation], etiquetas[:-index_of_validation], 'preprocess_batch_' + pags(batch_i) + '.pags') # a diferencia del conjunto de datos de entrenamiento, el conjunto de datos de validación se agregará a través de todo el conjunto de datos por lotes # - tomar el 10% del conjunto de datos completo del lote # - agréguelos a una lista de # - valid_features # - valid_labels valid_features.ampliar(Características[-index_of_validation:]) valid_labels.ampliar(etiquetas[-index_of_validation:]) # preprocesar todo el conjunto de datos de validación apilado _preprocess_and_save(normalizar, one_hot_encode, p.ej..formación(valid_features), p.ej..formación(valid_labels), 'preprocess_validation.p') # cargar el conjunto de datos de prueba con abierto(cifar10_dataset_folder_path + '/ test_batch', modo='rb') como archivo: lote = pepinillo.carga(archivo, codificacion='latin1') # preprocesar los datos de prueba test_features = lote['datos'].remodelar((len(lote['datos']), 3, 32, 32)).transponer(0, 2, 3, 1) test_labels = lote['etiquetas'] # Preprocesar y guardar todos los datos de prueba _preprocess_and_save(normalizar, one_hot_encode, p.ej..formación(test_features), p.ej..formación(test_labels), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normalizar, one_hot_encode)

• Control

importar pepinillo valid_features, valid_labels = pepinillo.carga(abierto('preprocess_validation.p', modo='rb'))

• Construyendo la Red

El modelo completo consta de 14 capas en total.

importar tensorflow como tf def conv_net(x, keep_prob): conv1_filter = tf.Variable(tf.truncated_normal(forma=[3, 3, 3, 64], media=0, stddev=0.08)) conv2_filter = tf.Variable(tf.truncated_normal(forma=[3, 3, 64, 128], media=0, stddev=0.08)) conv3_filter = tf.Variable(tf.truncated_normal(forma=[5, 5, 128, 256], media=0, stddev=0.08)) conv4_filter = tf.Variable(tf.truncated_normal(forma=[5, 5, 256, 512], media=0, stddev=0.08)) # 1, 2 conv1 = tf.nos.conv2d(x, conv1_filter, zancadas=[1,1,1,1], relleno='MISMO') conv1 = tf.nos.relu(conv1) conv1_pool = tf.nos.max_pool(conv1, ksize=[1,2,2,1], zancadas=[1,2,2,1], relleno='MISMO') conv1_bn = tf.capas.batch_normalization(conv1_pool) # 3, 4 conv2 = tf.nos.conv2d(conv1_bn, conv2_filter, zancadas=[1,1,1,1], relleno='MISMO') conv2 = tf.nos.relu(conv2) conv2_pool = tf.nos.max_pool(conv2, ksize=[1,2,2,1], zancadas=[1,2,2,1], relleno='MISMO') conv2_bn = tf.capas.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.nos.conv2d(conv2_bn, conv3_filter, zancadas=[1,1,1,1], relleno='MISMO') conv3 = tf.nos.relu(conv3) conv3_pool = tf.nos.max_pool(conv3, ksize=[1,2,2,1], zancadas=[1,2,2,1], relleno='MISMO') conv3_bn = tf.capas.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.nos.conv2d(conv3_bn, conv4_filter, zancadas=[1,1,1,1], relleno='MISMO') conv4 = tf.nos.relu(conv4) conv4_pool = tf.nos.max_pool(conv4, ksize=[1,2,2,1], zancadas=[1,2,2,1], relleno='MISMO') conv4_bn = tf.capas.batch_normalization(conv4_pool) # 9 plano = tf.contrib.capas.aplanar(conv4_bn) # 10 completo1 = tf.contrib.capas.totalmente_conectado(entradas=plano, num_outputs=128, activación_fn=tf.nos.relu) completo1 = tf.nos.abandonar(completo1, keep_prob) completo1 = tf.capas.batch_normalization(completo1) # 11 full2 = tf.contrib.capas.totalmente_conectado(entradas=completo1, num_outputs=256, activación_fn=tf.nos.relu) full2 = tf.nos.abandonar(full2, keep_prob) full2 = tf.capas.batch_normalization(full2) # 12 full3 = tf.contrib.capas.totalmente_conectado(entradas=full2, num_outputs=512, activación_fn=tf.nos.relu) full3 = tf.nos.abandonar(full3, keep_prob) full3 = tf.capas.batch_normalization(full3) # 13 full4 = tf.contrib.capas.totalmente_conectado(entradas=full3, num_outputs=1024, activación_fn=tf.nos.relu) full4 = tf.nos.abandonar(full4, keep_prob) full4 = tf.capas.batch_normalization(full4) # 14 fuera = tf.contrib.capas.totalmente_conectado(entradas=full3, num_outputs=10, activación_fn=Ninguna) regreso fuera

• Hiperparámetros

épocas = 10 tamaño del lote = 128 keep_probability = 0.7 tasa de aprendizaje = 0.001

logits = conv_net(x, keep_prob) modelo = tf.identidad(logits, nombre='logits') # Nombre logits Tensor, para que se pueda cargar desde el disco después del entrenamiento # Pérdida y optimizador costo = tf.reduce_mean(tf.nos.softmax_cross_entropy_with_logits(logits=logits, etiquetas=y)) optimizador = tf.tren.AdamOptimizer(tasa de aprendizaje=tasa de aprendizaje).minimizar(costo) # Exactitud correct_pred = tf.igual(tf.argmax(logits, 1), tf.argmax(y, 1)) exactitud = tf.reduce_mean(tf.emitir(correct_pred, tf.float32), nombre='exactitud')

• Entrene la red neuronal

# Optimización única 
def train_neural_network(sesión, optimizador, keep_probability, feature_batch, label_batch): sesión.correr(optimizador, feed_dict={ x: feature_batch, y: label_batch, keep_prob: keep_probability })

#Showing Stats def print_stats(sesión, feature_batch, label_batch, costo, exactitud): pérdida = sess.correr(costo, feed_dict={ x: feature_batch, y: label_batch, keep_prob: 1. }) valid_acc = sess.correr(exactitud, feed_dict={ x: valid_features, y: valid_labels, keep_prob: 1. }) impresión('Pérdida:{:> 10.4f}Precisión de validación:{: .6f}'.formato(pérdida, valid_acc))

• Entrenamiento completo y guardado del modelo

def batch_features_labels(Características, etiquetas, tamaño del lote): ''' Divida características y etiquetas en lotes ''' para comienzo en rango(0, len(Características), tamaño del lote): fin = min(comienzo + tamaño del lote, len(Características)) rendimiento Características[comienzo:fin], etiquetas[comienzo:fin] def load_preprocess_training_batch(ID del lote, tamaño del lote): ''' Cargue los datos de entrenamiento preprocesados ​​y devuélvalos en lotes de o menos ''' nombre del archivo = 'preprocess_batch_' + pags(ID del lote) + '.pags' Características, etiquetas = pepinillo.carga(abierto(nombre del archivo, modo='rb')) # Devuelve los datos de entrenamiento en lotes de tamaño o menos regreso batch_features_labels(Características, etiquetas, tamaño del lote)

#Saving Model and Path 
save_model_path = './image_classification' impresión('Formación...') con tf.Sesión() como sess: # Inicializando las variables sess.correr(tf.global_variables_initializer()) # Ciclo formativo para época en rango(épocas): # Bucle sobre todos los lotes n_botes = 5 para batch_i en rango(1, n_botes + 1): para batch_features, batch_labels en load_preprocess_training_batch(batch_i, tamaño del lote): train_neural_network(sess, optimizador, keep_probability, batch_features, batch_labels) impresión('Época{:>2}, Lote CIFAR-10{}: '.formato(época + 1, batch_i), fin='') print_stats(sess, batch_features, batch_labels, costo, exactitud) # Guardar modelo ahorrador = tf.tren.Ahorrador() save_path = ahorrador.salvar(sess, save_model_path)

Ahora, la parte importante de la clasificación de imágenes de Tensorflow está lista. Ahora es el momento de probar el modelo.

• Probando el modelo

importar pepinillo importar numpy como p.ej. importar matplotlib.pyplot como plt de sklearn.preprocessing importar LabelBinarizer def batch_features_labels(Características, etiquetas, tamaño del lote): ''' Divida características y etiquetas en lotes ''' para comienzo en rango(0, len(Características), tamaño del lote): fin = min(comienzo + tamaño del lote, len(Características)) rendimiento Características[comienzo:fin], etiquetas[comienzo:fin] def display_image_predictions(Características, etiquetas, predicciones, predicciones): n_clases = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.ajuste(rango(n_clases)) label_ids = label_binarizer.transformación_inversa(p.ej..formación(etiquetas)) higo, axies = plt.subtramas(nrows=predicciones, ncols=2, figsize=(20, 10)) higo.tight_layout() higo.subtítulo('Predicciones Softmax', tamaño de fuente=20, y=1.1) n_predicciones = 3 margen = 0.05 Indiana = p.ej..arange(n_predicciones) anchura = (1. - 2. * margen) / n_predicciones para image_i, (característica, label_id, pred_indicies, pred_values) en enumerar(Código Postal(Características, label_ids, predicciones.índices, predicciones.valores)): Si (image_i < predicciones): pred_names = [label_names[pred_i] para pred_i en pred_indicies] nombre correcto = label_names[label_id] axies[image_i][0].imshow((característica*255).astipo(p.ej..int32, Copiar=Falso)) axies[image_i][0].set_title(nombre correcto) axies[image_i][0].set_axis_off() axies[image_i][1].barh(Indiana + margen, pred_values[:3], anchura) axies[image_i][1].set_yticks(Indiana + margen) axies[image_i][1].set_yticklabels(pred_names[::-1]) axies[image_i][1].set_xticks([0, 0.5, 1.0])

%matplotlib en línea %config InlineBackend.figure_format = 'retina' importar tensorflow como tf importar pepinillo importar aleatorio save_model_path = './image_classification' tamaño del lote = 64 n_samples = 10 predicciones = 5 def modelo_prueba(): test_features, test_labels = pepinillo.carga(abierto('preprocess_training.p', modo='rb')) gráfico_cargado = tf.Grafico() con tf.Sesión(grafico=gráfico_cargado) como sess: # Modelo de carga cargador = tf.tren.import_meta_graph(save_model_path + '.meta') cargador.restaurar(sess, save_model_path) # Obtener tensores del modelo cargado cargado_x = gráfico_cargado.get_tensor_by_name('entrada_x: 0') cargado_y = gráfico_cargado.get_tensor_by_name('salida_y: 0') loaded_keep_prob = gráfico_cargado.get_tensor_by_name('keep_prob: 0') load_logits = gráfico_cargado.get_tensor_by_name('logits: 0') cargado_acc = gráfico_cargado.get_tensor_by_name('precisión: 0') # Obtenga precisión en lotes para limitaciones de memoria test_batch_acc_total = 0 test_batch_count = 0 para train_feature_batch, train_label_batch en batch_features_labels(test_features, test_labels, tamaño del lote): test_batch_acc_total += sess.correr( cargado_acc, feed_dict={cargado_x: train_feature_batch, cargado_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count += 1 impresión(Exactitud de las pruebas:{} '.formato(test_batch_acc_total/test_batch_count)) # Imprimir muestras aleatorias características_de_prueba_aleatorias, etiquetas_de_prueba_aleatorias = tupla(Código Postal(*aleatorio.muestra(lista(Código Postal(test_features, test_labels)), n_samples))) predicciones_de_prueba_aleatorias = sess.correr( tf.nos.top_k(tf.nos.softmax(load_logits), predicciones), feed_dict={cargado_x: características_de_prueba_aleatorias, cargado_y: etiquetas_de_prueba_aleatorias, loaded_keep_prob: 1.0}) display_image_predictions(características_de_prueba_aleatorias, etiquetas_de_prueba_aleatorias, predicciones_de_prueba_aleatorias, predicciones) modelo_prueba()

Salida: Exactitud de la prueba: 0.5882762738853503

Ahora, si entrena su red neuronal para más épocas o cambia la función de activación, puede obtener un resultado diferente que podría tener una mayor precisión.

Entonces, con esto, llegamos al final de este artículo de Clasificación de imágenes de TensorFlow. Estoy seguro de que ahora puedes usar lo mismo para clasificar cualquier tipo de imágenes y no eres un principiante en la clasificación de imágenes.

Edureka's con la certificación de Python, la capacitación es seleccionada por profesionales de la industria según los requisitos y demandas de la industria. Dominará conceptos como la función SoftMax, redes neuronales con codificador automático, máquina de Boltzmann restringida (RBM), Keras y TFLearn. El curso ha sido especialmente comisariado por expertos de la industria con estudios de casos en tiempo real.