¿Qué es la red neuronal convolucional?
La red neuronal convolucional, también conocida como convnets o CNN, es un método bien conocido en las aplicaciones de visión por computadora. Este tipo de arquitectura es dominante para reconocer objetos de una imagen o video.
En este tutorial, aprenderá cómo construir una convnet y cómo usar TensorFlow para resolver el conjunto de datos escrito a mano.
En este tutorial, aprenderá
- Red neuronal convolucional
- Arquitectura de una red neuronal convolucional
- Componentes de Convnets
- Entrena CNN con TensorFlow
- Paso 1: Cargar conjunto de datos
- Paso 2: capa de entrada
- Paso 3: capa convolucional
- Paso 4: capa de agrupación
- Paso 5: Segunda capa convolucional y capa de agrupación
- Paso 6: capa densa
- Paso 7: Capa Logit
Arquitectura de una red neuronal convolucional
Piense en Facebook hace unos años, después de que subió una imagen a su perfil, se le pidió 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 no es muy difícil de entender. Una imagen de entrada se procesa durante la fase de convolución y luego se le atribuye una etiqueta.
Una arquitectura de convnet típica se puede resumir en la siguiente imagen. En primer lugar, se envía una imagen a la red; esto se llama imagen de entrada. Luego, la imagen de entrada pasa por un número infinito de pasos; esta es la parte convolucional de la red. Finalmente, la red neuronal puede predecir el dígito de la imagen.
Una imagen se compone de una matriz de píxeles con alto y ancho. Una imagen en escala de grises tiene solo un canal, mientras que la imagen en color tiene tres canales (cada uno para rojo, verde y azul). Un canal se apila uno sobre el otro. En este tutorial, utilizará una imagen en escala de grises con un solo canal. Cada píxel tiene un valor de 0 a 255 para reflejar la intensidad del color. Por ejemplo, un píxel igual a 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 MNIST. La siguiente imagen muestra cómo representar la imagen de la izquierda en un formato de matriz. Tenga en cuenta que la matriz original se ha estandarizado para estar entre 0 y 1. Para colores más oscuros, el valor en la matriz es de aproximadamente 0,9 mientras que los píxeles blancos tienen un valor de 0.
Operación convolucional
El componente más crítico del modelo es la capa convolucional. Esta parte tiene como objetivo reducir el tamaño de la imagen para cálculos más rápidos de los pesos y mejorar su generalización.
Durante la parte convolucional, la red conserva las características esenciales de la imagen y excluye el ruido irrelevante. Por ejemplo, el modelo está aprendiendo a reconocer un elefante de una imagen con una montaña al fondo. Si utiliza 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, una red neuronal convolucional utilizará una técnica matemática para extraer solo los píxeles más relevantes. Esta operación matemática se llama 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ñas piezas para aprender a conocer los elementos más esenciales dentro de cada pieza.
Componentes de Convnets
Hay cuatro componentes de Convnets
- Circunvolución
- No linealidad (ReLU)
- Agrupación o submuestreo
- Clasificación (capa completamente conectada)
- Circunvolución
El propósito de la convolución es extraer las características del objeto en la imagen localmente. Significa que la red aprenderá patrones específicos dentro de la imagen y podrá reconocerlos en todas partes de la imagen.
La convolución es una multiplicación por elementos. El concepto es fácil de entender. La computadora escaneará una parte de la imagen, generalmente con una dimensión de 3x3 y la multiplicará en un filtro. La salida de la multiplicación por elementos se denomina mapa de características. Este paso se repite hasta que se escanea toda la imagen. Tenga en cuenta que, después de la convolución, se reduce el tamaño de la imagen.
A continuación, hay una URL para ver en acción cómo funciona la convolución.
Hay numerosos canales disponibles. A continuación, enumeramos algunos de los canales. Puede ver que cada filtro tiene un propósito específico. Tenga en cuenta, en la imagen de abajo; el Kernel es sinónimo de filtro.
Fuente
Aritmética detrás de la convolución
La fase convolucional aplicará el filtro en una pequeña matriz de píxeles dentro de la imagen. El filtro se moverá a lo largo de la imagen de entrada con una forma general de 3x3 o 5x5. Significa que la red deslizará estas ventanas por toda la imagen de entrada y calculará la convolución. La siguiente imagen muestra cómo funciona la convolución. El tamaño del parche es 3x3 y la matriz de salida es el resultado de la operación de elementos entre la matriz de imagen y el filtro.
Fuente
Observa que el ancho y el alto de la salida pueden ser diferentes del ancho y alto de la entrada. Sucede por el efecto borde.
Efecto de borde
La imagen tiene un mapa de características de 5x5 y un filtro de 3x3. Solo hay una ventana en el centro donde el filtro puede filtrar una cuadrícula de 3x3. El mapa de características de salida se reducirá en dos mosaicos junto con una dimensión de 3x3.
Para obtener la misma dimensión de salida que la dimensión de entrada, debe agregar relleno. El relleno consiste en agregar el número correcto de filas y columnas en cada lado de la matriz. Permitirá que la convolución se ajuste al centro de cada mosaico de entrada. En la imagen de abajo, la matriz de entrada / salida tiene la misma dimensión 5x5
Cuando define la red, las entidades convolucionadas se controlan mediante tres parámetros:
- Profundidad: define la cantidad de filtros a aplicar durante la convolución. En el ejemplo anterior, vio una profundidad de 1, lo que significa que solo se usa un filtro. En la mayoría de los casos, hay más de un filtro. La siguiente imagen muestra las operaciones realizadas en una situación con tres filtros
- Stride: define el número de "salto de píxel" entre dos cortes. Si la zancada es igual a 1, las ventanas se moverán con una extensión de un píxel de uno. Si la zancada es igual a dos, las ventanas saltarán 2 píxeles. Si aumenta la zancada, tendrá mapas de características más pequeños.
Ejemplo de zancada 1
Imagen zancada 2
- Relleno de ceros: un relleno es una operación de agregar un número correspondiente de filas y columnas en cada lado de los mapas de características de entrada. En este caso, la salida tiene la misma dimensión que la entrada.
- No linealidad (ReLU)
Al final de la operación de convolución, la salida está sujeta a una función de activación para permitir la no linealidad. La función de activación habitual de convnet es Relu. Todos los píxeles con valor negativo serán reemplazados por cero.
- Operación de agrupación máxima
Este paso es fácil de entender. El propósito de la agrupación es reducir la dimensionalidad de la imagen de entrada. Los pasos se realizan para reducir la complejidad computacional de la operación. Al disminuir la dimensionalidad, la red tiene menores pesos para calcular, por lo que evita el sobreajuste.
En esta etapa, debe definir el tamaño y la zancada. Una forma estándar de agrupar la imagen de entrada es utilizar el valor máximo del mapa de características. Mira la foto de abajo. La "agrupación" mostrará una submatriz de cuatro del mapa de características 4x4 y devolverá el valor máximo. La agrupación toma el valor máximo de una matriz de 2x2 y luego mueve esta ventana dos píxeles. Por ejemplo, la primera submatriz es [3,1,3,2], la agrupación devolverá el máximo, que es 3.
Hay otra operación de agrupación como la media.
Esta operación reduce agresivamente el tamaño del mapa de características
- Capas completamente conectadas
El último paso consiste en construir una red neuronal artificial tradicional como hiciste en el tutorial anterior. Conecta todas las neuronas de la capa anterior a la siguiente. Utiliza una función de activación softmax para clasificar el número en la imagen de entrada.
Resumen:
La red neuronal convolucional compila diferentes capas antes de hacer una predicción. Una red neuronal tiene:
- Una capa convolucional
- Función de activación Relu
- Capa de agrupación
- Capa densamente conectada
Las capas convolucionales aplican diferentes filtros en una subregión de la imagen. La función de activación de Relu agrega no linealidad y las capas de agrupación reducen la dimensionalidad de los mapas de características.
Todas estas capas extraen información esencial de las imágenes. Por último, el mapa de características se alimenta a una capa primaria completamente conectada con una función softmax para hacer una predicción.
Entrena CNN con TensorFlow
Ahora que está familiarizado con el componente básico de convnets, está listo para crear uno con TensorFlow. Usaremos el conjunto de datos MNIST para la clasificación de imágenes.
La preparación de datos es la misma que en el tutorial anterior. Puede ejecutar los códigos y saltar directamente a la arquitectura de la CNN.
Seguirás los pasos a continuación:
Paso 1: Cargar conjunto de datos
Paso 2: capa de entrada
Paso 3: capa convolucional
Paso 4: capa de agrupación
Paso 5: Segunda capa convolucional y capa de agrupación
Paso 6: capa densa
Paso 7: Capa Logit
Paso 1: Cargar conjunto de datos
El conjunto de datos MNIST está disponible con scikit para aprender en esta URL. Descárguelo y guárdelo en Descargas. Puede cargarlo con fetch_mldata ('MNIST original').
Crea un tren / conjunto de prueba
Debes dividir el conjunto de datos con train_test_split
Escale las características
Finalmente, puede escalar la función con MinMaxScaler
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_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 )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_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 usa filtros en el píxel sin procesar de una imagen para aprender los detalles del patrón en comparación con el patrón global con una red neuronal tradicional. Para construir una CNN, debe definir:
- Una capa convolucional: aplique n número de filtros al mapa de características. Después de la convolución, debe usar una función de activación de Relu para agregar no linealidad a la red.
- Capa de agrupación: el siguiente paso después de la convolución es reducir la resolución de la función máx. El propósito es reducir la dimensionalidad del mapa de características para evitar el sobreajuste y mejorar la velocidad de cálculo. La agrupación máxima es la técnica convencional, que divide los mapas de características en subregiones (generalmente con un tamaño de 2x2) y mantiene solo los valores máximos.
- Capas completamente conectadas: todas las neuronas de las capas anteriores están conectadas a las siguientes capas. La CNN clasificará la etiqueta de acuerdo con las características de las capas convolucionales y se reducirá con la capa de agrupación.
Arquitectura CNN
- Capa convolucional: aplica 14 filtros 5x5 (extrayendo subregiones de 5x5 píxeles), con función de activación ReLU
- Capa de agrupación: realiza una agrupación máxima con un filtro de 2x2 y un paso de 2 (que especifica que las regiones agrupadas no se superponen)
- Capa convolucional: aplica 36 filtros 5x5, con función de activación ReLU
- Capa de agrupación n. ° 2: de nuevo, realiza una agrupación máxima con un filtro de 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 dado se elimine durante el entrenamiento)
- Capa densa (Capa Logits): 10 neuronas, una para cada clase de destino de dígitos (0-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 agrupación bidimensional utilizando el algoritmo de agrupación máxima.
- 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 de construcción antes de envolver todo 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])
Necesitas definir un tensor con la forma de los datos. Para eso, puede usar el módulo tf.reshape. En este módulo, debe declarar el tensor para remodelar 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 con un tamaño de 28x28. Establecemos el tamaño del lote en -1 en el argumento de forma para que tome la forma de las características ["x"]. La ventaja es hacer que los hiperparámetros de tamaño de lote se ajusten. Si el tamaño del lote se establece en 7, el tensor alimentará 5488 valores (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = 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 5x5 con el mismo relleno. El mismo relleno significa que tanto el tensor de salida como el tensor de entrada deben tener la misma altura y ancho. Tensorflow agregará ceros a las filas y columnas para garantizar el mismo tamaño.
Utiliza la función de activación de Relu. El tamaño de salida será [28, 28, 14].
Paso 4: capa de agrupación
El siguiente paso después de la convolución es el cálculo de agrupación. El cálculo de la agrupación reducirá la dimensionalidad de los datos. Puede utilizar el módulo max_pooling2d con un tamaño de 2x2 y zancada de 2. Utiliza la capa anterior como entrada. El tamaño de salida será [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Paso 5: Segunda capa convolucional y capa de agrupación
La segunda capa convolucional tiene 32 filtros, con un tamaño de salida de [batch_size, 14, 14, 32]. La capa de agrupación tiene el mismo tamaño que antes y la forma de salida es [batch_size, 14, 14, 18].
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
Luego, debe definir la capa completamente conectada. El mapa de características debe aplanarse antes de conectarse con la capa densa. Puede utilizar la remodelación del módulo con un tamaño de 7 * 7 * 36.
La capa densa conectará 1764 neuronas. Agrega una función de activación de Relu. Además, agrega un término de regularización de abandono con una tasa de 0.3, lo que significa que 30 por ciento de los pesos se establecerán en 0. Tenga en cuenta que el abandono tiene lugar solo durante la fase de entrenamiento. La función cnn_model_fn tiene un modo de argumento para declarar si el modelo necesita ser entrenado o evaluado.
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, puede definir la última capa con la predicción del modelo. La forma de salida es igual al tamaño del lote y 10, el número total de imágenes.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Puede crear un diccionario que contenga las clases y la probabilidad de cada clase. El módulo tf.argmax () con devuelve el valor más alto si las capas 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 desea devolver la predicción del diccionario cuando el modo está configurado en predicción. Agrega estos códigos 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 último tutorial, aprendió 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 es optimizar el modelo, es decir, encontrar los mejores valores de los pesos. Para eso, usa un optimizador de descenso de gradiente con una tasa de aprendizaje de 0.001. El objetivo es minimizar la pérdida
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Terminaste con la CNN. Sin embargo, desea mostrar las métricas de rendimiento durante el modo de evaluación. Las métricas de rendimiento para un modelo multiclase son las métricas de precisión. Tensorflow está equipado con un módulo de precisión con 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. Creó su primera CNN y está 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 Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = 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 Layerpool2_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 Layerlogits = 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 Lossloss = 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 modeeval_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)
Los pasos siguientes son los mismos que los de los tutoriales anteriores.
En primer lugar, define un estimador con el modelo CNN.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
Una CNN tarda muchas veces en entrenarse, por lo tanto, crea un gancho de registro para almacenar los valores de las capas softmax cada 50 iteraciones.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Estás listo para estimar el modelo. Establece un tamaño de lote de 100 y mezcla los datos. Tenga en cuenta que establecemos pasos de entrenamiento de 16.000, puede llevar mucho tiempo entrenar. Se paciente.
# Train the modeltrain_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, puede evaluarlo e imprimir los resultados.
# Evaluate the model and print resultseval_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)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO: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, obtienes una precisión del 97%. Puede cambiar la arquitectura, el tamaño del lote y el número de iteraciones para mejorar la precisión. La red neuronal de CNN se ha desempeñado mucho mejor que ANN o la regresión logística. En el tutorial sobre redes neuronales artificiales, tuviste una precisión del 96%, que es menor que 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.
Resumen
Una red neuronal convolucional funciona muy bien para evaluar imágenes. Este tipo de arquitectura es dominante para reconocer objetos de una imagen o video.
Para crear una CNN, debe seguir seis pasos:
Paso 1: capa de entrada:
Este paso cambia la forma de los datos. La forma es igual a la raíz cuadrada del número de píxeles. Por ejemplo, si una imagen tiene 156 píxeles, entonces la forma es 26x26. Debe especificar si la imagen tiene color o no. Si es así, entonces tenía 3 en la forma, 3 para RGB, de lo contrario 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Paso 2: capa convolucional
A continuación, debe crear las capas convolucionales. Aplica diferentes filtros para permitir que la red aprenda características importantes. Usted especifica el tamaño del kernel y la cantidad de filtros.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Paso 3: capa de agrupación
En el tercer paso, agrega una capa de agrupación. Esta capa disminuye el tamaño de la entrada. Lo hace tomando el valor máximo de una submatriz. Por ejemplo, si la submatriz es [3,1,3,2], la agrupación devolverá el máximo, que es 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Paso 4: agregue la capa convolucional y la capa de agrupación
En este paso, puede agregar tantas capas de convivencia como desee y capas de agrupación. Google usa una arquitectura con más de 20 capas de conv.
Paso 5: capa densa
El paso 5 aplana el anterior para crear capas completamente conectadas. En este paso, puede usar una función de activación diferente y agregar un efecto de abandono.
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 6: Capa Logit
El paso final es la predicción.
logits = tf.layers.dense(inputs=dropout, units=10)