Autocodificadores evolutivos para la reducción de ruido en imágenes

En «Anomaly Detection with Autoencoders Made Easy» mencioné que los autocodificadores se han aplicado ampliamente en la reducción de dimensiones y en la reducción de ruido en imágenes. Desde entonces muchos lectores me han preguntado si puedo cubrir el tema de la reducción de ruido en imágenes usando autocodificadores. Esa es la motivación de este post.

El modelado de datos de imágenes requiere un enfoque especial en el mundo de las redes neuronales. La red neuronal más conocida para modelar datos de imágenes es la Red Neural Convolucional (CNN, o ConvNet) o llamada Autoencoder Convolucional. En este post comenzaré con una suave introducción para los datos de imagen porque no todos los lectores están en el campo de los datos de imagen (por favor, siéntase libre de saltarse esa sección si ya está familiarizado). A continuación, describo una sencilla red neuronal estándar para los datos de imagen. Esto me dará la oportunidad de demostrar por qué los autocodificadores convolucionales son el método preferido para tratar los datos de imágenes. Sobre todo, demostraré cómo los Autoencoders Convolucionales reducen los ruidos en una imagen. En este post utilizo el módulo Keras y los datos de MNIST. El cuaderno está disponible en este enlace. Keras es una API de redes neuronales de alto nivel, escrita en Python y capaz de funcionar sobre TensorFlow. Este post es una extensión de mi anterior post «¿Qué es el reconocimiento de imágenes?» que os animo a echar un vistazo.

Pensé que es útil mencionar las tres grandes categorías de datos. Las tres categorías de datos son: (1) Datos no correlacionados (En contraste con los datos en serie), (2) Datos en serie (incluyendo datos de texto y de flujo de voz), y (3) Datos de imagen. El aprendizaje profundo tiene tres variantes básicas para abordar cada categoría de datos: (1) la red neuronal feedforward estándar, (2) RNN/LSTM, y (3) NN Convolucional (CNN). Para los lectores que busquen tutoriales para cada tipo, se recomienda consultar «Explaining Deep Learning in a Regression-Friendly Way» para (1), el artículo actual «A Technical Guide for RNN/LSTM/GRU on Stock Price Prediction» para (2), y «Deep Learning with PyTorch Is Not Torturing», «What Is Image Recognition?», «Anomaly Detection with Autoencoders Made Easy», y «Convolutional Autoencoders for Image Noise Reduction» para (3). Puede marcar el artículo resumen «Dataman Learning Paths – Build Your Skills, Drive Your Career».

Entender los datos de la imagen

Una imagen está hecha de «píxeles» como se muestra en la figura (A). En una imagen en blanco y negro cada píxel está representado por un número que va de 0 a 255. Hoy en día, la mayoría de las imágenes utilizan colores de 24 bits o más. Una imagen en color RGB significa que el color de un píxel es la combinación de rojo, verde y azul, cada uno de los cuales va de 0 a 255. El sistema de color RGB construye todos los colores a partir de la combinación de los colores Rojo, Verde y Azul como se muestra en este generador de color RGB. Así, un píxel contiene un conjunto de tres valores RGB(102, 255, 102) que se refiere al color #66ff66.

Una imagen de 800 píxeles de ancho, 600 píxeles de alto tiene 800 x 600 = 480.000 píxeles = 0,48 megapíxeles («megapíxel» es 1 millón de píxeles). Una imagen con una resolución de 1024×768 es una cuadrícula con 1.024 columnas y 768 filas, que por lo tanto contiene 1.024 × 768 = 0,78 megapíxeles.

MNIST

La base de datos MNIST (base de datos modificada del Instituto Nacional de Estándares y Tecnología) es una gran base de datos de dígitos escritos a mano que se utiliza habitualmente para entrenar varios sistemas de procesamiento de imágenes. El conjunto de datos de entrenamiento en Keras tiene 60.000 registros y el conjunto de datos de prueba tiene 10.000 registros. Cada registro tiene 28 x 28 píxeles.

¿Qué aspecto tienen? Utilicemos matplotlib y su función de imagen imshow() para mostrar los diez primeros registros.

Apila los datos de la imagen para el entrenamiento

Con el fin de ajustar un marco de red neuronal para el entrenamiento del modelo, podemos apilar todos los 28 x 28 = 784 valores en una columna. La columna apilada para el primer registro tiene el siguiente aspecto (utilizando x_train.reshape(1,784)):

Entonces podemos entrenar el modelo con una red neuronal estándar como se muestra en la Figura (B). Cada uno de los 784 valores es un nodo en la capa de entrada. Pero espera, ¿no perdemos mucha información al apilar los datos? Sí. Se han descartado las relaciones espaciales y temporales de una imagen. Esto supone una gran pérdida de información. Veamos cómo los autocodificadores convolucionales pueden retener la información espacial y temporal.

¿Por qué los autocodificadores convolucionales son adecuados para los datos de imagen?

Vemos una gran pérdida de información al cortar y apilar los datos. En lugar de apilar los datos, los autocodificadores convolucionales mantienen la información espacial de los datos de la imagen de entrada tal como son, y extraen la información suavemente en lo que se llama la capa de convolución. La figura (D) demuestra que una imagen 2D plana se extrae a un cuadrado grueso (Conv1), luego continúa para convertirse en un cúbico largo (Conv2) y otro cúbico más largo (Conv3). Este proceso está diseñado para conservar las relaciones espaciales en los datos. Este es el proceso de codificación en un autocodificador. En el medio, hay un autocodificador totalmente conectado cuya capa oculta está compuesta por sólo 10 neuronas. Después viene el proceso de decodificación que aplana los cúbicos, luego a una imagen plana 2D. El codificador y el decodificador son simétricos en la figura (D). No es necesario que sean simétricos, pero la mayoría de los profesionales se limitan a adoptar esta regla como se explica en «Anomaly Detection with Autoencoders made easy».

¿Cómo funcionan los autocodificadores convolucionales?

La extracción de datos anterior parece mágica. ¿Cómo funciona realmente? Implica las siguientes tres capas: La capa de convolución, la capa de reLu y la capa de pooling.

1. La capa de convolución

El paso de convolución crea muchas piezas pequeñas llamadas mapas de características o rasgos como los cuadrados verdes, rojos o azul marino de la figura (E). Estos cuadrados conservan la relación entre los píxeles de la imagen de entrada. Cada característica recorre la imagen original como se muestra en la figura (F). Este proceso en la producción de las puntuaciones se llama filtrado.

Después de escanear la imagen original, cada característica produce una imagen filtrada con puntuaciones altas y bajas, como se muestra en la figura (G). Si hay una coincidencia perfecta, hay una puntuación alta en esa casilla. Si hay una coincidencia baja o no hay coincidencia, la puntuación es baja o cero. Por ejemplo, el cuadrado rojo encontró cuatro áreas en la imagen original que muestran una coincidencia perfecta con la característica, por lo que las puntuaciones son altas para esas cuatro áreas.

Más filtros significan más número de características que el modelo puede extraer. Sin embargo, más características significan más tiempo de entrenamiento. Así que se aconseja utilizar el mínimo número de filtros para extraer las características.

1.1 Padding

¿Cómo determinan las características la coincidencia? Un hiperparámetro es Padding que ofrece dos opciones: (i) rellenar la imagen original con ceros para que encaje la característica, o (ii) eliminar la parte de la imagen original que no encaja y mantener la parte válida.

1.2 Strides

La capa de convolución incluye otro parámetro: el Stride. Es el número de píxeles que se desplazan sobre la matriz de entrada. Cuando el stride es 1, los filtros se desplazan 1 píxel cada vez. Lo veremos en nuestro código Keras como un hiperparámetro.

2. Paso ReLUs

La Unidad Lineal Rectificada (ReLU) es el paso que es el mismo que el de las típicas redes neuronales. Rectifica cualquier valor negativo a cero para garantizar que las matemáticas se comporten correctamente.

3. Max Pooling Layer

El pooling reduce el tamaño de la imagen. En la figura (H) una ventana de 2 x 2, llamada tamaño de pool, recorre cada una de las imágenes filtradas y asigna el valor máximo de esa ventana de 2 x 2 a un cuadrado de 1 x 1 en una nueva imagen. Como se ilustra en la figura (H), el valor máximo de la primera ventana de 2 x 2 es una puntuación alta (representada en rojo), por lo que la puntuación alta se asigna al cuadrado de 1 x 1.

Además de tomar el valor máximo, otros métodos de pooling menos comunes son el Average Pooling (tomar el valor medio) o el Sum Pooling (la suma).

Después del pooling, se produce una nueva pila de imágenes filtradas más pequeñas. Ahora dividimos las imágenes filtradas más pequeñas y las apilamos en una lista como se muestra en la Figura (J).

Modelo en Keras

Las tres capas anteriores son los bloques de construcción en la red neuronal de convolución. Keras ofrece las siguientes dos funciones:

Se pueden construir muchas capas de convolución en los autocodificadores de convolución. En la Figura (E) hay tres capas etiquetadas Conv1, Conv2 y Conv3 en la parte de codificación. Así que vamos a construir en consecuencia.

• El código de abajo input_img = Input(shape=(28,28,1) declara que la imagen 2D de entrada es de 28 por 28.
• Entonces construye las tres capas Conv1, Conv2 y Conv3.
• Nota que Conv1 está dentro de Conv2 y Conv2 está dentro de Conv3.
• El padding especifica qué hacer cuando el filtro no se ajusta bien a la imagen de entrada. padding='valid' significa dejar caer la parte de la imagen cuando el filtro no se ajusta; padding='same' rellena la imagen con ceros para que se ajuste a la imagen.

Luego continúa añadiendo el proceso de decodificación. Así que la parte decode de abajo tiene todo lo codificado y decodificado.

La api de Keras requiere la declaración del modelo y el método de optimización:

• Model(inputs= input_img,outputs= decoded): El modelo incluirá todas las capas necesarias en el cálculo de las salidas decoded dados los datos de entrada input_img. compile(optimizer='adadelta',loss='binary_crossentropy'): El optimizador realiza la optimización como lo hace el decente de gradiente. Los más comunes son el gradiente estocástico decente (SGD), el gradiente adaptado (Adagrad), y Adadelta que es una extensión de Adagrad. Consulte la documentación del optimizador Keras para conocer los detalles. Las funciones de pérdida se pueden encontrar en la documentación de pérdidas de Keras.

Abajo entreno el modelo usando x_train como entrada y salida. El batch_size es el número de muestras y el epoch es el número de iteraciones. Especifico shuffle=True para requerir barajar los datos de entrenamiento antes de cada época.

Podemos imprimir las diez primeras imágenes originales y las predicciones para las mismas diez imágenes.

¿Cómo construir un autoencoder de convolución de reducción de ruido de imagen?

La idea de la reducción de ruido de imagen es entrenar un modelo con datos ruidosos como las entradas, y sus respectivos datos claros las salidas. Esta es la única diferencia con el modelo anterior. Vamos a añadir primero ruidos a los datos.

Las primeras diez imágenes con ruido tienen el siguiente aspecto:

Entonces entrenamos el modelo con los datos ruidosos como entradas, y los datos limpios las salidas.

Por último, imprimimos las diez primeras imágenes con ruido y las correspondientes imágenes sin ruido.

El cuaderno está disponible a través de este enlace.

¿Hay algún código de CNNs preentrenadas que pueda utilizar?

Sí. Si estás interesado en aprender el código, Keras tiene varias CNNs pre-entrenadas incluyendo Xception, VGG16, VGG19, ResNet50, InceptionV3, InceptionResNetV2, MobileNet, DenseNet, NASNet, y MobileNetV2. Vale la pena mencionar esta gran base de datos de imágenes ImageNet a la que se puede contribuir o descargar con fines de investigación.