Blog
Reconocimiento de Dígitos (Números) Manuscritos
- Publicado por: Rafael Fernandez
- Categoría: Natural Language Processing
-En este proyecto descubrirás cómo desarrollar un modelo de deep learning para lograr una tarea de reconocimiento de dígitos escritos a mano en Python usando la biblioteca de aprendizaje profundo de Keras.
-Cómo cargar el conjunto de datos MNIST en Keras y desarrollar un modelo básico de red neuronal para el problema.
-Cómo implementar y evaluar una Red Neural Convolucional simple para MNIST.
-Cómo implementar un modelo de aprendizaje profundo cercano al estado del arte para el MNIST.
Una demostración popular de la capacidad de las técnicas de aprendizaje profundo es el reconocimiento de objetos en imágenes. El inicio del reconocimiento de objetos para el aprendizaje automático y el aprendizaje profundo es el conjunto de datos MNIST.
La base de datos MNIST (Base de datos del Instituto Nacional de Estándares y Tecnología) es una gran base de datos de dígitos manuscritos que se utiliza comúnmente para la capacitación de varios sistemas de procesamiento de imágenes y las pruebas en el campo del aprendizaje automático.
Conjunto de datos de Reconocimiento de Dígitos Escritos a Mano
MNIST
El MNIST es un conjunto de datos desarrollado por Yann LeCun, Corinna Cortes y Christopher Burges para la evaluación de modelos de aprendizaje de máquinas sobre el problema de la clasificación de los dígitos escritos a mano. La base de datos se construyó a partir de varios conjuntos de datos de documentos escaneados disponibles en la carpeta Instituto Nacional de Estándares y Tecnología (NIST).
Las imágenes de los dígitos fueron tomadas de una variedad de documentos escaneados, normalizados en tamaño y centrado. Esto lo convierte en un excelente conjunto de datos para evaluar modelos, permitiendo al desarrollador centrar el aprendizaje de la máquina con muy poca limpieza de datos. Cada imagen tiene 28 x 28 píxeles cuadrados (784 píxeles en total). Se utiliza una división estándar del conjunto de datos para evaluar y comparar modelos, en la que se utilizan 60.000 imágenes para formar un modelo y un conjunto separado de 10.000 imágenes para probarlo.
Es una tarea de reconocimiento de dígitos. Como tal, hay 10 dígitos (0 a 9) o 10 clases para predecir. Los resultados se informan utilizando el error de predicción. Excelentes resultados consiguen un error de predicción inferior al 1%. Una predicción de aproximadamente 0.2% se puede lograr con Redes Neuronales Convolucionales grandes.
Cargar el conjunto de datos MNIST en Keras
La biblioteca de aprendizaje profundo de Keras proporciona un método para cargar el conjunto de datos MNIST. El set de datos se descarga automáticamente la primera vez que se llama esta función y se almacena en su directorio home en ~/.keras/datasets/mnist.pkl.gz con una longitud de 15 megabytes. Esto es muy práctico para desarrollar y probar modelos de aprendizaje profundo. Para demostrar lo fácil que es cargar el conjunto de datos MNIST, primero escribiremos un pequeño script para descargar y visualizar las primeras 4 imágenes en el conjunto de datos de formación.
# ejemplo mnist from keras.datasets import mnist import matplotlib.pyplot as plt # cargar (descargar si es necesario) el conjunto de datos MNIST (X_train, y_train), (X_test, y_test) = mnist.load_data() # plot 4 imagenes en escala de grises plt.subplot(221) plt.imshow(X_train[8], cmap=plt.get_cmap('gray')) plt.subplot(222) plt.imshow(X_train[13], cmap=plt.get_cmap('gray')) plt.subplot(223) plt.imshow(X_train[22], cmap=plt.get_cmap('gray')) plt.subplot(224) plt.imshow(X_train[5], cmap=plt.get_cmap('gray')) # muestra el plot plt.show()
Puede ver que descargar y cargar el conjunto de datos MNIST es tan fácil como llamar a la función mnist.load_data(). Ejecutando el ejemplo de arriba, debería ver la imagen de abajo. En la siguiente imagen pueden ver un ejemplo de la base de datos de MNIST.
Modelo de línea base con Perceptrones Multicapa
¿Realmente necesitamos un modelo complejo como una red neuronal convolucional para obtener los mejores resultados con el MNIST? Usted puede obtener buenos resultados usando un modelo de red neural muy simple con un solo capa oculta. En esta sección crearemos un sencillo modelo de Perceptrón Multicapa que consigue un índice de error de aproximadamente el 1,73%. Usaremos esto como una línea de base para compararla con más modelos complejos de redes neurales convolucionales. Empecemos o importando las clases y funciones que necesitaremos.
import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.utils import np_utils
Siempre es una buena idea inicializar el generador de números aleatorios a una constante para asegurar que los resultados de su script sean reproducibles.
# generador de números aleatorios seed = 7 numpy.random.seed(seed)
Ahora podemos cargar el conjunto de datos MNIST usando la función de ayuda de Keras.
# cargamos los datos (X_train, y_train), (X_test, y_test) = mnist.load_data()
El conjunto de datos de formación está estructurado como una matriz tridimensional de instancia, ancho y alto de imagen. Para un modelo de Perceptrón Multicapa debemos reducir las imágenes a un vector de píxeles. En este caso, las 28 imágenes de tamaño 28 serán vectores de entrada de 784 píxeles. Podemos hacer esta transformación fácilmente usando la función reshape() en la matriz NumPy. Los valores de los píxeles son enteros, por lo que los fundimos en valores de coma flotante para que podamos normalizarlos fácilmente en el siguiente paso.
num_pixels = X_train.shape[1] * X_train.shape[2] X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32') X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
Los valores de los píxeles son en escala de grises entre 0 y 255. Casi siempre es una buena idea realizar alguna escalada de los valores de entrada cuando se utilizan modelos de redes neuronales. Debido a que la escala es bien conocida y se comporta bien, podemos rápidamente normalizar los valores de los píxeles en el rango 0 y 1 dividiendo cada valor por el máximo de 255.
# normalizamos las entradas desde 0-255 a 0-1 X_train = X_train / 255 X_test = X_test / 255
Finalmente, la variable de salida es un número entero de 0 a 9. Se trata de un problema de clasificación multiclase. Como tal, es una buena práctica utilizar una codificación en caliente de los valores de clase, transformando el vector de los enteros de clase en una matriz binaria. Podemos hacer esto fácilmente usando la función de ayuda incorporada np_utils.to_categorical() en Keras.
# una codificacion en caliente a la salida y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1]
Ahora estamos listos para crear nuestro simple modelo de red neuronal. Dibujaremos nuestro modelo en una función. Esto es útil si desea ampliar el ejemplo más tarde e intenta obtener una mejor puntuación.
# definismos la linea base del modelo def baseline_model(): # creamos el modelo model = Sequential() model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu')) model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax')) # Compilamos el modelo model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
El modelo es una red neural simple con una capa oculta con el mismo número de neuronas que hay entradas (784). Una función de activación de rectifier se utiliza para las neuronas en la capa oculta. Una función de activación softmax se utiliza en la capa de salida para convertir las salidas en valores similares a los de la probabilidad y permitir que una clase de las 10 sea seleccionada como predicción de salida del modelo. La pérdida logarítmica se utiliza como función de pérdida (llamada categorical_crossentropy en Keras) y el algoritmo de descenso de gradiente ADAM se utiliza para aprender a los pesos. A continuación se ofrece un resumen de la estructura de la red:
Capa visible (787 entradas) —> Capa oculta (784 neuronas) —> Capa de salida (10 salidas)
Ahora podemos evaluar el modelo. El modelo está ajustado a 10 épocas con actualizaciones cada 200 imágenes. Los datos de la prueba se utilizan como conjunto de datos de validación, lo que le permite ver la habilidad mientras entrena. Se utiliza un valor verbose de 2 para reducir la salida a una línea por cada época de entrenamiento. Finalmente, el conjunto de datos de prueba se utiliza para evaluar el modelo y una tasa de error de clasificación es impreso.
# construye el modelo model = baseline_model() # ajusta el modelo model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2) # Final evaluacion del model scores = model.evaluate(X_test, y_test, verbose=0) print("Error de linea base: %.2f%%" % (100-scores[1]*100))
La lista completa de códigos se proporciona a continuación para mayor información.
# linea base de MLP para MNIST dataset import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras.utils import np_utils # semilla de reproducibilidad seed = 7 numpy.random.seed(seed) # cargamos los datos (X_train, y_train), (X_test, y_test) = mnist.load_data() num_pixels = X_train.shape[1] * X_train.shape[2] X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32') X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32') # normaliza las entradas de 0-255 a 0-1 X_train = X_train / 255 X_test = X_test / 255 # codificacion en caliente a la salida y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1] # define la linea base del modelo def baseline_model(): # crea el modelo model = Sequential() model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu')) model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax')) # Compila el modelo model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model # Construir del modelo model = baseline_model() # Ajusta el modelo model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2) # Final evaluacion del modelo scores = model.evaluate(X_test, y_test, verbose=0) print("Baseline Error: %.2f%%" % (100-scores[1]*100))
La ejecución del ejemplo puede tardar unos minutos cuando se ejecuta en una CPU. Debería ver la salida a continuación. Esta sencilla red densificada en muy pocas líneas de código alcanza una tasa de error respetable del 1,91%.
Train on 60000 samples, validate on 10000 samples Epoch 1/10 - 6s - loss: 0.2782 - acc: 0.9210 - val_loss: 0.1412 - val_acc: 0.9574 Epoch 2/10 - 8s - loss: 0.1115 - acc: 0.9675 - val_loss: 0.0925 - val_acc: 0.9706 Epoch 3/10 - 11s - loss: 0.0718 - acc: 0.9799 - val_loss: 0.0780 - val_acc: 0.9773 Epoch 4/10 - 10s - loss: 0.0503 - acc: 0.9856 - val_loss: 0.0746 - val_acc: 0.9768 Epoch 5/10 - 8s - loss: 0.0374 - acc: 0.9893 - val_loss: 0.0671 - val_acc: 0.9790 Epoch 6/10 - 6s - loss: 0.0270 - acc: 0.9926 - val_loss: 0.0627 - val_acc: 0.9804 Epoch 7/10 - 7s - loss: 0.0210 - acc: 0.9948 - val_loss: 0.0626 - val_acc: 0.9811 Epoch 8/10 - 6s - loss: 0.0140 - acc: 0.9969 - val_loss: 0.0621 - val_acc: 0.9799 Epoch 9/10 - 7s - loss: 0.0108 - acc: 0.9978 - val_loss: 0.0590 - val_acc: 0.9805 Epoch 10/10 - 6s - loss: 0.0083 - acc: 0.9984 - val_loss: 0.0583 - val_acc: 0.9817 Baseline Error: 1.91%
Red Neural Convolucional Simple para MNIST
Ahora que hemos visto cómo cargar el conjunto de datos MNIST y entrenar un simple Perceptrón multicapa es hora de desarrollar una red neuronal convolucional más sofisticada o CNN. Keras proporciona mucha capacidad para crear redes neuronales convolucionales. En este crearemos una simple CNN para MNIST que demuestre cómo usar todos los aspectos de una implementación moderna de CNN, incluyendo Capas convolucionales, Capas de pooling y Abandono. El primer paso es importar las clases y funciones necesarias.
import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.convolutional import MaxPooling2D from keras.utils import np_utils from keras import backend as K K.set_image_dim_ordering('th')
Siempre es una buena idea inicializar el generador de números aleatorios a una constante para asegurar que los resultados de su script sean reproducibles.
# generador de números aleatorios seed = 7 numpy.random.seed(seed)
A continuación tenemos que cargar el conjunto de datos MNIST y remodelarlo para que sea adecuado para el entrenamiento de uso de una CNN. En Keras, las capas utilizadas para las convoluciones bidimensionales esperan valores de píxeles con las dimensiones [canales][ancho][alto]. En el caso de RGB, los canales de primera dimensión serían 3 para los componentes rojo, verde y azul y sería como tener 3 entradas de imagen para cada imagen en color. En el caso de MNIST donde los valores de los canales son en escala de grises, la dimensión del píxel se ajusta a 1.
# cargamos los datos (X_train, y_train), (X_test, y_test) = mnist.load_data() # remodelamos para [ejemplos][canales][ancho][alto] X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32') X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32')
Como antes, es una buena idea normalizar los valores de los píxeles al rango 0 y 1 y codificar en caliente la variable de salida.
# normalizamos las entradas de 0-255 a 0-1 X_train = X_train / 255 X_test = X_test / 255 # codificacion en calinete de la salida y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1]
A continuación, desentrañamos nuestro modelo de red neuronal. Las redes neuronales convolucionales son más complejas que los Perceptrones multicapa estándar, así que empezaremos usando una estructura simple para comenzar con todos los elementos para obtener resultados de última generación y alta precisión. A continuación se resume la arquitectura de la red por números:
- La primera capa oculta es una capa convolucional llamada Conv2D. La capa tiene 32 características con un tamaño de 5 x 5 y una función de activación de rectifier. Esta es la capa de entrada, esperando imágenes con el contorno de la estructura de arriba.
- A continuación se crea una capa de pooling que toma el valor máximo llamado MaxPooling2D. Es con un tamaño de piscina de 2 x 2.
- La siguiente capa es una capa de regularización que utiliza una exclusión llamada Dropout. Se configura al excluir aleatoriamente el 20% de las neuronas de la capa para reducir el sobreentrenamiento.
- Luego hay una capa que convierte los datos de la matriz 2D a un vector llamado Flatten. Permite que la salida sea procesada por capas estándar completamente conectadas.
- A continuación se utiliza una capa completamente conectada con 128 neuronas y la función de activación del rectifier.
- Finalmente, la capa de salida tiene 10 neuronas para las 10 clases y una función de activación softmax para producir predicciones probabilísticas para cada clase. Como antes, el modelo se entrena utilizando la pérdida logarítmica y el descenso por gradiente ADAM. A continuación se presenta una descripción de la estructura de la red.
CapaVisible (1x28x28 entradas) -> Capa convulocional (32 maps 5×5) -> Max Pooling capa (2×2) -> Dropout capa (20%) -> Flatten capa -> Capa oculta (128 nuronas) -> Capa de salida (10 salidas)
def baseline_model(): # crea el modelo model = Sequential() model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(num_classes, activation='softmax')) # Compila el modelo model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
Evaluamos el modelo de la misma manera que antes con el Perceptrón multicapa. La CNN tiene capacidad para más de 10 épocas con un tamaño de lote de 200.
# construye el modelo model = baseline_model() # Ajusta el modelo model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2) # Final evaluacion del modelo scores = model.evaluate(X_test, y_test, verbose=0) print("CNN Error: %.2f%%" % (100-scores[1]*100))
Aquí dejamos el codigo completo de
# Simple CNN para MNIST Dataset import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.convolutional import MaxPooling2D from keras.utils import np_utils # ajusta el orden from keras import backend as K K.set_image_dim_ordering('th') # semillas de reproducibilidad seed = 7 numpy.random.seed(seed) # cargamos los datos (X_train, y_train), (X_test, y_test) = mnist.load_data() # reformas para [ejemplo][canales][ancho][alto] X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32') X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32') # normaliza entradas de 0-255 a 0-1 X_train = X_train / 255 X_test = X_test / 255 # codificacion en caliente para las salidas y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1] # define el CNN model def baseline_model(): # crea el modelo model = Sequential() model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(num_classes, activation='softmax')) # Compile el modelo model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model # construimos el modelo model = baseline_model() # ajusta el modelo model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200) # Final evaluacion del modelo scores = model.evaluate(X_test, y_test, verbose=0) print("CNN Error: %.2f%%" % (100-scores[1]*100))
Al ejecutar el ejemplo, se imprime la precisión de la prueba de entrenamiento y validación en cada época y al final la tasa de errores de clasificación. Las épocas pueden tardar unos 45 segundos en ejecutarse en la GPU (por ejemplo, en AWS). Usted puede ver que la red alcanza una tasa de error de 1.01, lo cual es mejor que nuestro modelo simple de Perceptrón Multicapa anterior.
Train on 60000 samples, validate on 10000 samples Epoch 1/10 60000/60000 [==============================] - 77s 1ms/step - loss: 0.2314 - acc: 0.9344 - val_loss: 0.0820 - val_acc: 0.9739 Epoch 2/10 60000/60000 [==============================] - 89s 1ms/step - loss: 0.0734 - acc: 0.9781 - val_loss: 0.0468 - val_acc: 0.9840 Epoch 3/10 60000/60000 [==============================] - 90s 1ms/step - loss: 0.0528 - acc: 0.9840 - val_loss: 0.0428 - val_acc: 0.9856 Epoch 4/10 60000/60000 [==============================] - 78s 1ms/step - loss: 0.0400 - acc: 0.9878 - val_loss: 0.0405 - val_acc: 0.9862 Epoch 5/10 60000/60000 [==============================] - 79s 1ms/step - loss: 0.0334 - acc: 0.9895 - val_loss: 0.0347 - val_acc: 0.9881 Epoch 6/10 60000/60000 [==============================] - 80s 1ms/step - loss: 0.0274 - acc: 0.9913 - val_loss: 0.0310 - val_acc: 0.9893 Epoch 7/10 60000/60000 [==============================] - 80s 1ms/step - loss: 0.0231 - acc: 0.9927 - val_loss: 0.0359 - val_acc: 0.9883 Epoch 8/10 60000/60000 [==============================] - 80s 1ms/step - loss: 0.0199 - acc: 0.9938 - val_loss: 0.0326 - val_acc: 0.9887 Epoch 9/10 60000/60000 [==============================] - 93s 2ms/step - loss: 0.0167 - acc: 0.9946 - val_loss: 0.0299 - val_acc: 0.9898 Epoch 10/10 60000/60000 [==============================] - 107s 2ms/step - loss: 0.0140 - acc: 0.9960 - val_loss: 0.0307 - val_acc: 0.9899 CNN Error: 1.01%
Red Neural Convolucional Más Grande para MNIST
Ahora que hemos visto cómo crear una simple CNN, echemos un vistazo a un modelo capaz de acercarse a los resultados más avanzados. Importamos las clases y funciones y luego cargamos y preparamos los datos de la misma manera que en el ejemplo anterior de CNN. Esta vez hemos creado una arquitectura CNN más grande con capas convolucionales adicionales, capas máximas de pooling y capas completamente conectadas. La topología de la red puede resumirse de la siguiente manera.
1. Capa convolucional con 30 mapas de características del tamaño 5 x 5
2. Capa de pooling con un máximo de 2 x 2 parches.
3. Capa convolucional con 15 mapas de características del tamaño 3 x 3
4. Capa de pooling con un máximo de 2 x 2 parches.
5. Capa de abandono (dropour) con una probabilidad del 20%.
6. Flatten la capa.
7. Capa totalmente conectada con 128 neuronas y activación de rectifier.
8. Capa totalmente conectada con 50 neuronas y activación de rectifier.
9. Capa de salida.
Al igual que los dos experimentos anteriores, el modelo tiene más de 10 épocas con un tamaño de lote de 200.
# CNN mas grande para MNIST Dataset import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.convolutional import MaxPooling2D from keras.utils import np_utils from keras import backend as K K.set_image_dim_ordering('th') # semilla random de reporducibilidad seed = 7 numpy.random.seed(seed) # cargamos los datos (X_train, y_train), (X_test, y_test) = mnist.load_data() # reforma para [samples][pixels][width][height] X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32') X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32') # normalizamos los inputs para 0-255 a 0-1 X_train = X_train / 255 X_test = X_test / 255 # codificación en caliente para la salida y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1] # define un modelo mas grande def larger_model(): # crea el modelo model = Sequential() model.add(Conv2D(30, (5, 5), input_shape=(1, 28, 28), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(15, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(50, activation='relu')) model.add(Dense(num_classes, activation='softmax')) # Compila el modelo model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model # construye el modelo model = larger_model() # Ajusta el modelo model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200) # Final evaluaciondel modelo scores = model.evaluate(X_test, y_test, verbose=0) print("Large CNN Error: %.2f%%" % (100-scores[1]*100))
Al ejecutar el ejemplo se imprime la precisión en los conjuntos de datos de formación y validación de cada época y una tasa de error de clasificación. El modelo tarda unos 55 segundos en ejecutarse por época en una CPU moderna. Este modelo ligeramente más grande alcanza la respetable tasa de error de clasificación del 0,70%.
Train on 60000 samples, validate on 10000 samples Epoch 1/10 60000/60000 [==============================] - 81s 1ms/step - loss: 0.3996 - acc: 0.8770 - val_loss: 0.0993 - val_acc: 0.9680 Epoch 2/10 60000/60000 [==============================] - 82s 1ms/step - loss: 0.0970 - acc: 0.9701 - val_loss: 0.0538 - val_acc: 0.9825 Epoch 3/10 60000/60000 [==============================] - 84s 1ms/step - loss: 0.0687 - acc: 0.9787 - val_loss: 0.0348 - val_acc: 0.9893 Epoch 4/10 60000/60000 [==============================] - 82s 1ms/step - loss: 0.0554 - acc: 0.9826 - val_loss: 0.0297 - val_acc: 0.9897 Epoch 5/10 60000/60000 [==============================] - 83s 1ms/step - loss: 0.0476 - acc: 0.9854 - val_loss: 0.0278 - val_acc: 0.9909 Epoch 6/10 60000/60000 [==============================] - 90s 1ms/step - loss: 0.0431 - acc: 0.9862 - val_loss: 0.0269 - val_acc: 0.9910 Epoch 7/10 60000/60000 [==============================] - 86s 1ms/step - loss: 0.0380 - acc: 0.9879 - val_loss: 0.0260 - val_acc: 0.9913 Epoch 8/10 60000/60000 [==============================] - 81s 1ms/step - loss: 0.0344 - acc: 0.9889 - val_loss: 0.0233 - val_acc: 0.9917 Epoch 9/10 60000/60000 [==============================] - 82s 1ms/step - loss: 0.0321 - acc: 0.9896 - val_loss: 0.0208 - val_acc: 0.9938 Epoch 10/10 60000/60000 [==============================] - 81s 1ms/step - loss: 0.0283 - acc: 0.9907 - val_loss: 0.0231 - val_acc: 0.9930 Large CNN Error: 0.70%
➡ Sigue aprendiendo de Deep Learning en nuestro curso:
Hola, solo para preguntar un un detalle, si quisiera usar mis imágenes propias, ¿como puedo hacer para acoplarlas en ves de la base de datos usada en el ejemplo?
Hola guadalupe, siguiendo el curso deberias poder hacer lo que me preguntas, gracias por comentar y un saludo!
Hola Rafael,
todo iba muy bien pero al ejecutar el primer ejemplo de la red Convolucional, aparece el siguiente error:
raise ValueError(str(e))
ValueError: Negative dimension size caused by subtracting 5 from 1 for ‘conv2d_1/convolution’ (op: ‘Conv2D’) with input shapes: [?,1,28,28], [5,5,28,32].
Estaré atento a su respuesta.
Un saludo
Luciano
Rafael, aparece el mismo error en el ejemplo 2 de la CNN
raise ValueError(str(e))
ValueError: Negative dimension size caused by subtracting 5 from 1 for ‘conv2d_5/convolution’ (op: ‘Conv2D’) with input shapes: [?,1,28,28], [5,5,28,30].
Estaré atento a su respuesta.
Un saludo
Luciano
Rafael,
Se corrigió el error con lo siguiente:
model.add(Conv2D(30, (5, 5), activation=’relu’, input_shape=(1,28,28), data_format=’channels_first’))
Todavía no sé qué es data_format=’channels_first’
Un saludo
Luciano