Clasificación de imágenes de CNN en TensorFlow con pasos y ejemplos
evelyn clarke
¿Qué es una red neuronal convolucional?
Red neuronal convolucional, también conocidas como convnets o CNN, 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 dominante para reconocer objetos a partir de una imagen o un vídeo. Se utiliza en aplicaciones como el reconocimiento de imágenes o vídeos, el procesamiento neuronal del lenguaje, etc.
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 envía una imagen a la red, llamada imagen de entrada. Luego, la imagen de entrada pasa por una cantidad infinita de pasos, que 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 un solo canal, mientras que una imagen en color tiene tres canales (cada uno para Rojo, Verde y Azul). Un canal está apilado uno encima del 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 formato matricial. Tenga en cuenta que la matriz original se ha estandarizado para que esté entre 0 y 1. Para 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 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 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 extraer solo 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 partes pequeñas para aprender los elementos más esenciales dentro de cada parte.
Componentes de la red neuronal convolucional (ConvNet o CNN)
Hay cuatro componentes de un Convnets
- Circunvolución
- No linealidad (ReLU)
- Pooling o submuestreo
- Clasificación (capa totalmente conectada)
Circunvolución
El propósito de la convolución es extraer localmente las características del objeto en la imagen. 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 elemento por elemento. 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á por un filtro. El resultado de la multiplicación elemento por elemento se denomina mapa de características. Este paso se repite hasta que se escanea toda la imagen. Observe que, después de la convolución, el tamaño de la imagen se reduce.
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. Puedes 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.
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 moverá 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 por toda la imagen de entrada y calculará la convolución. La imagen a continuación muestra cómo funciona la convolución. El tamaño del parche es 3×3 y la matriz de salida es el resultado de la operación elemento por 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. Sólo hay una ventana en el centro donde el filtro puede filtrar una cuadrícula de 3×3. El mapa de características de salida se reducirá en dos mosaicos junto con una dimensión de 3×3.
Para obtener la misma dimensión de salida que la dimensión de entrada, debe agregar relleno. El relleno consiste en sumar el número correcto de filas y columnas a 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 5×5
Cuando define la red, las funciones convolucionadas se controlan mediante tres parámetros:
- PROFUNDO: Define la cantidad de filtros que se aplicarán durante la convolución. En el ejemplo anterior, se vio una profundidad de 1, lo que significa que solo se utiliza 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.
- Paso: Define la cantidad de “saltos de píxeles” entre dos cortes. Si el paso es igual a 1, las ventanas se moverán con una separación de píxeles de uno. Si el paso es igual a dos, las ventanas saltarán 2 píxeles. Si aumenta el paso, tendrá mapas de características más pequeños.
Ejemplo de zancada 1
paso 2
- cero-relleno:El relleno es una operación que consiste en sumar una cantidad correspondiente de filas y columnas a 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 se somete a una función de activación para permitir la no linealidad. La función de activación habitual para convnet es Relu. Todos los píxeles con un valor negativo se reemplazarán por cero.
Pooling Operadesarrollo
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 pesos más bajos para calcular, por lo que evita el sobreajuste.
En esta etapa, debe 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. Observe la imagen a continuación. La “agrupación” filtrará una submatriz de cuatro del mapa de características de 4 × 4 y devolverá el valor máximo. La agrupación 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], la agrupación devolverá el máximo, que es 3.
Existe otra operación de agrupación como es la media.
Esta operación reduce agresivamente 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:
La red neuronal convolucional 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 distintos filtros a una subregión de la imagen. La función de activación Relu añade no linealidad y las capas de agrupamiento 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 envía 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 un convnets, está listo para construir uno 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:
Paso 1: cargar el conjunto de datos
Paso 2: capa de entrada
Paso 3: capa convolucional
Paso 4: Poolincapa g
Paso 5: Segunda capa convolucional y Pooling Capa
Paso 6: capa densa
Paso 7: Capa Logit
Paso 1: cargar el conjunto de datos
El conjunto de datos MNIST está disponible con scikit para aprender en este URL. Descárguelo y guárdelo en Descargas. Puedes subirlo con fetch_mldata('MNIST original').
Crear un conjunto de tren/prueba
Necesitas dividir el conjunto de datos con train_test_split
Escalar las características
Finalmente, puede escalar la función con MinMaxScaler como se muestra en la clasificación de imágenes a continuación usando el ejemplo de TensorFlow CNN.
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 el píxel original de una imagen para aprender detalles del patrón y compararlo con el patrón global de una red neuronal tradicional. Para construir una CNN, es necesario definir:
- Una capa convolucional: aplique n número de filtros al mapa de características. Después de la convolución, debe utilizar una función de activación de Relu para agregar no linealidad a la red.
- PoolinCapa g: el siguiente paso después de la convolución es reducir la resolución del mapa de características máximo. El objetivo 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 (normalmente con un tamaño de 2×2) y conserva solo los valores máximos.
- 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 (extrayendo subregiones 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 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])
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 monocrónica con un tamaño de 28 × 28. Establecemos el tamaño del lote en -1 en el argumento de forma para que adopte la forma de las características [“x”]. La ventaja es ajustar los hiperparámetros del tamaño del lote. Si el tamaño del lote se establece en 7, entonces el tensor alimentará 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 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: Poolincapa g
El siguiente paso después de la convolución es el cálculo de agrupación. El cálculo de agrupación reducirá la dimensionalidad de los datos. Puede utilizar el módulo max_pooling2d con un tamaño de 2×2 y un paso de 2. Utilice 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 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, necesitas 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 el 30 por ciento de los pesos se establecerán en 0. Tenga en cuenta que el abandono se produce sólo 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 como se muestra en el siguiente ejemplo de TensorFlow de clasificación de imágenes de CNN.
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, puedes 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 Layer logits = tf.layers.dense(inputs=dropout, units=10)
Puedes crear un diccionario que contenga las clases y la probabilidad de cada clase. El módulo tf.argmax() 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, 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 TensorFlow CNN es optimizar el modelo, es decir, encontrar los mejores valores de los pesos. Para eso, utiliza 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())
Ya 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 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)
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")
Una CNN requiere muchas veces entrenarse, por lo tanto, crea un gancho 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)
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 XNUMX; el entrenamiento puede llevar mucho tiempo. Ser 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)
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, se obtiene una precisión del 97 %. Se puede cambiar la arquitectura, el tamaño del lote y el número de iteraciones para mejorar la precisión. La red neuronal CNN ha tenido un rendimiento mucho mejor que la ANN o la regresión logística. En el tutorial sobre redes neuronales artificiales, se obtuvo una precisión del 96 %, que es inferior a la de la CNN. El rendimiento de la CNN es impresionante con una imagen 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 la predominante para reconocer objetos a partir de una imagen o un vídeo.
Para crear una CNN de TensorFlow, debe seguir siete pasos:
Paso 1: Cargar conjunto de datos:
El conjunto de datos MNIST está disponible con scikit para aprender. Descárguelo y guárdelo en Descargas. Puedes subirlo con fetch_mldata('MNIST original').
Paso 2: 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 26×26. Debe especificar si la imagen tiene color o no. Si es así, entonces tiene 3 para la forma (3 para RGB) y 1 en caso contrario.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Paso 3: 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 4: Poolincapa g
En el tercer paso, se agrega una capa de agrupación. Esta capa disminuye el tamaño de la entrada. Para ello, toma el valor máximo de una submatriz. Por ejemplo, si la submatriz es [3,1,3,2], la agrupación devolverá el valor máximo, que es 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Paso 5: Agregar capa convolucional y Pooling Capa
En este paso, puedes agregar tantas capas de convolución y capas de agrupación como quieras. Google utiliza una arquitectura con más de 20 capas de convolución.
Paso 6: Capa densa
El paso 6 aplana el anterior para crear capas completamente conectadas. En este paso, puede utilizar diferentes funciones de activación 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 7: Capa Logit
El último paso es la predicción.
logits = tf.layers.dense(inputs=dropout, units=10)
