LECCIÓN 12 · AVANZADO

Redes convolucionales (CNNs)

La arquitectura que revolucionó la visión por computadora. En vez de conectar todo con todo, las CNNs deslizan pequeños filtros sobre la imagen para detectar patrones — bordes, texturas, formas.

1. ¿Por qué no usar nn.Linear con imágenes?

Una imagen de 200×200 en color tiene 120.000 valores. Una capa Linear conectándolos a 1.000 neuronas necesitaría 120 millones de pesos — solo en la primera capa. Inviable, y además ignora que los píxeles cercanos están relacionados.

Las CNNs resuelven esto con dos ideas: (1) filtros pequeños que se deslizan por toda la imagen reutilizando los mismos pesos, y (2) detectar patrones locales (un borde es un borde esté donde esté). Resultado: muchísimos menos parámetros y mejor para imágenes.

2. La convolución: nn.Conv2d

Un filtro (kernel) es una pequeña matriz (p. ej. 3×3) que se desliza por la imagen calculando productos. Cada filtro aprende a detectar un patrón. Las imágenes en PyTorch tienen forma (lote, canales, alto, ancho):

# imagen ficticia: lote=1, 1 canal (gris), 8x8 píxeles
img = torch.randn(1, 1, 8, 8)

conv = nn.Conv2d(in_channels=1, out_channels=4, kernel_size=3)
out = conv(img)
print(out.shape)

salida realentrada: (1, 1, 8, 8) salida: (1, 4, 6, 6)

✍️ A mano: de dónde sale el 6×6

Fórmula del tamaño de salida de una convolución:
   salida = (entrada − kernel + 2·padding) / stride + 1

Con entrada=8, kernel=3, padding=0, stride=1:
   (8 − 3 + 2·0) / 1 + 1 = 5 + 1 = 6

Se aplica igual al alto y al ancho → 6×6.
Y son 4 canales porque pusimos out_channels=4 (4 filtros). ✓

4 canales de salida: aplicamos 4 filtros distintos → 4 "mapas de características".
6×6 en vez de 8×8: un filtro 3×3 no cabe en los bordes, así que la imagen "encoge" 2 píxeles (se puede evitar con padding).

3. Pooling: reducir tamaño quedándote con lo importante

nn.MaxPool2d reduce el tamaño tomando el máximo de cada región. Resume y hace la red más eficiente y robusta a pequeños desplazamientos:

pool = nn.MaxPool2d(2)   # toma el máximo de cada bloque 2x2
print(pool(out).shape)

salida realde (1, 4, 6, 6) → (1, 4, 3, 3)

✍️ A mano

MaxPool2d(2) divide alto y ancho entre 2:
   6 / 2 = 3   (toma el máximo de cada bloque 2×2)
Los 4 canales NO cambian (el pooling actúa dentro de cada canal).

El alto y ancho se reducen a la mitad (6→3). Los 4 canales se mantienen.

4. La estructura típica de una CNN

Bloques de [Conv → ReLU → Pool] que extraen patrones cada vez más complejos, y al final capas Linear para clasificar:

cnn = nn.Sequential(
    nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),   # bloque 1
    nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),  # bloque 2
    nn.Flatten(),                                          # aplanar a vector
    nn.Linear(32*7*7, 10),                              # clasificar (10 clases)
)

Las primeras capas detectan patrones simples (bordes); las profundas, patrones complejos (ojos, ruedas…). Es la arquitectura detrás del reconocimiento de imágenes moderno.

💡 Nota: nuestro proyecto final es tabular (no imágenes), así que usaremos capas Linear, no CNNs. Pero conocer las CNNs es esencial en tu caja de herramientas de PyTorch — son el tema de visión por computadora.

5. Resumen

Las CNNs usan Conv2d (filtros que se deslizan detectando patrones locales) y MaxPool2d (reducir tamaño), apilados en bloques, terminando en capas Linear. Mucho menos parámetros que conectar todo con todo, y perfectas para imágenes. En la próxima lección: transfer learning — reusar redes ya entrenadas en vez de empezar de cero.