Aplicación de la red neuronal convolucional en el conjunto de datos mnist

CNN es básicamente un modelo conocido como Red Neural Convolucional y en los últimos tiempos ha ganado mucha popularidad debido a su utilidad. CNN utiliza perceptrones multicapa para realizar trabajos computacionales. CNN utiliza relativamente poco preprocesamiento en comparación con otros algoritmos de clasificación de imágenes. Esto significa que la red aprende a través de filtros que en los algoritmos tradicionales fueron diseñados a mano. Por lo tanto, para las tareas de procesamiento de imágenes, las CNN son la opción más adecuada.

Conjunto de datos MNIST: 
el conjunto de datos mnist es un conjunto de datos de imágenes escritas a mano como se muestra a continuación en la imagen.

Podemos obtener una precisión del 99,06 % mediante el uso de CNN (red neuronal convolucional) con un modelo funcional. La razón para usar un modelo funcional es mantener la facilidad al conectar las capas.
 

En primer lugar, incluya todas las bibliotecas necesarias
 

import numpy as np
import keras
from keras.datasets import mnist
from keras.models import Model
from keras.layers import Dense, Input
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten
from keras import backend as k

Crear los datos del tren y los datos de prueba

• Datos de prueba: se utilizan para probar el modelo de cómo se ha entrenado nuestro modelo. 
  Datos de entrenamiento: Usados ​​para entrenar nuestro modelo.
   

(x_train, y_train), (x_test, y_test) = mnist.load_data()

• Mientras continúa, img_rows e img_cols se utilizan como dimensiones de la imagen. En el conjunto de datos mnist, es 28 y 28. También debemos verificar el formato de datos, es decir, ‘channels_first’ o ‘channels_last’. En CNN, podemos normalizar los datos de antemano de modo que los términos grandes de los cálculos se puedan reducir a términos más pequeños. Por ejemplo, podemos normalizar los datos de x_train y x_test dividiéndolos por 255.
  Verificando el formato de datos: 
   

img_rows, img_cols=28, 28
 
if k.image_data_format() == 'channels_first':
   x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
   x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
   inpx = (1, img_rows, img_cols)
 
else:
   x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
   x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
   inpx = (img_rows, img_cols, 1)
 
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

Descripción de las clases de salida:

• Dado que la salida del modelo puede comprender cualquiera de los dígitos entre 0 y 9, necesitamos 10 clases en la salida. Para generar resultados para 10 clases, use la función keras.utils.to_categorical, que proporcionará las 10 columnas. De estas 10 columnas, solo un valor será uno y los 9 restantes serán cero y este valor de la salida denotará la clase del dígito.
   

y_train = keras.utils.to_categorical(y_train)
y_test = keras.utils.to_categorical(y_test)

• Ahora, el conjunto de datos está listo, así que avancemos hacia el modelo CNN: 
   

inpx = Input(shape=inpx)
layer1 = Conv2D(32, kernel_size=(3, 3), activation='relu')(inpx)
layer2 = Conv2D(64, (3, 3), activation='relu')(layer1)
layer3 = MaxPooling2D(pool_size=(3, 3))(layer2)
layer4 = Dropout(0.5)(layer3)
layer5 = Flatten()(layer4)
layer6 = Dense(250, activation='sigmoid')(layer5)
layer7 = Dense(10, activation='softmax')(layer6)

• Explicación del funcionamiento de cada capa en el modelo CNN:
  la capa 1 es la capa Conv2d que convoluciona la imagen usando 32 filtros cada uno de tamaño (3*3). 
  layer2 es nuevamente una capa Conv2D que también se usa para convolucionar la imagen y usa 64 filtros cada uno de tamaño (3 * 3). 
  layer3 es la capa MaxPooling2D que selecciona el valor máximo de una array de tamaño (3*3). 
  La capa 4 muestra abandono a una tasa de 0,5. 
  la capa5 está aplanando la salida obtenida de la capa4 y esta salida aplanada se pasa a la capa6. 
  layer6 es una capa oculta de una red neuronal que contiene 250 neuronas. 
  layer7 es la capa de salida que tiene 10 neuronas para 10 clases de salida que utiliza la función softmax.
• Llamando a la función de compilación y ajuste: 
   

model = Model([inpx], layer7)
model.compile(optimizer=keras.optimizers.Adadelta(),
              loss=keras.losses.categorical_crossentropy,
              metrics=['accuracy'])
 
model.fit(x_train, y_train, epochs=12, batch_size=500)

• En primer lugar, creamos un objeto del modelo como se muestra en las líneas anteriores, donde [inpx] es la entrada en el modelo y la capa 7 es la salida del modelo. Compilamos el modelo utilizando el optimizador requerido, la función de pérdida e imprimimos la precisión y en el último modelo. Se llamó al ajuste junto con parámetros como x_train (significa vectores de imagen), y_train (significa la etiqueta), número de épocas y el tamaño del lote . Usando la función de ajuste x_train, el conjunto de datos y_train se alimenta al modelo en un tamaño de lote particular.
• Función de evaluación: 
  model.evaluate proporciona la puntuación de los datos de prueba, es decir, proporcionó los datos de prueba al modelo. Ahora, el modelo predecirá la clase de los datos, y la clase predicha se comparará con la etiqueta y_test para darnos la precisión. 
   

score = model.evaluate(x_test, y_test, verbose=0)
print('loss=', score[0])
print('accuracy=', score[1])

• Producción: