Attention Is All You Need: análisis técnico del paper que cambió el NLP

El paper y las cifras que importan leer bien

Existe una discrepancia documentada entre la página de resumen de NeurIPS y el PDF completo del paper. La abstract page cita 27.5 BLEU / 41.1 BLEU y un modelo de 165M parámetros. El PDF final y la ficha oficial de Google Research reportan 28.4 BLEU / 41.0 BLEU, con configuraciones base de 65M y big de 213M parámetros.

Este análisis toma como referencia autoritativa el PDF completo y la ficha oficial, que son las fuentes que contienen las tablas de ablación y la configuración definitiva del modelo.

Arquitectura del Transformer: componentes y ecuaciones

El paper propone un encoder-decoder clásico construido con bloques homogéneos. El encoder usa una pila de 6 capas; cada capa contiene multi-head self-attention y una feed-forward network por posición. El decoder añade una tercera subcapa de atención encoder-decoder y enmascara la self-attention para preservar la propiedad autoregresiva.

El modelo base trabaja con d_model = 512, 8 cabezas y d_ff = 2048. El modelo grande opera con d_model = 1024, 16 cabezas y d_ff = 4096. Ambos usan conexiones residuales y normalización de capa alrededor de cada subcapa.

Por qué funcionan estos componentes

El término √d_k estabiliza el dot-product attention cuando la dimensión de claves crece. La multi-cabeza permite atender a subespacios distintos en paralelo. La FFN introduce capacidad no lineal por token. La codificación posicional sinusoidal inyecta orden sin recurrir a recurrencia.

Una capa de self-attention tiene complejidad por capa O(n²·d), pero solo O(1) operaciones secuenciales y longitud máxima de camino O(1) entre posiciones. Las redes recurrentes requieren O(n) operaciones secuenciales y caminos más largos para dependencias lejanas.

Datos, entrenamiento y coste computacional

Para En→De, el paper usa WMT14 con unas 4.5M parejas de frases y BPE compartido de ~37k tokens. Para En→Fr, usa 36M frases con un vocabulario de 32k word-pieces. Cada batch contiene aproximadamente 25k tokens de origen y 25k de destino.

El entrenamiento se realizó en 8 NVIDIA P100: el modelo base durante 100k pasos / 12 horas, y el grande durante 300k pasos / 3.5 días. El optimizador es Adam con β₁=0.9, β₂=0.98, ε=10⁻⁹, con learning-rate schedule de inversa de raíz cuadrada y 4000 warmup steps.

La regularización combina dropout, label smoothing = 0.1 y checkpoint averaging. En inferencia se usa beam size 4 y length penalty α = 0.6.

Resultados: qué dice y qué no dice el paper

En En→De, el Transformer-big supera a todos los modelos previos, incluidos los ensembles, con 28.4 BLEU. En En→Fr, el paper reporta 41.0 BLEU, que supera a los mejores modelos individuales, pero no al mejor ensemble previo (ConvS2S Ensemble, 41.29). En parsing inglés sobre WSJ, llega a 92.7 F1 en ajuste semisupervisado.

Ablaciones y reproducibilidad: lo más útil del paper

El estudio de variaciones sobre En→De dev (newstest2013) es la parte más valiosa del paper para lectura técnica moderna. Una sola cabeza cae a 24.9 BLEU frente a 25.8 de la configuración base. Demasiadas cabezas también perjudica: con 32 cabezas el resultado baja a 25.4.

La lectura práctica es clara: el diseño base tenía redundancia y márgenes de ajuste desde el principio. Trabajos posteriores confirmaron que gran parte de las cabezas pueden podarse con impacto mínimo, y que la eficiencia o la extrapolación longitudinal requerían mecanismos adicionales.

Recursos de reproducción recomendados

The Annotated Transformer (Harvard NLP) plantea el paper como un ejercicio explícito de replicación, con implementación legible que sigue de cerca el original. Training Tips for the Transformer Model muestra que variables como batch size, learning rate, warmup steps y checkpoint averaging afectan directamente a calidad final y estabilidad del entrenamiento.

Implementaciones disponibles y su estado real

Código de referencia en PyTorch

Este ejemplo usa los defaults del paper base y la API de referencia de PyTorch. Para que sea entrenable faltan el tokenizador, el dataloader, la pérdida con label smoothing y el bucle de entrenamiento.

import math
import torch
from torch import nn

class PositionalEncoding(nn.Module):
    def __init__(self, d_model: int, max_len: int = 4096):
        super().__init__()
        pe = torch.zeros(max_len, d_model)
        pos = torch.arange(0, max_len, dtype=torch.float32).unsqueeze(1)
        div = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float32)
                        * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(pos * div)
        pe[:, 1::2] = torch.cos(pos * div)
        self.register_buffer("pe", pe.unsqueeze(0))  # [1, L, D]

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return x + self.pe[:, :x.size(1)]

class MiniTransformer(nn.Module):
    def __init__(self, vocab_src: int, vocab_tgt: int, pad_id: int):
        super().__init__()
        self.d_model = 512
        self.pad_id  = pad_id
        self.src_emb = nn.Embedding(vocab_src, self.d_model, padding_idx=pad_id)
        self.tgt_emb = nn.Embedding(vocab_tgt, self.d_model, padding_idx=pad_id)
        self.pos     = PositionalEncoding(self.d_model)
        self.core    = nn.Transformer(
            d_model=512, nhead=8,
            num_encoder_layers=6, num_decoder_layers=6,
            dim_feedforward=2048, dropout=0.1, batch_first=True,
        )
        self.lm_head = nn.Linear(self.d_model, vocab_tgt)

    def forward(self, src_ids: torch.Tensor, tgt_ids: torch.Tensor) -> torch.Tensor:
        src_key_padding_mask = src_ids.eq(self.pad_id)
        tgt_key_padding_mask = tgt_ids.eq(self.pad_id)
        src = self.pos(self.src_emb(src_ids) * math.sqrt(self.d_model))
        tgt = self.pos(self.tgt_emb(tgt_ids) * math.sqrt(self.d_model))
        tgt_mask = nn.Transformer.generate_square_subsequent_mask(
            tgt.size(1), device=tgt.device
        )
        hidden = self.core(
            src=src, tgt=tgt, tgt_mask=tgt_mask,
            src_key_padding_mask=src_key_padding_mask,
            tgt_key_padding_mask=tgt_key_padding_mask,
            memory_key_padding_mask=src_key_padding_mask,
        )
        return self.lm_head(hidden)

Guía de implementación reproducible

1. Elegir un dataset pequeño y medible

   IWSLT14 De→En o un subconjunto de OPUS Books En→Fr. Verifica que tienes train/valid/test separados y una métrica reproducible como SacreBLEU.

2. Fijar tokenización antes del modelo

   BPE o SentencePiece con vocabulario conjunto. Comprueba que el OOV es bajo y la longitud media de secuencia es estable.

3. Arrancar con el modelo base del paper

   6 capas, d_model=512, 8 cabezas, d_ff=2048, dropout 0.1, label smoothing 0.1. Verifica que el número de parámetros cuadra con una implementación de referencia.

4. Respetar la receta de optimización

   Adam (0.9, 0.98), inverse-sqrt schedule y 4000 warmup steps. La curva de pérdida no debe explotar al inicio.

5. Evaluar con protocolo fijo

   Beam search, length penalty y SacreBLEU con el mismo comando cada vez. El score debe ser regenerable de forma exacta.

6. Optimizar el serving después, no antes

   Convierte a un runtime de inferencia como CTranslate2. Compara BLEU y tokens/s antes y después con el mismo modelo y conjunto de prueba.

Impacto científico: citas positivas y críticas

La huella del paper es inmensa pero no uniforme. Hay trabajos que lo citan para extenderlo y trabajos que lo citan para corregirlo.

Limitaciones técnicas e implicaciones para negocio y SEO/GEO

Las limitaciones del paper original siguen siendo las del Transformer vanilla: atención cuadrática con la longitud, extrapolación débil a secuencias más largas de las vistas en entrenamiento, redundancia parcial en cabezas y decoder autoregresivo. Ninguna invalida el paper; explican por qué la historia posterior fue una historia de variantes de eficiencia.

En ética y seguridad, el paper casi no entra. No es un trabajo de alineamiento, sesgo ni evaluación de daño. Esa deuda la heredan sus descendientes. InstructGPT lo resume bien: hacer un modelo más grande no lo vuelve automáticamente mejor en seguir intenciones del usuario. El Transformer da la base computacional; el alineamiento llega después.

La implicación clave para búsqueda y contenido generativo

En 2019, Google explicó que BERT mejoraba la comprensión de 1 de cada 10 búsquedas en inglés en EE. UU., especialmente en consultas largas y conversacionales. Después, MUM se presentó como un sistema basado en T5, con ambición multimodal y multilingüe.

Para GEO, la consecuencia es directa: la recuperación y el ranking pasan a depender más de contexto, intención y cobertura semántica, no solo de coincidencia de keywords. RAG añade la capa de memoria no paramétrica que el diseño de 2017 no resolvía. ReAct añade la capacidad de actuar sobre fuentes externas para reducir alucinaciones.