CNN Architectures: Evolución de Profundidad y Feature Extraction

El reconocimiento de imágenes ha migrado de la extracción de características manuales (SIFT, HOG) hacia el aprendizaje "end-to-end" mediante Convolutional Neural Networks (CNNs). El problema central que abordan estas arquitecturas es la invarianza espacial y la gestión de la alta dimensionalidad en tensores de entrada (imágenes RGB), manteniendo la coherencia estructural de los datos.

El estado del arte (SOTA) en la competición ILSVRC ha demostrado una correlación directa entre la profundidad de la red (número de capas) y la reducción del error de clasificación. Sin embargo, arquitecturas como VGG-16 han expuesto los límites computacionales en términos de parámetros, mientras que la reciente aparición de ResNet (He et al., 2015) propone solucionar el problema de vanishing gradient en redes ultra profundas.

Fundamentos matemáticos

Una CNN basa su funcionamiento en la operación de convolución discreta, la cual permite compartir parámetros (pesos) a lo largo de la imagen, reduciendo drásticamente la complejidad respecto a un perceptrón multicapa (MLP) tradicional.

Dada una imagen de entrada $I$ y un kernel (filtro) $K$ de dimensiones $2h+1 \times 2w+1$, la operación de convolución en la posición $(i, j)$ se define como:

$$(I * K)_{i,j} = \sum_{m=-h}^{h} \sum_{n=-w}^{w} K_{m,n} \cdot I_{i-m, j-n}$$

Tras la convolución, se aplica una función de activación no lineal. La norma actual ha desplazado a la sigmoide y $\tanh$ en favor de ReLU (Rectified Linear Unit) debido a su eficiencia computacional y mitigación del desvanecimiento del gradiente en el paso backward:

$$f(x) = \max(0, x)$$

Finalmente, para ganar invarianza a pequeñas traslaciones y reducir la dimensionalidad espacial, se utiliza Pooling. El estándar de facto es Max Pooling:

$$y_{i,j} = \max_{(m,n) \in \mathcal{R}_{i,j}} x_{m,n}$$

Donde $\mathcal{R}_{i,j}$ es la región local definida por el tamaño de la ventana de pooling y el stride aplicado.

4. Implementación práctica

A continuación se presenta la definición de un bloque convolucional típico (estilo VGG) utilizando sintaxis de Keras (sobre backend Theano), enfocándose en la pila de convoluciones de $3 \times 3$ seguidas de Max Pooling.

from keras.models import Sequential
from keras.layers import Convolution2D, MaxPooling2D, Flatten, Dense, Dropout

def build_vgg_style_block(input_shape):
    model = Sequential()

    # Bloque 1: Extracción de features de bajo nivel
    # 64 filtros, kernel 3x3. 'same' padding mantiene dimensiones espaciales.
    model.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same', input_shape=input_shape))
    model.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

    # Bloque 2: Aumento de profundidad de filtros
    model.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    model.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

    # Capas Fully Connected (Clasificador)
    model.add(Flatten())
    model.add(Dense(4096, activation='relu'))
    model.add(Dropout(0.5)) # Regularización crítica en VGG
    model.add(Dense(4096, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(1000, activation='softmax')) # Salida ImageNet

    return model

# Ejemplo de instanciación para inputs de 224x224 RGB
model = build_vgg_style_block((3, 224, 224))

Nota: La arquitectura VGG se caracteriza por reemplazar filtros grandes (11x11 o 7x7 usados en AlexNet) por pilas de filtros 3x3, manteniendo el mismo campo receptivo efectivo pero con mayor no-linealidad.

La siguiente figura ilustra el flujo de datos a través de los bloques convolucionales de una arquitectura VGG-style:

5. Análisis de comportamiento

Al entrenar estas arquitecturas en GPUs (como NVIDIA Titan X), se observan patrones claros:

• Coste Computacional y Memoria: VGG-16 es extremadamente densa en parámetros (~138 millones), concentrados mayoritariamente en las primeras capas Fully Connected (FC). Esto genera un consumo de VRAM elevado tanto en entrenamiento como en inferencia.
• Convergencia: El uso de inicialización de pesos adecuada (Xavier o He initialization) es obligatorio. Sin ella, o sin el uso de Batch Normalization (introducido por Ioffe & Szegedy, 2015), redes profundas (>8 capas) no logran converger.
• Problema de Degradación: Al intentar simplemente apilar más capas (ej. una red plana de 50 capas), el error de entrenamiento aumenta en lugar de disminuir. Esto no es overfitting, sino dificultad en la optimización. Este es el comportamiento que ResNet mitiga mediante skip connections:

$$y = \mathcal{F}(x, \{W_i\}) + x$$

Donde la red aprende el mapeo residual $\mathcal{F}(x)$ en lugar del mapeo directo, facilitando el flujo del gradiente.

El siguiente diagrama muestra el mecanismo de skip connection que permite entrenar redes de más de 100 capas:

6. Comparativas y referencias técnicas

Comparación de arquitecturas clave en el dataset ImageNet (ILSVRC):

• VGG destaca por su simplicidad estructural y facilidad para Transfer Learning, a pesar de su ineficiencia en memoria.
• GoogLeNet optimiza drásticamente el conteo de parámetros usando módulos Inception, pero su implementación es más compleja.
• ResNet (actual ganador ILSVRC 2015) ha roto la barrera de la profundidad, logrando entrenar redes de más de 100 capas con menor error y complejidad computacional que VGG.

7. Limitaciones y casos donde no conviene usarlo

• Tamaño de entrada fijo: Las capas Fully Connected al final de arquitecturas como VGG o AlexNet exigen dimensiones de entrada fijas (ej. 224x224). Esto obliga a realizar cropping o warping en las imágenes, perdiendo información o introduciendo distorsión.
• Invarianza vs. Equivarianza: El Max Pooling otorga invarianza a pequeñas traslaciones, pero pierde información espacial precisa (pose y orientación). Para tareas que requieren segmentación a nivel de píxel o detección de keypoints precisos, la pérdida de resolución espacial en las capas profundas es contraproducente.
• Data Hunger: Estas arquitecturas no generalizan bien con datasets pequeños (<10k imágenes) si se entrenan desde cero (from scratch). En esos casos, es obligatorio usar fine-tuning de modelos pre-entrenados en ImageNet.
• Cajas negras: Aunque visualizaciones como DeconvNet permiten intuir qué activa ciertos filtros, la interpretabilidad de las decisiones en capas profundas sigue siendo limitada para entornos críticos.