Cuatro redes, cuatro suposiciones sobre los datos
Si ya sabes qué es una neurona, una función de pérdida y un descenso de gradiente, queda una pregunta práctica: ¿qué cambia de una arquitectura a otra y por qué cada pieza encaja con imágenes, secuencias o texto? Ese paso a paso lo explico en Cómo funcionan las redes neuronales, así que aquí no lo repito.
Esto es lo importante: todas siguen siendo funciones con parámetros que se ajustan poco a poco. Lo que cambia es la suposición que metes en la estructura. Una arquitectura es una apuesta sobre cómo están organizados tus datos, y si la apuesta es buena, necesitas menos parámetros y menos ejemplos para aprender.
- Densa: no asume nada.
- Convolucional: localidad e invarianza a la traslación.
- Recurrente: un estado que viaja por la secuencia.
- Transformer: atención global, cada posición puede mirar a cualquier otra.
Cada sección lleva un ejemplo que se comprueba solo con assert: si lo ejecutas y no salta ningún error, hace lo que dice el texto.
Red densa: la base sin suposiciones
Una capa densa (o totalmente conectada) hace que cada salida dependa de todas las entradas. En PyTorch, nn.Linear aplica una transformación afín, y = xAᵀ + b, y sus pesos tienen forma (out_features, in_features). Según la documentación de PyTorch, una capa nn.Linear(20, 30) aplicada a un lote de 128 vectores de 20 valores devuelve una salida de tamaño [128, 30].
import torch
from torch import nn
torch.manual_seed(0)
capa = nn.Linear(20, 30)
x = torch.randn(128, 20)
y = capa(x)
assert y.shape == (128, 30)
assert capa.weight.shape == (30, 20) # (salidas, entradas)
# Lo mismo a mano: y = x A^T + b
assert torch.allclose(y, x @ capa.weight.T + capa.bias, atol=1e-5)
print("Capa densa: formas y fórmula comprobadas")
La última comprobación es la clave: no hay nada más que una multiplicación de matrices y una suma.
Es el punto de partida porque no presupone estructura alguna. Eso es una virtud con datos tabulares o vectores de características donde el orden de las columnas no significa nada, y un problema con imágenes: el libro Dive into Deep Learning señala que tratar una imagen con capas totalmente conectadas podría requerir miles de millones de parámetros (D2L, sección 7.1). Como criterio práctico (no una cifra medida): si tus datos no tienen estructura espacial ni temporal, la densa es el primer candidato razonable.
Red convolucional: localidad y pesos compartidos
D2L parte de dos principios para las primeras capas ante una imagen:
- Invarianza a la traslación: la red debe responder igual a un mismo parche, aparezca donde aparezca.
- Localidad: las primeras capas se fijan en regiones locales, sin considerar zonas lejanas. Esas representaciones locales se agregan después, y las capas más profundas captan características de mayor alcance.
Una capa convolucional equivale a una capa totalmente conectada restringida por esos dos principios. Los pesos aprendibles son el núcleo (kernel o filtro), el mismo en todas las posiciones. Según D2L, eso baja de miles de millones de parámetros potenciales a unos pocos cientos, sin cambiar las dimensiones de la entrada ni de la representación oculta.
Para verlo sin librerías, aquí va una convolución escrita a mano con NumPy (en rigor, una correlación cruzada, que es lo que calculan las capas convolucionales de las librerías). El filtro detecta un borde vertical; desplazamos el borde dos columnas y comprobamos que la respuesta se desplaza igual. No usa números aleatorios.
import numpy as np
def convolucion(imagen, nucleo):
k = nucleo.shape[0]
alto, ancho = imagen.shape[0] - k + 1, imagen.shape[1] - k + 1
salida = np.zeros((alto, ancho))
for i in range(alto):
for j in range(ancho):
salida[i, j] = np.sum(imagen[i:i + k, j:j + k] * nucleo)
return salida
nucleo = np.array([[-1.0, 1.0], [-1.0, 1.0]]) # 4 pesos: borde oscuro -> claro
img = np.zeros((8, 8)); img[:, 4:] = 1.0 # borde entre columnas 3 y 4
img_desplazada = np.zeros((8, 8)); img_desplazada[:, 6:] = 1.0 # dos columnas a la derecha
r1 = convolucion(img, nucleo)
r2 = convolucion(img_desplazada, nucleo)
assert np.argmax(r1[0]) == 3 and np.argmax(r2[0]) == 5 # la respuesta se desplaza
assert np.array_equal(r1[:, :5], r2[:, 2:]) # y tiene la misma forma
assert nucleo.size == 4 # el filtro tiene 4 pesos
print("Convolución: invarianza a la traslación comprobada")
El filtro tiene 4 pesos. Una capa densa que conectara la misma imagen de 8×8 (64 entradas) con una salida de 7×7 (49 valores) tendría 64 × 49 = 3136 pesos, sin contar sesgos. Ese es el ahorro de escala que describe D2L.
El precio es el reverso de la ventaja: las características son invariantes a la traslación y cada activación solo incorpora información local. Si en tu problema la posición absoluta importa, esa suposición juega en contra. Para el contexto histórico de por qué estas redes despegaron, tienes el artículo sobre el despegue del deep learning.
Red recurrente y LSTM: un estado que recorre la secuencia
Con una secuencia (una frase, una serie temporal) el orden importa y la longitud varía. Una red recurrente guarda un estado oculto ht−1 que resume lo visto hasta el paso t−1, y lo actualiza con ht = f(xt, ht−1). Según D2L, así se aproxima P(xt | xt−1, …, x1) por P(xt | ht−1).
Pieza a pieza: en cada paso se concatenan la entrada actual y el estado previo, y se pasan por una capa totalmente conectada con función de activación. Los parámetros (Wxh, Whh y el sesgo bh) son los mismos en todos los pasos. Por eso el orden queda en la estructura y una secuencia más larga no añade parámetros.
Una recurrente simple tiene memoria corta en la práctica. La LSTM (memoria a corto y largo plazo) añade puertas de entrada, olvido y salida: tres capas totalmente conectadas con sigmoide, con valores en (0, 1), que controlan cuándo se actualiza y cuándo se reinicia el estado. Esos mecanismos también se aprenden (D2L, sección 10.1). Las ecuaciones, según la documentación de PyTorch, son ct = ft ⊙ ct−1 + it ⊙ gt y ht = ot ⊙ tanh(ct); por eso h queda siempre en (−1, 1).
import torch
from torch import nn
torch.manual_seed(0)
rnn = nn.LSTM(10, 20, 2) # 10 entradas, estado de 20, 2 capas
entrada = torch.randn(5, 3, 10) # (pasos, lote, características)
h0 = torch.randn(2, 3, 20)
c0 = torch.randn(2, 3, 20)
salida, (hn, cn) = rnn(entrada, (h0, c0))
assert salida.shape == (5, 3, 20)
assert hn.shape == (2, 3, 20) and cn.shape == (2, 3, 20)
assert salida.abs().max() <= 1.0 # h = o * tanh(c) está en (-1, 1)
# El último paso de la última capa coincide con el estado final h_n
assert torch.allclose(salida[-1], hn[-1], atol=1e-6)
print("LSTM: formas y rango comprobados")
Fíjate en que los cinco pasos se calculan uno tras otro: cada paso necesita el estado del anterior. Esa dependencia secuencial dificulta paralelizar el cálculo, y es una de las razones que dan los autores del Transformer para proponer otra cosa.
Transformer: atención en lugar de recurrencia
En junio de 2017, Vaswani y colaboradores propusieron en «Attention Is All You Need» una arquitectura basada solo en mecanismos de atención, sin recurrencia ni convoluciones. Partían de que los modelos dominantes de transducción de secuencias eran redes recurrentes o convolucionales en configuración codificador-decodificador. La atención establece dependencias globales entre posiciones y, según los autores, permite una paralelización considerablemente mayor (versión de NeurIPS 2017).
Una pieza que puedes mirar: el codificador es una pila de 6 capas idénticas, cada una con dos subcapas, atención multicabeza sobre sí misma (autoatención) y una red totalmente conectada aplicada posición a posición. En la autoatención, cada posición calcula cuánto peso da a todas las demás; no hay un estado que viaje paso a paso.
La capa nn.MultiheadAttention implementa la arquitectura original y su documentación la presenta como implementación de referencia para la comprensión básica, con funciones limitadas frente a arquitecturas más nuevas: sirve para aprender, no es un modelo de producción. embed_dim se reparte entre num_heads (cada cabeza trabaja con embed_dim // num_heads). Con batch_first=True, la entrada tiene forma (N, L, E): lote, longitud de secuencia y dimensión. En attn_mask, un True indica que esa posición no puede ser atendida.
import torch
from torch import nn
torch.manual_seed(0)
N, L, E = 2, 5, 16
atencion = nn.MultiheadAttention(E, num_heads=4, batch_first=True)
x = torch.randn(N, L, E)
salida, pesos = atencion(x, x, x) # query = key = value
assert salida.shape == (N, L, E)
# Cada fila de pesos reparte la atención: suma 1
assert torch.allclose(pesos.sum(dim=-1), torch.ones(N, L), atol=1e-5)
# Máscara: nadie puede atender a la última posición
mascara = torch.zeros(L, L, dtype=torch.bool)
mascara[:, -1] = True
_, pesos_m = atencion(x, x, x, attn_mask=mascara)
assert torch.all(pesos_m[:, :, -1] == 0)
print("Atención: formas, filas que suman 1 y máscara comprobadas")
Con la máscara, la última posición recibe peso 0 en todas las filas y el resto se reparte entre las demás, que siguen sumando 1.
Sobre resultados, esto es lo que afirman los autores en la versión de arXiv del paper, sin contraste independiente en las fuentes consultadas: 28,4 BLEU en traducción inglés-alemán de WMT 2014, más de 2 BLEU por encima de los mejores resultados anteriores, y 41,8 BLEU en inglés-francés con un solo modelo tras 3,5 días de entrenamiento en ocho GPU. BLEU es una puntuación que compara la traducción automática con traducciones humanas de referencia; sirve para comparar sistemas bajo las mismas condiciones, no es un veredicto definitivo de calidad.
Mapa para elegir y errores de enfoque
| Red | Suposición incorporada | Dónde encaja | Precio de la suposición |
|---|---|---|---|
| Densa | Ninguna | Vectores de características sin estructura espacial ni temporal | Con imágenes, miles de millones de parámetros potenciales |
| Convolucional | Localidad e invarianza a la traslación | Imágenes | Cada activación solo ve información local |
| Recurrente / LSTM | Un estado resume el pasado | Secuencias | Cálculo paso a paso, difícil de paralelizar |
| Transformer | Cualquier posición puede atender a otra | Secuencias y texto | Las fuentes consultadas no detallan su coste de memoria o cómputo |
Las fuentes consultadas tampoco hacen una comparación empírica entre arquitecturas, así que no afirmo cifras sobre cuál rinde más en cada tarea.
Dónde se rompe
- Densa con imágenes grandes: el número de parámetros se dispara y ignoras la estructura que ya tienes.
- Esperar sensibilidad a la posición de una convolucional: si dónde aparece algo importa, la invarianza a la traslación no te ayuda sola.
- Olvidar que una LSTM va paso a paso: secuencias largas significan cálculo secuencial largo.
- Confundir la capa de referencia con un modelo completo:
nn.MultiheadAttentiones una pieza para entender, no un Transformer entrenado.
Una opinión, marcada como tal: antes de elegir arquitectura, revisa tus datos. En la mayoría de los problemas reales pesan más que la arquitectura, y un modelo que acierta en entrenamiento y falla en test ha memorizado, sea del tipo que sea. Si te ocurre, este artículo sobre sobreajuste te dice cómo detectarlo.
Para practicar
Toma los cuatro ejemplos y cambia un tamaño cada vez: el núcleo de la convolución a 3×3, el hidden_size de la LSTM o el num_heads de la atención (debe dividir a E). Antes de ejecutar, escribe en un assert cómo crees que cambia la forma de salida y comprueba si acertaste.
Ejercicio opcional: cuenta los parámetros de un nn.Linear y de una convolución sobre la misma entrada y compara la escala, como hicimos con 4 frente a 3136.
Para seguir leyendo, el artículo de Kia sobre el despegue del deep learning en los años 2010 da el contexto de por qué las redes profundas se hicieron prácticas; no trata los transformers, así que para ellos el paper original enlazado arriba es el mejor punto de partida. Y si necesitas repasar neuronas, pérdida y descenso de gradiente, vuelve a Cómo funcionan las redes neuronales.
Fuentes
- Attention Is All You Need (arXiv:1706.03762)
- Attention is All you Need (NeurIPS 2017, PDF)
- 7.1. From Fully Connected Layers to Convolutions — Dive into Deep Learning 1.0.3
- 9.4. Recurrent Neural Networks — Dive into Deep Learning 1.0.3
- 10.1. Long Short-Term Memory (LSTM) — Dive into Deep Learning 1.0.3
- LSTM — documentación de PyTorch
- MultiheadAttention — documentación de PyTorch
- Linear — documentación de PyTorch 2.15