En el Módulo 2 vimos que un filtro convolucional detecta un patrón chico —un borde, una textura— y produce un feature map. Pero un borde no es un gato. Quedó la pregunta abierta: ¿cómo se pasa de detectar contornos a reconocer un objeto completo? La respuesta es apilar: poner una capa convolucional encima de otra, muchas veces. Ahí nace la arquitectura CNN (Convolutional Neural Network, red neuronal convolucional).

La tesis del módulo

La profundidad construye significado. Una capa convolucional sola ve bordes. Al apilar capas, cada una combina lo que vio la anterior: bordes se juntan en formas, formas en partes, partes en objetos. Una CNN no reconoce un gato de golpe; lo arma capa por capa, de lo simple a lo complejo.

La jerarquía de features

Este es el concepto central del módulo. Cuando apilas capas convolucionales, cada nivel trabaja sobre los feature maps del anterior, y emerge una jerarquía de features (características cada vez más abstractas):

   PROFUNDIDAD  ────────────────────────────────►

   capa 1       capa 2       capa 3       capa 4
   ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐
   │ bordes │   │ formas │   │ partes │   │ objetos│
   │ y color│   │ y      │   │ (ojo,  │   │ (gato, │
   │        │   │texturas│   │ rueda) │   │ auto)  │
   └────────┘   └────────┘   └────────┘   └────────┘
   simple  ──────────────────────────────► complejo

Las primeras capas detectan lo básico: bordes, manchas de color, cambios de brillo.
Las capas del medio combinan bordes en texturas y formas: curvas, esquinas, rejillas.
Las capas profundas combinan formas en partes reconocibles: un ojo, una oreja, una rueda.
Las últimas combinan partes en objetos completos: un rostro, un gato, un auto.

Nadie programa esta jerarquía: emerge sola del entrenamiento. Es una de las cosas más elegantes del deep learning — la red descubre por su cuenta que para ver gatos primero conviene ver bordes.

Pooling: reducir para robustecer

Entre bloques de convolución se intercala el pooling (submuestreo: achicar el feature map resumiendo cada región chica en un solo valor). Los dos tipos:

Max pooling: de cada ventana (típico 2×2) se queda con el valor máximo. Pregunta “¿apareció el patrón en algún lugar de esta zona?” y guarda la respuesta más fuerte. Es el más usado.
Average pooling: se queda con el promedio de la ventana. Resume la intensidad media en vez del pico.

   max pooling 2x2 (ventana 2x2, se queda el mayor)

   feature map 4x4          salida 2x2
   ┌───┬───┬───┬───┐
   │ 1 │ 3 │ 2 │ 0 │        ┌───┬───┐
   ├───┼───┼───┼───┤        │ 6 │ 8 │   6 = max(1,3,5,6)
   │ 5 │ 6 │ 8 │ 1 │  ───►  ├───┼───┤   8 = max(2,0,8,1)
   ├───┼───┼───┼───┤        │ 9 │ 4 │
   │ 9 │ 2 │ 1 │ 4 │        └───┴───┘
   ├───┼───┼───┼───┤
   │ 7 │ 3 │ 2 │ 4 │
   └───┴───┴───┴───┘

El pooling hace dos cosas: reduce la resolución (menos cómputo y memoria en las capas siguientes) y da robustez — si el patrón se corre un par de píxeles, el máximo de la ventana no cambia, así que la red se vuelve tolerante a pequeñas variaciones de posición.

Ojo: el pooling reduce alto y ancho, pero no los canales. Un max pooling 2×2 sobre un tensor de 64 canales y 224×224 saca 64 canales de 112×112. Achica el “mapa”, no la cantidad de detectores.

La CNN completa para clasificar

Ahora armemos la red entera. Una CNN clásica de clasificación tiene dos mitades bien distintas: primero un extractor de features (convoluciones y pooling), luego un clasificador (capas densas).

   ┌───────────────────┐
   │  imagen RGB HxWx3 │   la entrada
   └─────────┬─────────┘
             ▼
   ┌───────────────────┐
   │ conv + pool  (xN) │   extrae features
   │ bordes a objetos  │   (jerarquía)
   └─────────┬─────────┘
             ▼
   ┌───────────────────┐
   │      flatten      │   aplana a un vector
   └─────────┬─────────┘
             ▼
   ┌───────────────────┐
   │  FC + softmax     │   probabilidad por clase
   └─────────┬─────────┘
             ▼
           clase

Las piezas nuevas del clasificador:

Flatten (aplanar): tras las convoluciones tenemos un tensor 3D chico y rico en significado (p. ej. 512 canales de 7×7). Se estira en un vector largo para pasarlo a las capas densas. Ahora aplanar sí sirve: ya no aplanamos píxeles crudos sino features abstractas.
Capas totalmente conectadas (FC, las del módulo 1): combinan todas esas features en un veredicto. Son las que dicen “con estos bordes, texturas y partes presentes, esto es un gato”.
Softmax: la última capa convierte los números de salida en probabilidades que suman 1 — “87% gato, 9% perro, 4% zorro”. La clase ganadora es la predicción.

La clave: aplanar al final (sobre features) no es el error del módulo 1, que era aplanar al principio (sobre píxeles crudos). Las convoluciones ya hicieron el trabajo espacial; las FC solo toman la decisión.

Las arquitecturas clásicas

La historia de la visión moderna es la historia de estas redes. Cada una aportó una idea que hoy damos por sentada:

Arquitectura	Año	Capas (aprox.)	Aporte clave
LeNet-5	1998	7	La primera CNN útil (dígitos escritos a mano)
AlexNet	2012	8	Ganó ImageNet y arrancó el boom del deep learning
VGG	2014	16–19	Todo con kernels 3×3; profundidad uniforme y simple
ResNet	2015	50–152	Conexiones residuales: redes de cientos de capas

LeNet demostró que la idea funcionaba. AlexNet, con GPUs y más datos, pulverizó el récord de ImageNet y encendió la revolución. VGG mostró que apilar muchos kernels chiquitos (3×3) era mejor que pocos grandes.

Y ResNet resolvió el muro de la profundidad. Al pasar de ~20 a ~50 capas, las redes empezaban a empeorar: la señal se degradaba al atravesar tantas capas y el entrenamiento se atascaba. La solución fueron las conexiones residuales (residual connections, también llamadas skip connections): un atajo que suma la entrada de un bloque directamente a su salida, dejando que la información salte capas sin degradarse.

   bloque residual (skip connection)

           entrada x
              │
       ┌──────┴──────┐
       │             │
       ▼             │  atajo: x pasa
   ┌───────┐         │  intacto y se
   │ conv  │         │  suma al final
   │ conv  │         │
   └───┬───┘         │
       ▼             │
      (+)◄───────────┘
       │
       ▼
    salida = conv(x) + x

Si esa idea te suena, es porque es exactamente la misma que sostiene al Transformer. En La arquitectura completa del Transformer las conexiones residuales cumplen el mismo rol: dejar que la señal fluya intacta a través de muchas capas. ResNet (2015) las popularizó en visión; el Transformer (2017) las heredó para el lenguaje. Una misma buena idea, dos mundos.

Errores comunes

Creer que más capas siempre es mejor. Sin conexiones residuales, pasar de cierta profundidad empeora la red. ResNet existe justamente por eso.
Confundir pooling con convolución. El pooling no tiene parámetros que aprender: solo resume (máximo o promedio). La convolución sí aprende sus filtros.
Aplanar demasiado pronto. Aplanar píxeles crudos es el error del módulo 1. Aplanar features al final, tras las convoluciones, es correcto y necesario.
Olvidar el softmax. Sin él, la salida son números sueltos sin interpretación; el softmax los vuelve probabilidades comparables que suman 1.
Pensar que el pooling reduce los canales. Reduce alto y ancho; los canales los cambian las convoluciones, no el pooling.

La frase para llevarse

“Una CNN no reconoce un gato: reconoce bordes, con esos bordes arma formas, con las formas partes, y con las partes, recién ahí, un gato. La profundidad es lo que convierte números en significado.”

Qué viene

Módulo 4 y cierre del bloque básico: entrenar una CNN. Ya sabemos cómo está hecha una red; falta lo esencial — cómo aprende. Veremos la función de pérdida, backpropagation, el enemigo llamado overfitting y dos armas prácticas: data augmentation y transfer learning (el atajo que casi siempre conviene).

Generación de imágenes — Módulo 3: la arquitectura CNN — de bordes a objetos