Conexiones residuales explicadas: por qué los transformers profundos se pueden entrenar
Por qué apilar capas sin más rompe el entrenamiento, cómo las conexiones de salto x + F(x) arreglan el flujo de gradientes, cómo las usan los bloques Pre-LayerNorm y una implementación breve en PyTorch.
Si apilas docenas de capas sin más, el entrenamiento se vuelve inestable. Las conexiones residuales, también llamadas atajos, lo resuelven al permitir que tanto la información como los gradientes atraviesen la red directamente.
Por qué falla apilar sin más
A estas alturas, un bloque transformer tiene tres partes: autoatención multicabeza, normalización de capa y una red feed-forward. Es tentador repetirlas una detrás de otra:
Input
│
▼
Attention
│
▼
Feed Forward
│
▼
Attention
│
▼
Feed Forward
│
▼
...
Eso no entrena bien. Cuanto más profunda es una red, más difícil resulta optimizarla, y fue uno de los mayores obstáculos del deep learning hasta que llegaron las conexiones residuales con ResNet en 2015. Casi todos los transformers actuales, incluidos GPT, BERT, LLaMA, Claude y Gemini, dependen de ellas.
Empecemos con una red de dos capas:
Input ↓Layer 1 ↓Layer 2 ↓Output
Entrenarla suele ser sencillo. Ahora imagina 96 capas:
Input↓Layer 1↓Layer 2↓...↓Layer 96↓Output
Cada capa transforma la salida de la anterior. Durante la retropropagación, el gradiente tiene que volver atrás pasando por cada capa, y en el camino puede encogerse hasta casi nada (desvanecimiento), crecer sin límite (explosión) o volverse cada vez más ruidoso. Al final, las primeras capas apenas aprenden.
El teléfono escacharrado
Piensa en un mensaje que se susurra a lo largo de cincuenta personas:
Person 1↓Person 2↓Person 3↓...↓Person 50
Cuando llega al final, ha cambiado mucho. Faltan partes y otras están distorsionadas. Una red profunda se comporta de forma parecida, porque cada capa desplaza un poco la representación, y tras suficientes capas la señal útil puede desvanecerse.
Añadir un atajo
¿Y si los datos no tuvieran que pasar por cada capa y también pudieran rodearlas?
Input
│
├──────────────┐
▼ │
Layer │
▼ │
Output │
│ │
└────── Add ◄──┘
│
▼
Final Output
La entrada original tiene ahora siempre una vía directa hacia las capas posteriores, y ese pequeño cambio altera mucho el comportamiento de las redes profundas.
Las matemáticas
Supongamos que una capa calcula esto:
F(x)
Sin conexión residual, la salida es simplemente el resultado de la capa:
Output = F(x)
Con ella, la salida pasa a ser:
Output = x + F(x)
La entrada se suma directamente a la salida transformada. Esta operación se conoce como conexión de salto o conexión de atajo.
Por qué ayuda
Supongamos que una capa concreta no tiene nada útil que aportar. En una red simple tendría que aprender de algún modo a comportarse como una función identidad, y eso resulta ser difícil. Con una conexión residual, la identidad sale gratis. La capa solo necesita aprender:
F(x) = 0
de modo que:
Output = x + 0 = x
La entrada pasa intacta y la optimización se vuelve mucho más fácil.
Aprender la diferencia
De ahí viene el nombre. Una capa no tiene que aprender la transformación completa. Solo aprende la diferencia, el residuo, entre la entrada y la salida deseada. La edición de fotos es una buena comparación: rara vez repintas la imagen entera, la ajustas subiendo el brillo, el contraste o la nitidez de los bordes. Del mismo modo, una capa de transformer rara vez necesita sustituir toda la representación. Le basta con mejorarla un poco.
Dos atajos por bloque
Cada bloque transformer contiene dos conexiones residuales. La primera envuelve la capa de atención:
Input
│
├──────────────┐
▼ │
Multi-Head Attention
▼ │
Add ◄───────────┘
│
▼
Output
La segunda envuelve la red feed-forward:
Input
│
├──────────────┐
▼ │
Feed Forward Network
▼ │
Add ◄───────────┘
│
▼
Output
Pre-LayerNorm
Los modelos GPT actuales usan la disposición Pre-LayerNorm, que se calcula así:
Input
│
▼
LayerNorm
│
▼
Multi-Head Attention
│
▼
Add Residual
│
▼
LayerNorm
│
▼
Feed Forward Network
│
▼
Add Residual
│
▼
Output
Aquí LayerNorm se aplica antes de cada subcapa, no después, y esa disposición hace que el entrenamiento de transformers profundos sea notablemente más estable.
Flujo de gradientes
En la retropropagación, el gradiente tiene ahora dos rutas:
Gradient↓Transformer Layer↓Residual Path
Si la transformación principal resulta difícil de optimizar, el atajo sigue ofreciendo otro camino de vuelta, así que el gradiente no puede desaparecer del todo. En términos de cálculo, la derivada de
x + F(x)
es
1 + F'(x)
Esa constante 1 importa muchísimo. Aunque
F'(x)
se vuelva muy pequeño, el gradiente sigue teniendo una vía directa a través del enlace identidad. Es una de las principales razones por las que las redes residuales se entrenan con éxito.
Un ejemplo numérico
Supongamos que el embedding de entrada es:
[0.5, 1.2, -0.3]
y la atención devuelve:
[0.1, -0.2, 0.4]
En lugar de sustituir la entrada, se suman las dos:
[0.5, 1.2, -0.3] + [0.1, -0.2, 0.4] = [0.6, 1.0, 0.1]
La información original sobrevive mientras se le mezcla la nueva.
En PyTorch
En código no cuesta casi nada:
x = x + self.attention(
self.layer_norm1(x)
)
x = x + self.ffn(
self.layer_norm2(x)
)
Esa suma es una de las operaciones más importantes de toda la arquitectura.
Un bloque completo
Input
│
▼
LayerNorm
│
▼
Multi-Head Attention
│
▼
Add Residual
│
▼
LayerNorm
│
▼
Feed-Forward Network
│
▼
Add Residual
│
▼
Output
Los LLM modernos repiten esta estructura decenas o incluso cientos de veces.
Qué cambia con ellas y sin ellas
Sin conexiones residuales, las redes profundas son difíciles de optimizar, los gradientes se desvanecen con más facilidad, la información se va perdiendo poco a poco y añadir capas a menudo empeora los resultados. Con ellas, la información fluye directamente por la red, los gradientes se mantienen estables, los modelos más profundos se pueden entrenar y la optimización resulta mucho más sencilla. El aprendizaje residual es uno de los avances que hicieron posibles los grandes modelos de lenguaje actuales.