Convoluciones y visión

La operación

Dada una imagen $I$ y un kernel $K$ de tamaño $k\times k$, la salida (sin relleno) en la posición $(i,j)$ es

Técnicamente esto es una correlación cruzada; la convolución matemática voltea el kernel, pero en deep learning el kernel se aprende y la distinción no importa (Goodfellow et al., 2016, cap. 9). Con una imagen de $n\times n$, sin relleno ($p=0$) y zancada 1, la salida mide $n-k+1$ por lado; con zancada (stride) $s$ y relleno $p$ (filas y columnas de ceros alrededor): $\lfloor (n+2p-k)/s \rfloor + 1$ (Dumoulin y Visin, 2016). Ejemplo del quiz: $28\times28$ con $k=3$ da $26\times26$; con $p=1$ el tamaño se conserva en $28\times28$.

Parámetros: conectado frente a convolucional

Una capa totalmente conectada de $10^4$ entradas a $10^3$ neuronas tiene $10^7$ pesos (más sesgos). Una capa convolucional con $C_{out}$ kernels de $k\times k$ sobre $C_{in}$ canales tiene

parámetros, independientes del tamaño de la imagen. Con $C_{in}=1$, $k=3$ y 16 kernels: $16\cdot(9+1)=160$.

La comparación del gancho (10 millones frente a 10) pone un solo kernel frente a mil neuronas, y un kernel produce un solo mapa. Con 1 000 kernels de $3\times3$ sobre la misma imagen de $100\times100$ (sin relleno) hay $1\,000\cdot(9+1)=10\,000$ parámetros, mil veces menos que $10^7$; pero la salida son 1 000 mapas de $98\times98$ (9 604 000 valores) y $98^2\cdot 9\cdot 1\,000\approx 86$ millones de multiplicaciones, más que las 10 millones de la capa densa. Compartir pesos ahorra parámetros (y datos para ajustarlos), no operaciones: no cambia el orden del tiempo de cómputo de la pasada hacia delante, solo la memoria de los parámetros (Goodfellow et al., 2016, §9.2).

De dónde viene la idea

El neocognitrón de Fukushima (1980) ya combinaba capas de detectores de rasgos locales con capas tolerantes a desplazamientos, pero se entrenaba con una regla autoorganizada, sin supervisión: no tenía un algoritmo supervisado de extremo a extremo como la retropropagación (LeCun, Bengio y Hinton, 2015; Goodfellow et al., 2016, §9.10). LeCun et al. (1989) entrenaron con retropropagación una red con pesos compartidos para reconocer dígitos de códigos postales manuscritos que les dio el Servicio Postal de EE. UU.: 9 298 dígitos ya segmentados (7 291 para entrenar, 2 007 para probar) en imágenes de $16\times16$. Sus 64 660 conexiones se controlaban con 9 760 parámetros independientes, y el error fue 0.14 % en entrenamiento (10 errores) y 5.0 % en prueba (102 errores); una red totalmente conectada con 40 neuronas ocultas, probada como comparación, llegó a 8.1 % en prueba. Esa red no usaba pooling, sino convoluciones que saltaban de dos en dos píxeles. LeNet-5 (LeCun et al., 1998) tiene 7 capas, entrada de $32\times32$, kernels de $5\times5$, 340 908 conexiones y unos 60 000 parámetros libres; su «submuestreo» promedia cada bloque de $2\times2$ (con un coeficiente y un sesgo entrenables) en lugar de tomar el máximo.

El kernel de la lección

Los kernels de bordes de la escena son los del operador de Sobel (documentación de OpenCV, «Sobel Derivatives»). El de bordes verticales es

Su magnitud $\sqrt{(K_x * I)^2 + (K_y * I)^2}$ estima la intensidad de los bordes (la misma fuente). Aquí los kernels se eligen a mano para ver la operación; en una red entrenada los aprende el entrenamiento, y en las primeras capas suelen parecerse a detectores de bordes orientados y de manchas de color (Krizhevsky et al., 2012, fig. 3; Yosinski et al., 2014).

Campo receptivo y jerarquía

Cada capa ve una zona mayor de la imagen original. Con $r_L=1$ en la última capa, el campo receptivo cumple $r_{l-1}=s_l\,r_l+(k_l-s_l)$ (Araujo, Norris y Sim, 2019): dos convoluciones de $3\times3$ seguidas «ven» $5\times5$; con un pooling de $2\times2$ en medio ($3\times3$, pooling, $3\times3$) ven $8\times8$, y una unidad de la red de ejemplo de la escena, tras sus dos pooling, ve $10\times10$ píxeles. Por eso las primeras capas detectan patrones locales (bordes, colores) y las profundas, combinaciones amplias.

En una red de tipo AlexNet, Zeiler y Fergus (2014) visualizaron qué excita a cada capa: la 2 responde a esquinas y combinaciones de borde y color; la 3, a texturas y patrones más complejos; la 4, a partes propias de una clase (caras de perro); la 5, a objetos enteros con mucha variación de pose. LeCun, Bengio y Hinton (2015) lo resumen como bordes, motivos, partes y objetos, y subrayan que esas capas de rasgos no las diseñan ingenieros: se aprenden de los datos. Lo que sí diseña una persona es la arquitectura (cuántas capas, qué tamaño de kernel, dónde va el pooling).

Pooling y desplazamientos

El pooling máximo de $2\times2$ con paso 2 reduce el mapa a la mitad por lado y vuelve la salida aproximadamente invariante a desplazamientos pequeños (Goodfellow et al., 2016, §9.3; LeCun, Bengio y Hinton, 2015). Es solo aproximado: en la escena, desplazar la imagen un píxel cambia un 56 % el mapa de bordes (suma de diferencias absolutas entre suma de valores absolutos) y tras el pooling un 19 %; con 400 imágenes de franjas al azar, el cambio medio baja de 0.97 a 0.50 y en 50 de las 400 el pooling no lo reduce (script verify-data.ts). Azulay y Weiss (2019) muestran que en redes completas desplazar o escalar un poco la imagen puede cambiar mucho la predicción. En la escena el pooling toma el máximo del valor absoluto; en una red real la activación (por ejemplo ReLU) va antes.

Los límites, con números

• Texturas. Geirhos et al. (2019) mostraron a redes entrenadas con ImageNet imágenes con la forma de un objeto y la textura de otro. Al elegir, ResNet-50 respondió según la textura el 77.9 % de las veces (VGG-16, 82.8 %; GoogLeNet, 68.8 %; AlexNet, 57.1 %); las personas eligieron la forma en el 95.9 % de sus decisiones correctas. Con la misma arquitectura, entrenar con una versión «estilizada» de ImageNet cambió ese sesgo: depende de los datos y de la tarea, no solo de la convolución.
• Cambios casi invisibles. Szegedy et al. (2014) hallaron perturbaciones apenas perceptibles que cambian la clase que predice la red. Goodfellow, Shlens y Szegedy (2015) pasaron la respuesta de GoogLeNet ante la foto de un panda de «panda» (57.7 % de confianza) a «gibón» (99.3 %) sumando una perturbación de magnitud 0.007, el bit más pequeño de una imagen de 8 bits.
• Datos distintos de los de entrenamiento. Recht et al. (2019) rehicieron con el mismo procedimiento los conjuntos de prueba de ImageNet y la exactitud de los modelos bajó entre 11 % y 14 %. Beery et al. (2018): con cámaras trampa de fauna, buen rendimiento donde se entrenó y mala generalización a lugares nuevos. Hendrycks y Dietterich (2019): ImageNet-C aplica 75 alteraciones (15 tipos en 5 intensidades, entre ellas brillo, contraste, niebla y ruido), y la robustez relativa casi no mejoró de AlexNet a ResNet.
• Escenas. Goodfellow et al. (2016, §9.10) señalan que el sistema visual humano hace mucho más que reconocer objetos (entiende escenas completas, relaciones entre objetos y geometría 3D) y que las aplicaciones de las redes convolucionales a esos problemas estaban entonces en su infancia.

Reutilizar un modelo ya entrenado

Yosinski et al. (2014) midieron qué se puede reutilizar: los rasgos de la primera capa (como los de Gabor y las manchas de color) no dependen de la tarea ni de los datos, y los de las últimas capas sí. He, Girshick y Dollár (2018, informe técnico) compararon, en detección de objetos con COCO, partir de un modelo preentrenado en ImageNet frente a entrenar desde cero: el preentrenamiento acelera la convergencia, pero con suficientes iteraciones entrenar desde cero igualó la exactitud, incluso con el 10 % de los datos; solo con muy pocos datos (menos de unas 10 000 imágenes de COCO) el preentrenamiento mejoró claramente el resultado.

En código

import numpy as np

def conv2d(img, K, b=0.0):
    k = K.shape[0]
    h, w = img.shape[0] - k + 1, img.shape[1] - k + 1
    out = np.zeros((h, w))
    for i in range(h):
        for j in range(w):
            out[i, j] = b + np.sum(K * img[i:i + k, j:j + k])
    return out

Kx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
img = np.zeros((6, 6)); img[:, 3:] = 1          # mitad oscura, mitad clara: un borde vertical
print(conv2d(img, Kx))                           # valores 4 en las columnas del borde, 0 en el resto

Lo que viene

La retropropagación de la lección 8 entrena los kernels igual que cualquier peso. Las redes convolucionales pasaron a dominar la visión a partir de 2012 (lección 13); LeCun, Bengio y Hinton (2015) las describen como el enfoque dominante para casi todas las tareas de reconocimiento y detección. Para datos en secuencia, como el lenguaje, hace falta otra idea (lección 12).