Arquitectura Transformer explicada: atención, encoder, decoder y LLM

Ilustración técnica para: Introducción a la Arquitectura Transformer: Fundamentos y Funcionamiento Interno

Un Transformer es una arquitectura de red neuronal para procesar secuencias que sustituye la recurrencia por atención: cada token calcula cuánto debe fijarse en cada uno de los demás y construye su nueva representación como una media ponderada de ellos. Se presentó en 2017 en el artículo «Attention Is All You Need» (Vaswani et al.), pensado para traducción automática, y es la base de BERT, de la familia GPT y de Llama. También se aplica fuera del texto: ViT, por ejemplo, aplica un Transformer directamente a secuencias de parches de imagen (Dosovitskiy et al., 2020).

Esta guía recorre las piezas en el orden en que las atraviesa un token: embeddings y posición, atención (con un ejemplo calculado), multi-head, el bloque completo con residuales y normalización, encoder y decoder, y por qué los LLM generativos más conocidos usan solo el decoder. Las cifras de arquitectura salen del paper original salvo que se cite otra fuente.

Qué problema resolvía

En 2017, los mejores modelos de traducción eran redes recurrentes (RNN, LSTM) o convolucionales en configuración encoder-decoder, normalmente con un mecanismo de atención añadido. Una red recurrente procesa la frase token a token: el estado de la posición t depende del de la posición t−1, así que dentro de una secuencia el cálculo no se puede paralelizar, y la información entre dos palabras lejanas tiene que atravesar todos los pasos intermedios.

El Transformer prescinde de recurrencia y convoluciones y se queda solo con atención. La tabla 1 del paper compara los tipos de capa (n = longitud de la secuencia, d = dimensión de la representación, k = tamaño del kernel):

Tipo de capaCoste por capaOperaciones secuencialesCamino máximo entre dos posiciones
Self-attentionO(n2·d)O(1)O(1)
RecurrenteO(n·d2)O(n)O(n)
ConvolucionalO(k·n·d2)O(1)O(logk(n))

Con esta arquitectura, el paper obtuvo 28,4 BLEU en la traducción inglés-alemán de WMT 2014 y 41,8 BLEU en inglés-francés, este último tras 3,5 días de entrenamiento en ocho GPU P100.

Paso 1: de tokens a vectores con posición

El texto se divide en tokens (palabras o fragmentos de palabra) y cada token se convierte en un vector de dimensión dmodel mediante una tabla de embeddings aprendida. En el modelo base del paper, dmodel = 512. Las dos capas de embedding (entrada y salida) comparten la matriz de pesos con la proyección lineal previa al softmax final, y en las capas de embedding esos pesos se multiplican por √dmodel.

La atención, por sí sola, no sabe en qué orden están los tokens: si se permutan las entradas, las salidas salen permutadas de la misma forma. Por eso se suma a cada embedding una codificación posicional (positional encoding), en la base de las dos pilas: la del encoder y la del decoder. El paper usa senos y cosenos de distintas frecuencias, donde pos es la posición e i recorre los pares de dimensiones:

PE(pos, 2i) = sin(pos / 100002i/dmodel)
PE(pos, 2i+1) = cos(pos / 100002i/dmodel)

Con dmodel = 4 solo hay dos pares (i = 0 e i = 1), cuyos divisores son 100000 = 1 y 100000,5 = 100. Las tres primeras posiciones quedan así:

possin(pos)cos(pos)sin(pos/100)cos(pos/100)
00101
10,84150,54030,01000,99995
20,9093−0,41610,02000,9998

Las primeras dimensiones cambian deprisa con la posición y las últimas despacio, de modo que cada posición recibe un patrón distinto. Los autores probaron también embeddings posicionales aprendidos y obtuvieron resultados casi idénticos; eligieron la versión sinusoidal porque podría permitir extrapolar a secuencias más largas que las vistas en entrenamiento. Esta es una de las piezas que más ha cambiado después: GPT-1 usó posiciones aprendidas y Llama elimina las posiciones absolutas y aplica RoPE (rotary position embeddings, Su et al., 2021) en cada capa.

import math
import torch

def positional_encoding(seq_len, d_model):
    # d_model debe ser par: las columnas pares llevan seno y las impares coseno
    pe = torch.zeros(seq_len, d_model)
    pos = torch.arange(seq_len, dtype=torch.float32).unsqueeze(1)    # (seq_len, 1)
    div = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float32)
                    * (-math.log(10000.0) / d_model))               # 1 / 10000^(2i/d_model)
    pe[:, 0::2] = torch.sin(pos * div)
    pe[:, 1::2] = torch.cos(pos * div)
    return pe

# positional_encoding(3, 4) reproduce la tabla anterior.
# Entrada al modelo: x = embedding(tokens) * math.sqrt(d_model) + positional_encoding(n, d_model)

Paso 2: la atención (scaled dot-product attention)

Para cada token se calculan tres vectores multiplicando su representación por tres matrices aprendidas, WQ, WK y WV:

  • Query (q): lo que este token busca en los demás.
  • Key (k): lo que este token ofrece para ser encontrado.
  • Value (v): la información que aporta a quien le preste atención.

Apilando los vectores de todos los tokens en las matrices Q, K y V, la atención del paper es:

Attention(Q, K, V) = softmax(QKT / √dk) V

Leída por partes: el producto escalar entre la query de un token y la key de otro mide su afinidad; el softmax convierte cada fila de afinidades en pesos positivos que suman 1; la salida de cada token es la suma de los values ponderada por esos pesos. dk es la dimensión de queries y keys.

Por qué se divide entre √dk

Si las componentes de q y k son independientes, con media 0 y varianza 1, su producto escalar es una suma de dk términos de varianza 1: tiene media 0 y varianza dk. Con dk = 64, la desviación típica es 8, así que las afinidades salen grandes, el softmax se concentra casi entero en un solo token y sus gradientes se vuelven muy pequeños. Dividir entre √64 = 8 devuelve la desviación típica a 1. Es el argumento de la sección 3.2.1 del paper.

Ejemplo numérico paso a paso

Tres tokens y dk = 2. Supón que las proyecciones con WQ, WK y WV ya han dado estos vectores:

Tokenqkv
1(1, 0)(1, 0)(1, 0)
2(0, 1)(1, 1)(0, 1)
3(1, 1)(0, 1)(1, 1)
  1. Afinidades QKT (fila = token que pregunta, columna = token consultado). Para el token 3, q = (1, 1): con k1 da 1, con k2 da 2 y con k3 da 1. Las tres filas completas son (1, 1, 0), (0, 1, 1) y (1, 2, 1).
  2. Escalado entre √2 ≈ 1,4142. La fila 3 queda en (0,7071; 1,4142; 0,7071).
  3. Softmax de la fila 3: e0,7071 ≈ 2,0281 y e1,4142 ≈ 4,1133; la suma es 8,1695, y los pesos son (0,248; 0,503; 0,248).
  4. Media ponderada de los values: 0,248·(1, 0) + 0,503·(0, 1) + 0,248·(1, 1) ≈ (0,50; 0,75).

Haciendo lo mismo con las tres filas:

TokenPesos sobre tokens 1, 2, 3Salida
10,401; 0,401; 0,198(0,60; 0,60)
20,198; 0,401; 0,401(0,60; 0,80)
30,248; 0,503; 0,248(0,50; 0,75)

Cada salida mezcla información de toda la secuencia, con más peso donde la afinidad es mayor, y nada del cálculo es secuencial: las tres filas salen a la vez de dos productos de matrices y un softmax.

La máscara causal

Cuando el modelo genera texto, un token no puede mirar los que vienen después. Para impedirlo, antes del softmax se ponen a −∞ las afinidades con posiciones posteriores, y su peso queda en 0. En el ejemplo, el token 1 solo se ve a sí mismo (peso 1, salida (1, 0)); el token 2 aplica softmax a (0; 0,7071) y obtiene pesos (0,330; 0,670) y salida (0,33; 0,67); el token 3 no cambia, porque ya era el último.

Paso 3: multi-head attention

En lugar de una sola atención sobre vectores de 512 dimensiones, el Transformer proyecta Q, K y V h veces con matrices distintas, calcula h atenciones en paralelo y concatena los resultados:

MultiHead(Q, K, V) = Concat(head1, …, headh) WO
headi = Attention(QWiQ, KWiK, VWiV)

En el modelo base, h = 8 y cada cabeza trabaja con dk = dv = 512 / 8 = 64. Como cada cabeza tiene dimensión reducida, el coste total es parecido al de una única atención con la dimensión completa. La justificación del paper: varias cabezas permiten atender a la vez a información de distintos subespacios de representación en distintas posiciones, algo que con una sola cabeza impide el promediado.

Los tres usos de la atención en el modelo original

DóndeQueries deKeys y values deQué ve cada posición
Self-attention del encoderla capa anterior del encoderla capa anterior del encodertoda la entrada
Self-attention del decoderla capa anterior del decoderla capa anterior del decodersolo posiciones anteriores y la propia (máscara causal)
Atención encoder-decoder (cross-attention)la capa anterior del decoderla salida del encodertodas las posiciones de la entrada

Paso 4: el bloque completo (residuales, LayerNorm y feed-forward)

Cada subcapa, sea atención o feed-forward, va envuelta en una conexión residual seguida de normalización de capa: la salida es LayerNorm(x + Subcapa(x)). Durante el entrenamiento se aplica dropout a la salida de cada subcapa antes de sumarla. La red feed-forward se aplica a cada posición por separado y con los mismos pesos en todas:

FFN(x) = max(0, xW1 + b1) W2 + b2

Son dos capas lineales con ReLU en medio, que en el modelo base pasan de 512 a 2048 dimensiones y vuelven a 512. La activación es ReLU en el paper; modelos posteriores la cambiaron (GPT-1 usó GELU y Llama usa SwiGLU). Una capa del encoder tal como la describe el paper, con la normalización después de cada subcapa (post-LN), queda así:

import torch.nn as nn

class EncoderLayer(nn.Module):
    # Post-LN, como en el paper de 2017
    def __init__(self, d_model=512, num_heads=8, d_ff=2048, dropout=0.1):
        super().__init__()
        self.attn = MultiHeadAttention(d_model, num_heads)  # definida más abajo
        self.ff = nn.Sequential(nn.Linear(d_model, d_ff), nn.ReLU(), nn.Linear(d_ff, d_model))
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.drop = nn.Dropout(dropout)

    def forward(self, x):
        x = self.norm1(x + self.drop(self.attn(x)))
        x = self.norm2(x + self.drop(self.ff(x)))
        return x

Muchos modelos posteriores mueven la normalización al principio de cada subcapa (pre-LN): x + Subcapa(LayerNorm(x)). Xiong et al. (2020) muestran que con post-LN los gradientes cerca de la salida son grandes al inicializar, lo que obliga a calentar el learning rate (warm-up), y que con pre-LN se alcanzan resultados comparables sin esa fase. Llama normaliza la entrada de cada subcapa con RMSNorm. En PyTorch, nn.TransformerEncoderLayer implementa la arquitectura original (ReLU y dff = 2048 por defecto) y norm_first=True la convierte en pre-LN.

Paso 5: encoder, decoder y generación

El modelo original apila N = 6 capas idénticas en el encoder y otras 6 en el decoder.

  • Encoder: cada capa tiene self-attention sin máscara y una FFN. Convierte la frase de entrada en una secuencia de vectores contextuales, uno por token.
  • Decoder: cada capa tiene self-attention con máscara causal, atención encoder-decoder sobre la salida del encoder y una FFN. Encima de la última capa, una proyección lineal y un softmax dan la probabilidad de cada token del vocabulario como siguiente token.

En inferencia, el modelo es autorregresivo: genera un token, lo añade a su entrada y vuelve a ejecutarse para el siguiente. En una traducción, el encoder procesa la frase origen una sola vez, y el decoder parte de un símbolo de inicio y produce la traducción token a token, consultando en cada paso la salida del encoder.

En entrenamiento, la frase objetivo completa ya se conoce. Se pasa al decoder desplazada una posición a la derecha y, junto con la máscara causal, eso garantiza que la predicción de la posición i solo dependa de las posiciones anteriores. Así todas las posiciones se entrenan a la vez en una sola pasada. El paralelismo que el Transformer gana frente a una RNN está en el entrenamiento y en el procesamiento de la entrada; la generación sigue siendo token a token.

La máscara causal también abarata esa generación: como un token nunca atiende a los posteriores, las keys y values de los tokens ya procesados no cambian al añadir uno nuevo. Las bibliotecas los guardan en una caché por capa (la KV cache) y en cada paso solo calculan los del token nuevo.

Encoder-only, decoder-only y encoder-decoder

Después de 2017 la arquitectura se dividió en tres familias según qué partes conservan:

VarianteQué conservaAtenciónEjemplo publicadoPara qué se diseñó
Encoder-onlysolo el encoderbidireccional: cada token ve a izquierda y derechaBERT (Devlin et al., 2018)representaciones de texto que se ajustan a tareas como clasificación o extracción de respuestas
Encoder-decoderencoder y decoderbidireccional en la entrada, causal en la salidaTransformer original; T5 (Raffel et al., 2019); Flan-UL2transformar una secuencia en otra; T5 plantea toda tarea de lenguaje como texto a texto
Decoder-onlysolo el decoder, sin atención encoder-decodercausalGPT-1 (Radford et al., 2018); Llama (Touvron et al., 2023)modelar el lenguaje prediciendo el siguiente token

Por qué los LLM generativos más conocidos son decoder-only

Los LLM generativos más conocidos con arquitectura publicada siguen este esquema: GPT-1 es un Transformer de 12 capas solo decoder, con atención enmascarada, y Llama usa atención causal entrenada como modelo de lenguaje. No es el único esquema para generar texto: también hay modelos generativos encoder-decoder, como T5 o Flan-UL2, que Google publica como un modelo encoder-decoder basado en la arquitectura T5 y que genera texto con generate(). De muchos modelos comerciales no se publica la arquitectura; el informe técnico de GPT-4, por ejemplo, solo dice que es un modelo basado en Transformer preentrenado para predecir el siguiente token y declara que no da más detalles de arquitectura. Las razones que sí están documentadas son estas:

  • Un objetivo de entrenamiento simple y sin etiquetas. Predecir el siguiente token solo necesita texto. GPT-1 se preentrenó así y después se ajustó a cada tarea.
  • Una sola secuencia en lugar de dos pilas. Liu et al. (2018) quitaron el encoder, unieron entrada y salida en una única secuencia y entrenaron el modelo como un modelo de lenguaje estándar, lo que casi reduce a la mitad los parámetros para la misma configuración. En un chat ocurre lo mismo: instrucción y respuesta forman una secuencia que el modelo continúa.
  • Buena generalización sin ejemplos tras el preentrenamiento. Wang et al. (2022) compararon arquitecturas y objetivos: los modelos decoder-only causales entrenados como modelo de lenguaje fueron los que mejor generalizaron zero-shot tras un preentrenamiento sin supervisión.

Eso no convierte al decoder-only en mejor en todo. En el mismo estudio de Wang et al., tras un ajuste multitarea ganaron los modelos con visibilidad no causal sobre la entrada entrenados con modelado de lenguaje enmascarado, y en la comparación de T5 el encoder-decoder con objetivo de eliminación de ruido fue el mejor en todas las tareas. La elección depende del objetivo de entrenamiento y del uso.

Qué ha cambiado desde 2017

PiezaPaper original (2017)Variantes posteriores documentadas
NormalizaciónLayerNorm después de cada subcapa (post-LN)normalización antes de cada subcapa (pre-LN); RMSNorm en Llama
Activación de la FFNReLUGELU en GPT-1; SwiGLU en Llama
Posiciónsinusoidal absoluta, sumada a la entradaaprendida en GPT-1; RoPE aplicada en cada capa en Llama
Estructuraencoder-decoderdecoder-only en los LLM generativos más conocidos (GPT, Llama); los encoder-decoder siguen en uso (T5, Flan-UL2)

El núcleo (atención con escalado, varias cabezas, residuales y FFN por posición) se mantiene. Para variantes más profundas, como mixture-of-experts, está la guía de LLM con MoE y modelos multimodales.

Ventajas y límites

  • Entrenamiento paralelo: una capa de self-attention necesita O(1) operaciones secuenciales frente a las O(n) de una capa recurrente.
  • Dependencias lejanas: cualquier par de posiciones está conectado en un solo paso (camino O(1)), frente a O(n) en una RNN. Eso facilita aprender relaciones lejanas, pero no elimina todos los problemas con secuencias largas.
  • Coste cuadrático: la matriz de atención tiene n × n entradas por cabeza y por capa, así que duplicar la longitud de la secuencia cuadruplica su tamaño. El paper señala que la self-attention es más rápida que una capa recurrente cuando n es menor que d, y propone restringir la atención a un vecindario de tamaño r para secuencias muy largas.
  • Generación secuencial: el entrenamiento se paraleliza, pero la inferencia autorregresiva produce un token por paso.
  • Sin noción propia del orden: depende de la codificación posicional.

Código: multi-head attention en PyTorch

Implementación directa de las fórmulas anteriores, con máscara causal opcional y soporte de cross-attention:

import math
import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        assert d_model % num_heads == 0, "d_model debe ser divisible por num_heads"
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        self.w_q = nn.Linear(d_model, d_model)
        self.w_k = nn.Linear(d_model, d_model)
        self.w_v = nn.Linear(d_model, d_model)
        self.w_o = nn.Linear(d_model, d_model)

    def _split_heads(self, x):
        # (batch, seq, d_model) -> (batch, heads, seq, d_k)
        batch, seq, _ = x.shape
        return x.view(batch, seq, self.num_heads, self.d_k).transpose(1, 2)

    def forward(self, x_q, x_kv=None, causal=False):
        # Self-attention si x_kv es None; cross-attention si x_kv es la salida del encoder
        if x_kv is None:
            x_kv = x_q
        q = self._split_heads(self.w_q(x_q))
        k = self._split_heads(self.w_k(x_kv))
        v = self._split_heads(self.w_v(x_kv))

        scores = q @ k.transpose(-2, -1) / math.sqrt(self.d_k)   # (batch, heads, L, S)
        if causal:
            L, S = scores.shape[-2:]
            future = torch.triu(torch.ones(L, S, dtype=torch.bool, device=scores.device), diagonal=1)
            scores = scores.masked_fill(future, float("-inf"))
        weights = scores.softmax(dim=-1)
        context = weights @ v                                      # (batch, heads, L, d_k)

        batch, _, L, _ = context.shape
        context = context.transpose(1, 2).reshape(batch, L, self.num_heads * self.d_k)
        return self.w_o(context)

mha = MultiHeadAttention(d_model=512, num_heads=8)
x = torch.randn(2, 10, 512)      # batch de 2 secuencias de 10 tokens
y = mha(x, causal=True)
print(y.shape)                   # torch.Size([2, 10, 512])

En código real, el bloque que calcula scores, aplica la máscara y el softmax y obtiene context se sustituye por torch.nn.functional.scaled_dot_product_attention(q, k, v, is_causal=causal), que calcula lo mismo y puede usar implementaciones optimizadas. Para cargar modelos ya entrenados, el paso habitual es la librería Transformers de Hugging Face.

Preguntas frecuentes

¿Qué significa «Attention Is All You Need»?

Es el título del artículo de 2017 de Vaswani et al. que presentó el Transformer. Resume su tesis: un modelo de traducción basado solo en mecanismos de atención, sin recurrencia ni convoluciones, superó a los anteriores en calidad (28,4 BLEU en inglés-alemán de WMT 2014) con un entrenamiento más paralelizable.

¿Qué diferencia hay entre self-attention y cross-attention?

En self-attention, queries, keys y values salen de la misma secuencia, así que cada token atiende a los demás tokens de su propia secuencia. En cross-attention (la atención encoder-decoder del paper), las queries salen del decoder y las keys y values de la salida del encoder, de modo que cada posición del decoder puede consultar toda la frase de entrada.

¿Por qué se divide entre la raíz cuadrada de d_k?

Porque el producto escalar de dos vectores con componentes independientes de media 0 y varianza 1 tiene varianza dk. Sin escalar, con dk grande los valores son tan grandes que el softmax se satura y sus gradientes se vuelven muy pequeños; dividir entre √dk devuelve la varianza a 1.

¿Los modelos GPT son Transformers?

Sí. GPT-1 se describe en su paper como un Transformer de 12 capas solo decoder con atención enmascarada, y el informe técnico de GPT-4 lo define como un modelo basado en Transformer preentrenado para predecir el siguiente token, aunque no publica más detalles de su arquitectura.

¿Es lo mismo un Transformer que la librería Transformers de Hugging Face?

No. El Transformer es la arquitectura descrita en el paper de 2017; Transformers de Hugging Face es una librería de Python que implementa y distribuye modelos basados en esa arquitectura (BERT, T5, Llama y muchos otros) para cargarlos y usarlos con pocas líneas de código.

Fuentes

Compartir

X LinkedIn
Volver al blog