LECCIÓN 7 · CONSTRUIR Y ENTRENAR

Optimizadores y el bucle de entrenamiento

Aquí se junta TODO. El optimizador automatiza la regla w = w − lr·gradiente, y el bucle de entrenamiento es el ciclo de 5 pasos que repetirás en cada proyecto de PyTorch de tu vida.

1. ¿Qué hace un optimizador?

En el curso de redes, actualizabas cada peso a mano con w = w − lr·gradiente. Un optimizador de torch.optim hace eso por todos los parámetros de la red de una sola llamada. Le pasas qué parámetros ajustar y el learning rate:

opt = torch.optim.SGD(net.parameters(), lr=0.1)   # descenso de gradiente
opt = torch.optim.Adam(net.parameters(), lr=0.001)  # más inteligente y popular

SGD: el descenso de gradiente puro que ya conoces. Simple y predecible.
Adam: ajusta el tamaño del paso por parámetro automáticamente. Converge mucho más rápido y es la opción por defecto en la práctica.

2. Un optimizador en acción (cálculo real)

Minimicemos L = (w − 3)² (mínimo en w = 3) empezando en w = 1, con SGD y lr = 0.1:

w = torch.tensor([1.0], requires_grad=True)
opt = torch.optim.SGD([w], lr=0.1)

for step in range(3):
    opt.zero_grad()       # 1. limpiar gradientes
    L = (w - 3)**2      # 2. calcular pérdida
    L.backward()         # 3. gradientes (autograd)
    opt.step()           # 4. actualizar w

salida realstep 0: w=1.0000 L=4.0000 grad=-4.0000 step 1: w=1.4000 L=2.5600 grad=-3.2000 step 2: w=1.7200 L=1.6384 grad=-2.5600 w final: 1.976

✍️ A mano: L=(w−3)², su derivada es dL/dw = 2(w−3), lr=0.1

regla en cada paso:  w_nuevo = w − lr · gradiente

PASO 0  (w = 1.0):
   L    = (1 − 3)²      = (-2)²  = 4.0000
   grad = 2·(1 − 3)     = 2·(-2) = -4.0000
   w    = 1 − 0.1·(-4)  = 1 + 0.4 = 1.4000

PASO 1  (w = 1.4):
   L    = (1.4 − 3)²    = (-1.6)² = 2.5600
   grad = 2·(1.4 − 3)   = 2·(-1.6) = -3.2000
   w    = 1.4 − 0.1·(-3.2) = 1.4 + 0.32 = 1.7200

PASO 2  (w = 1.72):
   L    = (1.72 − 3)²   = (-1.28)² = 1.6384
   grad = 2·(1.72 − 3)  = 2·(-1.28) = -2.5600
   w    = 1.72 − 0.1·(-2.56) = 1.72 + 0.256 = 1.9760

Cada número coincide con la salida real. Mira cómo w sube hacia 3 mientras L baja: está aprendiendo. El gradiente negativo "empuja" a w hacia arriba.

3. El bucle de entrenamiento: los 5 pasos sagrados

Este patrón es idéntico en casi todos los proyectos de PyTorch. Memorízalo:

for epoca in range(num_epocas):
    opt.zero_grad()              # 1. ❌ borrar gradientes del paso anterior
    pred = net(X)                # 2. ▶️ forward: predecir
    loss = loss_fn(pred, Y)      # 3. 📏 medir el error
    loss.backward()             # 4. 🔄 backward: gradientes (autograd)
    opt.step()                  # 5. ✅ actualizar los pesos

Paso	Qué hace	De tu curso de redes
`zero_grad()`	Pone gradientes a 0	(evita la acumulación, lección 4)
`net(X)`	Forward pass	Lecciones 1–4 de redes
`loss_fn(...)`	Función de pérdida	Lección 5 de redes
`backward()`	Backpropagation	Lección 7 de redes
`step()`	w = w − lr·grad	Lección 8 de redes

⚠️ El olvido más común: saltarse zero_grad(). Sin él, los gradientes se acumulan entre pasos (lo viste en la lección 4) y el entrenamiento se vuelve un caos. Siempre va primero.

4. Resumen

El optimizador (SGD, Adam) automatiza la actualización de todos los pesos. El bucle de entrenamiento es siempre el mismo ritual de 5 pasos: zero_grad → forward → loss → backward → step. Esto es el 90% del código de entrenar cualquier red. Hasta ahora entrenamos con todos los datos a la vez; con datasets reales grandes hay que ir por lotes — para eso están Dataset y DataLoader, la próxima lección.