Redes neuronales y Deep Learning

Una red neuronal es una composición de funciones simples y diferenciables. Cada neurona calcula una combinación lineal de sus entradas y aplica una no linealidad. La magia no está en una neurona, sino en apilar muchas y entrenarlas con gradientes.

La neurona

Funciones de activación

Del perceptrón al MLP

El perceptrón de Rosenblatt es una neurona con umbral. No puede resolver XOR porque una sola frontera lineal no separa las clases. Un perceptrón multicapa con una capa oculta sí puede: combina varias fronteras y las compone.

Profundidad y composición

Una capa oculta puede aproximar funciones continuas con suficiente anchura (teorema de aproximación universal), pero no dice nada sobre cuántos datos o neuronas hacen falta. La profundidad permite construir representaciones jerárquicas: bordes → texturas → partes → objetos. Esa es la intuición del deep learning.

El forward pass es la propagación de la entrada a través de las capas hasta la salida. Es una secuencia de multiplicaciones de matrices y activaciones. Entenderlo es prerequisites para entender backpropagation.

Formulación matricial

Ejemplo numérico completo

Funciones de pérdida

import numpy as np

def relu(z):
    return np.maximum(0, z)

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def forward(X, params):
    W1, b1, W2, b2 = params
    h = relu(X @ W1.T + b1)
    out = sigmoid(h @ W2.T + b2)
    return h, out

X = np.array([[1.0, 2.0]])
params = (
    np.array([[1.0, 0.0], [0.0, 1.0]]),  # W1
    np.array([0.0, -1.0]),               # b1
    np.array([[2.0, -1.0]]),             # W2
    np.array([0.5])                      # b2
)
h, out = forward(X, params)
print("oculta:", h, "salida:", np.round(out, 3))

Backpropagation no es un optimizador: es un algoritmo para calcular gradientes de forma eficiente. Aplica la regla de la cadena capa por capa, reutilizando cálculos intermedios.

La regla de la cadena en una red

Para una pérdida $L$ que depende de la salida $\hat y=f(g(x))$, la derivada es $\frac{dL}{dx}=\frac{dL}{df}\frac{df}{dg}\frac{dg}{dx}$. En una red, cada capa aporta un factor. Backpropagation propaga el gradiente desde la salida hacia la entrada.

Derivación con un ejemplo mínimo

Un detalle crucial: el grafo computacional

Los frameworks construyen un grafo de operaciones durante el forward pass. Al llamar a backward(), recorren ese grafo en orden inverso y acumulan gradientes. Por eso es importante no modificar tensores in-place de forma que se rompa el grafo.

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def train_step(X, y, W, b, lr=0.1):
    # forward
    z = X @ W + b
    a = sigmoid(z)
    loss = np.mean(-(y * np.log(a + 1e-9) + (1 - y) * np.log(1 - a + 1e-9)))

    # backward (entropía cruzada + sigmoide)
    dz = (a - y) / len(X)          # dL/dz
    dW = X.T @ dz                  # dL/dW
    db = dz.sum(axis=0)            # dL/db

    # update
    W -= lr * dW
    b -= lr * db
    return loss, W, b

rng = np.random.default_rng(0)
X = rng.normal(size=(200, 3))
y = (X[:, 0] + X[:, 1] - X[:, 2] > 0).astype(float).reshape(-1, 1)
W = rng.normal(scale=0.1, size=(3, 1))
b = np.zeros((1, 1))

for epoch in range(500):
    loss, W, b = train_step(X, y, W, b)
print("loss final:", round(loss, 4), "W:", np.round(W.ravel(), 3))

El descenso del gradiente puro es simple pero frágil. Los optimizadores modernos adaptan la dirección y la magnitud del paso, y las schedules ajustan la tasa de aprendizaje a lo largo del entrenamiento.

SGD con momentum

RMSProp y Adam

Schedules de tasa de aprendizaje

• Step decay: reduce la tasa cada cierto número de épocas.
• Cosine annealing: reduce suavemente siguiendo un coseno.
• Warmup: empieza con una tasa muy baja y sube; estabiliza el inicio de transformers.
• ReduceLROnPlateau: baja cuando la métrica de validación deja de mejorar.

import torch

modelo = torch.nn.Sequential(
    torch.nn.Linear(20, 64), torch.nn.ReLU(),
    torch.nn.Linear(64, 1)
)

optimizador = torch.optim.AdamW(modelo.parameters(), lr=1e-3, weight_decay=1e-2)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizador, T_max=50)

loss_fn = torch.nn.BCEWithLogitsLoss()

for epoch in range(50):
    modelo.train()
    for xb, yb in train_loader:
        optimizador.zero_grad()
        logits = modelo(xb).squeeze(1)
        loss = loss_fn(logits, yb)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(modelo.parameters(), 1.0)
        optimizador.step()
    scheduler.step()
    print(f"epoch {epoch}: lr={scheduler.get_last_lr()[0]:.5f}")

Las redes tienen millones de parámetros y pueden memorizar. Regularizar es limitar su capacidad efectiva sin perder capacidad expresiva. No hay una técnica mágica: cada una ataca un mecanismo distinto.

Otras técnicas

• Data augmentation: transformaciones válidas que amplían la variedad de ejemplos.
• Label smoothing: suaviza las etiquetas duras y reduce la confianza excesiva.
• Mixup / CutMix: combina ejemplos y etiquetas para crear datos virtuales.
• Stochastic depth: omite bloques residuales al azar en redes muy profundas.
• Gradient clipping: limita la norma del gradiente, útil en RNN y transformers.

Receta de diagnóstico

Una capa densa sobre una imagen de 224×224×3 tendría 150 000 pesos por neurona y destruiría la estructura espacial. Una convolución comparte un filtro pequeño en todas las posiciones: menos parámetros, invariancia a traslaciones y detección local de patrones.

La operación

Hiperparámetros de una capa

• Filtros: cuántos patrones distintos aprende la capa.
• Kernel size: 3×3 es el estándar; apilar dos 3×3 cubre un campo receptivo de 5×5 con menos parámetros.
• Stride: paso del kernel. Stride 2 reduce la resolución.
• Padding: mantiene el tamaño espacial con same o lo reduce con valid.
• Canales: la profundidad de entrada y salida; cada filtro produce un mapa de activación.

Pooling y estructura típica

El max pooling resume regiones locales y reduce la dimensión espacial. Una CNN clásica alterna convoluciones, activaciones y pooling, y termina con capas densas para clasificar.

import torch
import torch.nn as nn

class CNN(nn.Module):
    def __init__(self, n_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),                       # 32x32 -> 16x16
            nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),                       # 16x16 -> 8x8
            nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(),
            nn.AdaptiveAvgPool2d((1, 1))           # 8x8 -> 1x1
        )
        self.classifier = nn.Linear(128, n_classes)

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        return self.classifier(x)

modelo = CNN()
print(sum(p.numel() for p in modelo.parameters()), "parámetros")

Las arquitecturas modernas no se inventan desde cero: se reutilizan modelos preentrenados en ImageNet y se ajustan a la tarea. Es la forma más práctica de obtener buenos resultados con pocos datos.

Evolución en una tabla

ResNet: la conexión que lo cambió todo

Transfer learning

1. Elige un modelo preentrenado en un dataset grande y similar.
2. Congela el extractor de features y entrena una cabeza nueva para tu tarea.
3. Si tienes suficientes datos, descongela algunas capas y ajusta con una tasa pequeña (fine-tuning).
4. Usa augmentation y early stopping para evitar sobreajustar.

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

# Modelo preentrenado en ImageNet
modelo = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

# Congelar el extractor
for param in modelo.parameters():
    param.requires_grad = False

# Reemplazar la cabeza para nuestro número de clases
modelo.fc = nn.Linear(modelo.fc.in_features, n_clases)

# Solo la cabeza se entrena al principio
optimizador = torch.optim.AdamW(modelo.fc.parameters(), lr=1e-3)

# Fine-tuning opcional: descongelar el último bloque
# for param in modelo.layer4.parameters():
#     param.requires_grad = True
# optimizador = torch.optim.AdamW(modelo.parameters(), lr=1e-4)

En una secuencia, el orden importa. Una RNN procesa un elemento a la vez y mantiene un estado oculto que resume el pasado. Es la base histórica del modelado de lenguaje, series temporales y audio.

LSTM y GRU

La LSTM introduce una celda de memoria y compuertas que deciden qué recordar, qué olvidar y qué exponer. La GRU simplifica la idea con dos compuertas. Ambas mitigan el problema del gradiente que se desvanece.

import torch
import torch.nn as nn

class ClasificadorSecuencia(nn.Module):
    def __init__(self, vocab, emb=64, hidden=128, clases=2):
        super().__init__()
        self.embedding = nn.Embedding(vocab, emb, padding_idx=0)
        self.lstm = nn.LSTM(emb, hidden, batch_first=True, bidirectional=True)
        self.dropout = nn.Dropout(0.3)
        self.fc = nn.Linear(hidden * 2, clases)

    def forward(self, x, lengths=None):
        e = self.embedding(x)
        packed = nn.utils.rnn.pack_padded_sequence(
            e, lengths.cpu(), batch_first=True, enforce_sorted=False
        )
        _, (h, _) = self.lstm(packed)
        h = torch.cat([h[-2], h[-1]], dim=1)  # último estado de ambas direcciones
        return self.fc(self.dropout(h))

Series temporales

En series temporales, la validación debe respetar el tiempo. Además, features como lags, medias móviles y calendario suelen ser más importantes que la arquitectura. Una LSTM no compensa un mal diseño de ventanas o fugas del futuro.

La atención permite que cada token consulte a todos los demás y decida a cuáles prestar atención. El Transformer eliminó la recurrencia y se convirtió en la arquitectura dominante de NLP y, cada vez más, de visión y audio.

Multi-head attention

En lugar de una sola atención, se proyectan $Q,K,V$ en $h$ subespacios y se concatenan. Cada cabeza puede especializarse en relaciones distintas: sintaxis, correferencia, posición. La salida se proyecta de nuevo a la dimensión del modelo.

El bloque Transformer

1. Embedding de tokens + codificación posicional.
2. Multi-head self-attention con conexión residual y LayerNorm.
3. Feed-forward por posición (dos capas lineales con activación).
4. Otra conexión residual + LayerNorm.
5. Se apilan $N$ bloques; la salida se usa para predecir o representar.

import torch
import torch.nn as nn

class BloqueTransformer(nn.Module):
    def __init__(self, d_model=128, n_heads=4, d_ff=256, dropout=0.1):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, n_heads, dropout=dropout, batch_first=True)
        self.norm1 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(
            nn.Linear(d_model, d_ff), nn.GELU(), nn.Dropout(dropout),
            nn.Linear(d_ff, d_model)
        )
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        attn, _ = self.attention(x, x, x, attn_mask=mask, need_weights=False)
        x = self.norm1(x + self.dropout(attn))
        x = self.norm2(x + self.dropout(self.ff(x)))
        return x

modelo = BloqueTransformer()
entrada = torch.randn(8, 20, 128)  # batch, secuencia, dimensión
print(modelo(entrada).shape)

Entrenar una red no es solo elegir una arquitectura. Es construir un pipeline reproducible, comprobar que aprende, detectar fugas, controlar el overfitting y comparar contra baselines honestas.

Checklist antes de escalar

1. Overfit un batch pequeño: si la red no puede memorizar 10 ejemplos, hay un bug en datos, etiquetas o gradientes.
2. Verifica formas y rangos: imprime shapes, medias y mínimos/máximos de las entradas.
3. Comprueba la pérdida inicial: para $K$ clases balanceadas, la entropía inicial ronda $\log K$.
4. Visualiza ejemplos y augmentations: errores de etiqueta o transformaciones destructivas explican muchos fracasos.
5. Fija semillas y registra versiones: sin reproducibilidad no puedes comparar experimentos.

Entrenamiento con buenas prácticas

import torch
from torch.utils.data import DataLoader

def evaluar(modelo, loader, loss_fn):
    modelo.eval()
    total, correct, perdida = 0, 0, 0.0
    with torch.no_grad():
        for xb, yb in loader:
            xb, yb = xb.to(device), yb.to(device)
            logits = modelo(xb)
            perdida += loss_fn(logits, yb).item() * len(xb)
            correct += (logits.argmax(1) == yb).sum().item()
            total += len(xb)
    return perdida / total, correct / total

mejor_val = float("inf")
paciencia = 5
espera = 0

for epoch in range(50):
    modelo.train()
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        opt.zero_grad()
        loss = loss_fn(modelo(xb), yb)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(modelo.parameters(), 1.0)
        opt.step()

    val_loss, val_acc = evaluar(modelo, val_loader, loss_fn)
    print(f"epoch {epoch:02d} val_loss={val_loss:.4f} val_acc={val_acc:.3f}")

    if val_loss < mejor_val - 1e-4:
        mejor_val = val_loss
        espera = 0
        torch.save(modelo.state_dict(), "mejor_modelo.pt")
    else:
        espera += 1
        if espera >= paciencia:
            print("early stopping")
            break