Reconocimiento de escritura con Keras: Perceptrón Vs CNN.

Keras es una interfaz de trabajo para la rápida generación de prototipos usando Redes Neuronales Artificiales, que se engloba dentro de las técnicas de Inteligencia Artificial como aprendizaje profundo o Deep Learning.

Uno de sus puntos fuertes es que corre sobre algunas de las librerías más utilizadas en este campo, como TensorFlow, Theano o CNTK, proporcionando una capa de abstracción extra que simplifica su uso.

Además, otra ventaja es que esta interfaz está completamente escrita con Python en código abierto. Su facilidad de implementación, así como su completísima documentación, la están posicionando como una de las herramientas de más rápido crecimiento dentro del ecosistema Deep Learning.

Para demostrar su potencial nos vamos a apoyar en dos de los fantásticos ejemplos que nos proporciona Keras en su documentación. Ambos entrenan una red neuronal para reconocer dígitos manuscritos del 0 al 9 presentes en el archiconocido dataset MNIST en dos versiones: un perceptrón multicapa y una Red Neuronal Convolucional.

Vamos a ver cómo se comportan nuestras redes, ya entrenadas, de una forma gráfica. Debajo puedes introducir un carácter del 0 al 9 con el ratón, y al pulsar el botón veremos si las AI lo han logrado identificar.

Perceptrón Multicapa

Esta forma de RNA es la más sencilla y se compone de una capa de entrada, una de salida, y una o varias capas ocultas completamente conectadas entre sí. Esto significa que a cada neurona de una capa le llega señal de todos los nodos de la capa anterior.

La información se va propagando por las capas hasta producir una salida que es un vector con tantas posiciones como las clases de las que constan nuestros datos. En este caso 10 (dígitos 0-9).

Implementación de un perceptrón en Keras

Veamos ahora cómo podemos crear esta RNA apoyándonos en el código del ejemplo de la documentación oficial.

model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))

Lo primero es instanciar el sistema con la llamada a Sequential(), que crea una red neuronal vacía a la que habrá que agregar las capas correspondientes con la instrucción model.add().

La primera capa es de tipo “Dense”, es decir, completamente conectada con una dimensionalidad de salida de 512, función de activación ReLu y recibe una entrada unidimensional de longitud 784. Esto se debe a que las imágenes del dataset tienen 28x28 píxeles, es decir, 784 valores en total.

A continuación se añade una capa Dropout con parámetro 0.2. Esto se conoce como regularización y su función es prevenir el sobreajuste otorgando a cada neurona una probabilidad del 20% de no activarse durante la fase de entrenamiento. No influye en la topología de nuestra RNA.

Seguidamente agregamos una segunda capa Dense con dimensión de salida 512. No es necesario especificar el tamaño de la entrada en ninguna capa salvo en la primera, ya que Keras puede inferirlo del diseño. Luego, otra capa Dropout con igual función que la anterior y finalmente una capa de salida con 10 posibles valores (0-9) y activación softmax.

Así de fácil hemos definido nuestra topología. Vamos a completar el diseño de la red con algunos parámetros más:

model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

Mediante la llamada a compile le proporcionamos al sistema la función de pérdidas que queremos minimizar durante el entrenamiento, el tipo de algoritmo que usaremos para hacerlo y las métricas que nos gustaría conocer. En un problema de clasificación como el de este ejemplo, siempre querremos ver la medida de precisión (accuracy) de nuestro modelo.

Con esto, ya podemos entrenar nuestra RNA con los datos del MNIST y comprobar nuestra precisión.

Red Neuronal Convolucional

Este tipo de topologías son comunes en el reconocimiento de imágenes y, a diferencia de las anteriores, implementan una operación de convolución entre la imagen y un kernel de un tamaño dado por el usuario.

Esta operación se puede interpretar como la aplicación de filtros de diversos tipos sobre la imagen, que implementan operaciones como por ejemplo la detección de bordes.

En resumen, lo que se propaga por la red no es el valor de cada píxel, como en el caso anterior, sino información relativa a las características morfológicas de la imagen.

Implementación de una RNC en Keras

Veamos ahora cómo se implementa esta topología, también siguiendo el ejemplo provisto en la documentación de Keras:

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu',         input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))

model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])

Observamos ciertas similitudes con el anterior, como por ejemplo la llamada a Sequential() para crear nuestra red, y la adición de capas:

• Conv2D: tal como hemos mencionado antes, implementa la convolución en dos dimensiones de la imagen de entrada con un kernel de 3x3. Esta operación se realiza 32 veces en la primera capa, dando lugar a una salida de 32 imágenes “filtradas” diferentes.
• MaxPooling2D: reduce el tamaño de las imágenes que circulan por la red, tomando para cada 4 píxeles el mayor de todos ellos. Esta operación mejora el rendimiento y afecta poco a la precisión.
• Dropout: capas de regularización.
• Flatten: cambia la forma del input a un vector unidimensional.
• Dense: capas completamente conectadas con activación ReLU.

La última capa Dense es la capa de salida que tiene, como siempre, tantas posibles salidas como número de clases de nuestro problema, en este caso 10.

Esta es una de muchas posibles topologías que se pueden generar para atajar este problema, pero no hay una solución única.

De nuevo estamos listos para entrenar y probar nuestro modelo, tal como se hace en el ejemplo.

Conclusiones

Keras es un framework pensado para poder generar prototipos rápidos de nuestros problemas de deep learning, y así hemos visto lo fácil que es implementar nuestros sistemas de clasificación de dígitos manuscritos con Keras. Y esto es sólo un ejemplo sencillo: ¡las posibilidades son infinitas!

Ni que decir tiene que los sistemas profesionales son mucho más complejos y precisos que nuestro ejemplo, pero esperamos que os haya dado una idea básica de cómo funcionan los sistemas de reconocimiento de texto manuscrito y de cómo empezar a prototipar con Keras.