Clasificación de imágenes de CNN en TensorFlow con pasos y ejemplos

¿Qué es una red neuronal convolucional?

Red neuronal convolucionalLas redes neuronales convolucionales (CNN, por sus siglas en inglés) son un método muy conocido en aplicaciones de visión artificial. Se trata de una clase de redes neuronales profundas que se utilizan para analizar imágenes visuales. Este tipo de arquitectura es fundamental para el reconocimiento de objetos en fotografías o vídeos. Se emplea en aplicaciones como el reconocimiento de imágenes o vídeos, el procesamiento del lenguaje natural y los sistemas de recomendación.

ArchiEstructura de una red neuronal convolucional

Piense en Facebook hace unos años, después de cargar una imagen en su perfil, se le pedía que agregara un nombre a la cara en la imagen manualmente. Hoy en día, Facebook usa convnet para etiquetar a tu amigo en la imagen automáticamente.

Una red neuronal convolucional para la clasificación de imágenes no es muy difícil de entender. Una imagen de entrada se procesa durante la fase de convolución y luego se le asigna una etiqueta.

La arquitectura típica de una red neuronal convolucional se puede resumir en la siguiente imagen. En primer lugar, se introduce una imagen en la red; esta se denomina imagen de entrada. A continuación, la imagen de entrada pasa por una serie de pasos; esta es la parte convolucional de la red. Finalmente, la red neuronal puede predecir el dígito en la imagen.

Una imagen se compone de una matriz de píxeles con altura y anchura. Una imagen en escala de grises tiene un solo canal, mientras que una imagen a color tiene tres canales (uno para rojo, uno para verde y uno para azul). Los canales se apilan uno encima del otro. En este tutorial, utilizarás una imagen en escala de grises con un solo canal. Cada píxel tiene un valor entre 0 y 255 que refleja la intensidad del color. Por ejemplo, un píxel con valor 0 mostrará un color blanco, mientras que un píxel con un valor cercano a 255 será más oscuro.

Echemos un vistazo a una imagen almacenada en el conjunto de datos MNISTLa imagen a continuación muestra cómo representar la imagen de la izquierda en formato de matriz. Tenga en cuenta que la matriz original se ha estandarizado para que sus valores estén entre 0 y 1. Para los colores más oscuros, el valor en la matriz es aproximadamente 0.9, mientras que los píxeles blancos tienen un valor de 0.

operación convolucional

El componente más importante del modelo es la capa convolucional. Esta parte tiene como objetivo reducir el tamaño de la imagen para acelerar el cálculo de los pesos y mejorar la generalización.

Durante la parte convolucional, la red mantiene las características esenciales de la imagen y excluye el ruido irrelevante. Por ejemplo, el modelo está aprendiendo a reconocer un elefante en una imagen con una montaña de fondo. Si utilizas una red neuronal tradicional, el modelo asignará un peso a todos los píxeles, incluidos los de la montaña, que no es imprescindible y puede inducir a error a la red.

En cambio, un Keras La red neuronal convolucional utilizará una técnica matemática para...tracSolo se seleccionan los píxeles más relevantes. Esta operación matemática se denomina convolución. Esta técnica permite que la red aprenda características cada vez más complejas en cada capa. La convolución divide la matriz en pequeños fragmentos para extraer los elementos más esenciales de cada fragmento.

Componentes de la red neuronal convolucional (ConvNet o CNN)

Una red neuronal convolucional (convnet) consta de cuatro componentes:

1. Circunvolución
2. No linealidad (ReLU)
3. Pooling o submuestreo
4. Clasificación (capa totalmente conectada)

Circunvolución

El propósito de la convolución es extract las características del objeto en la imagen localmente. Esto significa que la red aprenderá patrones específicos dentro de la imagen y podrá reconocerlos en cualquier parte de la misma.

La convolución es una multiplicación elemento a elemento. El concepto es fácil de entender. El ordenador escanea una parte de la imagen, generalmente de 3x3, y la multiplica por un filtro. El resultado de esta multiplicación se denomina mapa de características. Este paso se repite hasta que se haya escaneado toda la imagen. Cabe destacar que, tras la convolución, el tamaño de la imagen se reduce.

El diagrama que aparece a continuación muestra cómo un fragmento de la imagen se multiplica mediante el filtro para producir una sola celda del mapa de características.

La animación que aparece a continuación muestra la misma convolución recorriendo toda la imagen.

Existen numerosos filtros disponibles. A continuación, enumeramos algunos de ellos. Como puede observar, cada filtro tiene una finalidad específica. Tenga en cuenta que, en la imagen inferior, el kernel es sinónimo del filtro.

Aritmética detrás de la convolución.

La fase convolucional aplicará el filtro a una pequeña matriz de píxeles dentro de la imagen. El filtro se desplazará a lo largo de la imagen de entrada con una forma general de 3×3 o 5×5. Esto significa que la red deslizará estas ventanas a través de toda la imagen de entrada y calculará la convolución. La animación a continuación muestra cómo funciona la convolución. El tamaño del parche es de 3×3, y la matriz de salida es el resultado de la operación elemento a elemento entre la matriz de la imagen y el filtro.

Observa que el ancho y el alto de la salida pueden ser diferentes del ancho y el alto de la entrada. Sucede por el efecto frontera.

Efecto de borde

La imagen tiene un mapa de características de 5×5 y un filtro de 3×3. Solo hay una ventana en el centro donde el filtro puede mostrar una cuadrícula de 3×3. El mapa de características resultante se reduce en dos mosaicos en cada eje, dejando una dimensión de 3×3.

Para obtener la misma dimensión de salida que la de entrada, es necesario añadir relleno. El relleno consiste en añadir el número correcto de filas y columnas a cada lado de la matriz. Esto permitirá que la convolución se ajuste al centro de cada celda de entrada. En la imagen siguiente, las matrices de entrada y salida tienen la misma dimensión, 5×5.

Cuando define la red, las funciones convolucionadas se controlan mediante tres parámetros:

Profundidad: Define el número de filtros que se aplicarán durante la convolución. En el ejemplo anterior, se observó una profundidad de 1, lo que significa que solo se utiliza un filtro. En la mayoría de los casos, se utilizan varios filtros. La animación a continuación muestra las operaciones realizadas con tres filtros.

Paso: Define el número de "saltos de píxeles" entre dos secciones. Si el paso es igual a 1, la ventana se desplazará con una separación de un píxel. Si el paso es igual a dos, la ventana se desplazará dos píxeles. Si aumenta el paso, obtendrá mapas de características más pequeños. Los dos diagramas siguientes comparan un paso de 1 con un paso de 2.

Ejemplo de zancada 1

paso 2

Relleno de ceros: El relleno consiste en añadir un número correspondiente de filas y columnas a cada lado de los mapas de características de entrada. En este caso, la salida tiene las mismas dimensiones que la entrada.

No linealidad (ReLU)

Al finalizar la operación de convolución, la salida se somete a una función de activación para permitir la no linealidad. La función de activación habitual para una red neuronal convolucional es ReLU. Todos los píxeles con un valor negativo se reemplazarán por cero.

Pooling Operadisrupción

Este paso es fácil de entender. El objetivo del pooling es reducir la dimensionalidad de la imagen de entrada. Los pasos se realizan para disminuir la complejidad computacional de la operación. Al reducir la dimensionalidad, la red tiene menos pesos que calcular, lo que previene el sobreajuste.

En esta etapa, debes definir el tamaño y el paso. Una forma estándar de agrupar la imagen de entrada es usar el valor máximo del mapa de características. Observa la imagen a continuación. El agrupamiento filtrará cuatro submatrices del mapa de características de 4×4 y devolverá el valor máximo. El agrupamiento toma el valor máximo de una matriz de 2×2 y luego mueve esta ventana dos píxeles. Por ejemplo, la primera submatriz es [3,1,3,2], por lo que el agrupamiento devolverá el máximo, que es 3.

Existe otra operación de agrupación como es la media.

Esta operación reduce drásticamente el tamaño del mapa de características.

Capas totalmente conectadas

El último paso consiste en construir un tradicional Red neuronal artificial como lo hiciste en el tutorial anterior. Conectas todas las neuronas de la capa anterior a la siguiente. Utiliza una función de activación de softmax para clasificar el número en la imagen de entrada.

Recapitulación:

Una red neuronal convolucional de TensorFlow compila diferentes capas antes de realizar una predicción. Una red neuronal tiene:

• Una capa convolucional
• Función de activación ReLU
• Poolincapa g
• Capa densamente conectada

Las capas convolucionales aplican diferentes filtros a una subregión de la imagen. La función de activación ReLU añade no linealidad, y las capas de agrupación reducen la dimensionalidad de los mapas de características.

Todas estas capas extracinformación esencial de las imágenes. Finalmente, los mapas de características se introducen en una capa totalmente conectada con una función softmax para realizar una predicción.

Entrena CNN con TensorFlow

Ahora que ya conoces los componentes básicos de una red convolucional, estás listo para construir una con TensorFlow. Usaremos el conjunto de datos MNIST para la clasificación de imágenes de CNN.

La preparación de los datos es la misma que en el tutorial anterior. Puedes ejecutar los códigos y saltar directamente a la arquitectura de la CNN.

Seguirá los pasos a continuación para la clasificación de imágenes usando CNN:

1. Paso 1: cargar el conjunto de datos
2. Paso 2: capa de entrada
3. Paso 3: capa convolucional
4. Paso 4: Poolincapa g
5. Paso 5: Segunda capa convolucional y Pooling Capa
6. Paso 6: capa densa
7. Paso 7: Capa Logit

Nota de versión: Los listados a continuación están dirigidos a TensorFlow 1.x. En TensorFlow 2, el espacio de nombres tf.layers y tf.estimator.inputs.numpy_input_fn ya no existen; los equivalentes son tf.keras.layers.Conv2D, MaxPoolinLas capas g2D, Dense y Dropout se ensamblan en un objeto tf.keras.Model y se entrenan con model.fit(). Lea los pasos para comprender el funcionamiento de cada capa y luego mapéelos a la API de Keras.

Paso 1: cargar el conjunto de datos

El conjunto de datos MNIST está disponible a través de scikit-learn. Descárguelo y guárdelo en la carpeta Descargas. Puede subirlo con fetch_mldata('MNIST original').

Nota de versión: mldata.org ha cerrado y fetch_mldata() se eliminó en scikit-learn 0.22. En cualquier instalación actual, cargue los mismos dígitos con buscar_openml En su lugar, se utiliza fetch_openml('mnist_784', version=1). El resto del proceso permanece sin cambios.

Crear un conjunto de tren/prueba

Necesitas dividir el conjunto de datos con train_test_split.

Escalar las características

Finalmente, puedes escalar las características con MinMaxScaler como se muestra en el siguiente ejemplo de clasificación de imágenes usando una CNN de TensorFlow.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Definir la CNN

Una CNN utiliza filtros en los píxeles sin procesar de una imagen para aprender patrones de detalle en comparación con los patrones globales aprendidos por una red neuronal tradicional. Para construir una CNN, es necesario definir:

1. Una capa convolucional: Aplica n filtros al mapa de características. Después de la convolución, debes usar una función de activación ReLU para añadir no linealidad a la red.
2. PoolinCapa g: El siguiente paso después de la convolución es reducir la dimensionalidad del mapa de características para evitar el sobreajuste y mejorar la velocidad de cálculo. La técnica convencional es el max pooling, que divide los mapas de características en subregiones (generalmente de 2×2) y conserva solo los valores máximos.
3. Capas completamente conectadas: todas las neuronas de las capas anteriores están conectadas a las capas siguientes. La CNN clasificará la etiqueta según las características de las capas convolucionales y las reducirá con la capa de agrupamiento.

Arquitectura CNN

• Capa convolucional: Aplica 14 filtros de 5×5 (ej.tracsubregiones de 5×5 píxeles), con función de activación ReLU
• PoolinCapa g: realiza una agrupación máxima con un filtro 2×2 y un paso de 2 (que especifica que las regiones agrupadas no se superponen)
• Capa convolucional: Aplica 36 filtros de 5×5, con función de activación ReLU
• PoolinCapa g n.° 2: nuevamente, realiza una agrupación máxima con un filtro 2x2 y un paso de 2
• 1,764 neuronas, con una tasa de regularización de abandono de 0.4 (probabilidad de 0.4 de que cualquier elemento determinado se elimine durante el entrenamiento)
• Capa densa (capa logits): 10 neuronas, una para cada clase objetivo de dígito (0 a 9).

Hay tres módulos importantes que se pueden utilizar para crear una CNN:

• conv2d(). Construye una capa convolucional bidimensional con el número de filtros, el tamaño del núcleo del filtro, el relleno y la función de activación como argumentos.
• max_pooling2d(). Construye una capa de agrupamiento bidimensional utilizando el algoritmo max-pooling.
• denso(). Construye una capa densa con las capas y unidades ocultas.

Definirás una función para construir la CNN. Veamos en detalle cómo construir cada bloque antes de finalizar.ping todo junto en la función.

Paso 2: capa de entrada

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Necesita definir un tensor con la forma de los datos. Para eso, puedes usar el módulo tf.reshape. En este módulo, debes declarar el tensor a reformar y la forma del tensor. El primer argumento son las características de los datos, que se definen en el argumento de la función.

Una imagen tiene una altura, un ancho y un canal. El conjunto de datos MNIST es una imagen monocromática de 28 × 28 píxeles. Establecemos el tamaño del lote en -1 en el argumento `shape` para que adopte la forma de las características `["x"]`. La ventaja es que el tamaño del lote se convierte en un hiperparámetro ajustable. Si el tamaño del lote se establece en 7, el tensor recibirá 5,488 valores (28 × 28 × 7).

Paso 3: capa convolucional

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

La primera capa convolucional tiene 14 filtros con un tamaño de núcleo de 5×5 y el mismo relleno. El mismo relleno significa que tanto el tensor de salida como el de entrada deben tener la misma altura y anchura. TensorFlow añadirá ceros a las filas y columnas para garantizar el mismo tamaño.

Se utiliza la función de activación ReLU. El tamaño de la salida será [28, 28, 14].

Paso 4: Poolincapa g

El siguiente paso después de la convolución es el cálculo de agrupamiento. Este cálculo reducirá la dimensionalidad de los datos. Puede usar el módulo max_pooling2d con un tamaño de 2×2 y un paso de 2. Use la capa anterior como entrada. El tamaño de salida será [batch_size, 14, 14, 14].

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Paso 5: Segunda capa convolucional y Pooling Capa

La segunda capa convolucional aplica 36 filtros, lo que da como resultado un tamaño de salida de [batch_size, 14, 14, 36]. La capa de agrupación utiliza la misma ventana de 2×2 y un paso de 2 que antes, por lo que divide a la mitad cada eje espacial y la forma de salida se convierte en [batch_size, 7, 7, 36].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Paso 6: capa densa

A continuación, debes definir la capa totalmente conectada. El mapa de entidades debe aplanarse antes de conectarse con la capa densa. Puedes usar el módulo de redimensionamiento con un tamaño de 7*7*36.

La capa densa conectará 1,764 neuronas. Se añade una función de activación ReLU. Además, se agrega un término de regularización de abandono (dropout) con una tasa de 0.3, lo que significa que el 30 % de las activaciones se establecerán en 0. Cabe destacar que el abandono solo se aplica durante la fase de entrenamiento. La función `cnn_model_fn` tiene un argumento `mode` para indicar si el modelo necesita ser entrenado o evaluado, como se muestra en el siguiente ejemplo de clasificación de imágenes con CNN en TensorFlow.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Paso 7: Capa Logit

Finalmente, en el ejemplo de clasificación de imágenes de TensorFlow, se puede definir la última capa con la predicción del modelo. La forma de salida es igual al tamaño del lote más 10, el número total de clases objetivo.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Puedes crear un diccionario que contenga las clases y la probabilidad de cada una. La función tf.argmax() devuelve el índice del valor más alto en la capa logit. La función softmax devuelve la probabilidad de cada clase.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Solo debes devolver el diccionario de predicciones cuando el modo esté configurado como predicción. Agrega este código para mostrar las predicciones.

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

El siguiente paso consiste en calcular la pérdida del modelo. En el tutorial anterior, aprendiste que la función de pérdida para un modelo multiclase es la entropía cruzada. La pérdida se calcula fácilmente con el siguiente código:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

El último paso del ejemplo de CNN de TensorFlow consiste en optimizar el modelo, es decir, encontrar los mejores valores para los pesos. Para ello, se utiliza un optimizador de descenso de gradiente con una tasa de aprendizaje de 0.001. El objetivo es minimizar la función de pérdida.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Ya has terminado con la CNN. Sin embargo, quieres visualizar las métricas de rendimiento durante el modo de evaluación. La métrica de rendimiento para un modelo multiclase es la precisión. TensorFlow cuenta con un módulo de precisión que acepta dos argumentos: las etiquetas y los valores predichos.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Eso es todo. Creaste tu primera CNN y estás listo para envolver todo en una función para usarla para entrenar y evaluar el modelo.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Nota sobre la función ensamblada: La versión encapsulada anterior configura la primera capa convolucional con 32 filtros y un valor de dropout de 0.4, mientras que los fragmentos paso a paso utilizan 14 filtros y 0.3. Ambas se ejecutan, pero elija un par de valores y manténgalos consistentes para que las formas impresas coincidan con la tabla de capas.

Los pasos a continuación son los mismos que los de los tutoriales anteriores.

En primer lugar, define un estimador con el modelo CNN para la clasificación de imágenes.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

El entrenamiento de una red neuronal convolucional (CNN) lleva mucho tiempo; por lo tanto, se crea un mecanismo de registro para almacenar los valores de las capas softmax cada 50 iteraciones.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Ya puedes estimar el modelo. Establece un tamaño de lote de 100 y baraja los datos. Ten en cuenta que hemos configurado 16 000 pasos de entrenamiento, lo que puede llevar mucho tiempo. Sé paciente.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Ahora que el modelo está entrenado, puedes evaluarlo e imprimir los resultados.

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

La evaluación imprime el punto de control restaurado, el paso en el que se detuvo y el diccionario de métricas final.

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Con la arquitectura actual, el diccionario de evaluación informa una precisión de 0.9689286, aproximadamente un 97%. Puede cambiar la arquitectura, el tamaño del lote y el número de iteraciones para mejorar la precisión. La CNN ha tenido un rendimiento mucho mejor que una Red neuronal artificial o regresión logística: en el tutorial sobre redes neuronales artificiales, obtuviste una precisión del 96%, inferior a la de la CNN. El rendimiento de la CNN es impresionante con un conjunto de imágenes más grande, tanto en términos de velocidad de cálculo como de precisión.

Preguntas Frecuentes