En el Módulo 3 armamos una CNN completa: convoluciones que extraen features, pooling que resume y capas densas que clasifican. Pero una red recién construida tiene los filtros en números aleatorios — no distingue un gato de un tostador. Falta lo esencial: cómo aprende. Este módulo cierra el bloque básico enseñando a entrenar una CNN, y termina en el atajo que casi siempre conviene en la práctica: el transfer learning.

La tesis del módulo

Entrenar es ajustar los filtros a base de errores. La red predice, se compara con la respuesta correcta, mide cuánto se equivocó y corrige un poquito cada peso. Repetido millones de veces, esos filtros aleatorios se convierten en detectores de bordes, texturas y objetos. Y casi nunca hace falta empezar de cero: el transfer learning te regala una red que ya aprendió a ver.

Cómo aprende: el ciclo de entrenamiento

Entrenar necesita datos etiquetados: miles de imágenes, cada una con su respuesta correcta (“esto es un gato”). Con eso corre un ciclo que se repite sin parar:

Predicción (forward): la imagen entra, atraviesa la red y sale una probabilidad por clase.
Medir el error con la loss (función de pérdida): un número que dice cuán lejos estuvo la predicción de la verdad.
Backpropagation: repartir la culpa de ese error entre todos los pesos.
Actualizar: mover cada peso un pasito en la dirección que reduce el error.

   ┌────────────────────────┐
   │  imagen + etiqueta     │
   └───────────┬────────────┘
               ▼
   ┌────────────────────────┐
   │  CNN (pesos)  forward  │◄───────────┐
   └───────────┬────────────┘            │
               ▼                         │
   ┌────────────────────────┐            │
   │  predicción vs verdad  │            │
   └───────────┬────────────┘            │
               ▼                         │
   ┌────────────────────────┐            │
   │  loss: mide el error   │            │
   └───────────┬────────────┘            │
               ▼                         │
   ┌────────────────────────┐            │
   │  backpropagation  +    │            │
   │  actualizar los pesos  ├────────────┘
   └────────────────────────┘

La loss de cross-entropy. Para clasificar, la pérdida estándar es la cross-entropy (entropía cruzada). En simple: castiga fuerte cuando la red asigna poca probabilidad a la clase correcta. Si la verdad es “gato” y la red dijo 90% gato, la pérdida es baja; si dijo 5% gato, la pérdida es alta. El entrenamiento empuja esa probabilidad hacia arriba.

Backpropagation. Es el algoritmo que hace posible el aprendizaje. Como vimos en Cómo funciona la IA (y a fondo en Backpropagation, del Curso de Redes Neuronales), tras medir el error, backpropagation lo propaga hacia atrás por toda la red calculando cuánto contribuyó cada peso a equivocarse. Con esa información, cada peso se corrige en la dirección que baja la pérdida. Millones de repeticiones y los filtros aleatorios se vuelven detectores útiles.

Overfitting: el enemigo

Aquí aparece el problema más traicionero del machine learning. Overfitting (sobreajuste) es cuando la red memoriza las imágenes de entrenamiento en vez de aprender el patrón general. Le va perfecto con las fotos que ya vio y pésimo con fotos nuevas — como un alumno que memoriza las respuestas del ensayo pero no entiende la materia.

   entrenamiento    generalización (fotos nuevas)

   sin overfitting:  aprende gatos       ──► reconoce
                                              gatos nuevos OK

   con overfitting:  memoriza ESTOS      ──► falla con
                     gatos exactos           gatos nuevos MAL

La señal de alarma: el error baja y baja en los datos de entrenamiento, pero se estanca o sube en un set de validación (fotos apartadas que la red no vio). Pasa sobre todo con pocos datos. Y las CNN tienen tantos parámetros que memorizar les resulta muy fácil.

Arma 1: data augmentation

La cura más directa es tener más datos… pero etiquetar más fotos es caro. El truco: data augmentation (aumento de datos), que fabrica variaciones nuevas a partir de las que ya tienes. A cada imagen se le aplican transformaciones al vuelo:

Voltear horizontalmente (un gato al espejo sigue siendo un gato).
Recortar una región al azar (crop).
Rotar unos grados.
Cambiar levemente brillo, contraste o color.

Cada época la red ve una versión distinta de cada foto, así que le cuesta mucho más memorizar píxeles exactos y se ve obligada a aprender el patrón real. Es barato, no necesita datos nuevos y casi siempre ayuda.

Ojo: las transformaciones tienen que respetar el significado. Voltear un gato horizontalmente está perfecto; voltear un 6 lo convierte en algo que no es un 6, y rotar 180° una señal de tránsito cambia lo que significa. Aumenta solo con transformaciones que preserven la etiqueta.

Arma 2: transfer learning (el atajo práctico)

Aquí está la idea más útil del módulo para el mundo real. Transfer learning (aprendizaje por transferencia) es no empezar de cero: tomas una red que ya fue entrenada con millones de imágenes —típicamente ImageNet, un dataset gigante de 1.000 categorías— y la adaptas a tu problema.

¿Por qué funciona? Porque los bordes, texturas y formas que aprendió esa red (recuerda la jerarquía del módulo 3) sirven para cualquier imagen, no solo para las de ImageNet. Esa parte ya entrenada se llama backbone (el cuerpo preentrenado que extrae features). Solo tienes que reemplazar la última capa por una nueva para tus clases y afinar.

   modelo preentrenado en ImageNet (1000 clases)
   ┌──────────────────────────┐    ┌───────────┐
   │  backbone convolucional  │──► │ cabeza    │
   │  (bordes, texturas,      │    │ 1000      │
   │   formas — YA aprendido) │    │ clases    │
   └─────────────┬────────────┘    └───────────┘
                 ▼               (se descarta la
   ┌──────────────────────────┐   cabeza vieja)
   │  backbone (se reutiliza, │    ┌───────────┐
   │  casi congelado)         │──► │ cabeza    │
   │                          │    │ NUEVA:    │
   └──────────────────────────┘    │ tus clases│
                                   └───────────┘

La ventaja es enorme: en vez de millones de imágenes y días de cómputo, con unos cientos de fotos y minutos de entrenamiento obtienes buenos resultados. Por eso, salvo que tengas un dataset gigante, empezar por transfer learning es casi siempre lo correcto.

	Entrenar desde cero	Transfer learning
Datos necesarios	Muchísimos (decenas de miles+)	Pocos (cientos suele bastar)
Tiempo / cómputo	Alto (horas o días de GPU)	Bajo (minutos a horas)
Riesgo de overfitting	Alto con pocos datos	Mucho menor
Calidad con dataset chico	Pobre	Buena
Cuándo usarlo	Dataset enorme o dominio muy raro	Casi siempre, punto de partida

En código: afinar una ResNet preentrenada

Veámoslo con torchvision. Cargamos una ResNet-18 ya entrenada en ImageNet, congelamos el backbone y le ponemos una cabeza nueva para nuestras clases.

import torch
import torch.nn as nn
from torchvision import models

# 1. Cargar la ResNet-18 con sus pesos preentrenados en ImageNet
modelo = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

# 2. Congelar el backbone: sus filtros ya saben ver, no los tocamos
for parametro in modelo.parameters():
    parametro.requires_grad = False

# 3. Reemplazar la última capa por una nueva para NUESTRAS clases
#    (la original clasificaba 1000; supongamos que tenemos 5)
num_features = modelo.fc.in_features      # cuántas features entran a la cabeza
modelo.fc = nn.Linear(num_features, 5)    # cabeza nueva, sí se entrena

# 4. Loss de clasificación y optimizador SOLO sobre la cabeza nueva
criterio = nn.CrossEntropyLoss()
optimizador = torch.optim.Adam(modelo.fc.parameters(), lr=1e-3)

# 5. Un paso de entrenamiento (el ciclo del diagrama de arriba)
for imagenes, etiquetas in cargador_datos:      # tu DataLoader
    optimizador.zero_grad()
    predicciones = modelo(imagenes)             # forward
    perdida = criterio(predicciones, etiquetas) # cross-entropy
    perdida.backward()                          # backpropagation
    optimizador.step()                          # actualizar la cabeza

Fíjate en el patrón: el backbone queda congelado (requires_grad = False) y el optimizador solo recibe modelo.fc.parameters(). Así aprovechas todo lo que la red ya sabía y solo enseñas la parte nueva. Si tuvieras más datos, podrías descongelar también las últimas capas del backbone y afinarlas con un learning rate bajito — eso se llama fine-tuning completo.

Errores comunes

Juzgar el modelo por el error de entrenamiento. Ese número siempre baja; lo que importa es el error en datos que la red no vio (validación). La brecha entre ambos delata el overfitting.
Entrenar desde cero con pocos datos. Es la receta del overfitting. Con dataset chico, transfer learning gana casi siempre.
Augmentar rompiendo la etiqueta. Voltear un dígito o rotar una señal cambia su significado; solo transforma de formas que preserven la clase.
Olvidar congelar el backbone. Si dejas todo entrenable con pocos datos, arruinas los filtros preentrenados y pierdes la ventaja del transfer learning.
Usar el learning rate de “desde cero” al afinar. Un LR alto sobre un backbone preentrenado borra lo aprendido. Al hacer fine-tuning, baja el learning rate.

Cierre del bloque básico

Ya tienes la base completa de la visión por computador: una imagen es un tensor de píxeles (M1), la convolución detecta patrones (M2), apilar capas crea una jerarquía de bordes a objetos (M3) y el entrenamiento —con data augmentation y transfer learning— convierte filtros aleatorios en una red que ve (M4). Con esto se puede clasificar. Todo lo que viene construye sobre esta base para dar el gran salto: de entender imágenes a crearlas.

La frase para llevarse

“Entrenar una CNN es enseñarle a equivocarse cada vez menos. Y casi nunca vale la pena empezar de cero: párate sobre los hombros de una red que ya aprendió a ver, y solo enséñale lo tuyo.”

Qué viene

Módulo 5: autoencoders y VAE, y con él arranca el bloque intermedio. Hasta aquí la CNN analiza imágenes; ahora damos vuelta el flujo para generar. Los autoencoders aprenden a comprimir una imagen a su esencia y reconstruirla — y los VAE convierten esa esencia en una fábrica de imágenes nuevas. Es el salto de clasificar a crear.

Generación de imágenes — Módulo 4: entrenar una CNN — data augmentation y transfer learning