Transformers: Arquitectura, Atención, BERT y GPT

Visión general

Idea central: El Transformer (Vaswani et al., 2017) reemplaza las capas recurrentes y convolucionales de los modelos de secuencias con atención, permitiendo procesamiento paralelo y rutas cortas entre posiciones.

¿De dónde viene?

El Transformer nació para traducción automática neuronal. El reto: transformar una secuencia de palabras en otra preservando significado, orden, dependencias y contexto.

Los modelos previos (RNN/LSTM/GRU) procesaban tokens en secuencia. Esto limitaba la paralelización y creaba dificultades con dependencias de largo alcance.

El paper central: Vaswani et al. 2017 "Attention Is All You Need"

¿Qué resolvió?

Problema	Solución
Secuencialidad de RNNs	Cálculo paralelo por capa
Dependencias largas	Self-attention directo
Alineamiento flexible	Enc-dec attention
Falta de orden	Positional encoding
Capacidad limitada	Multi-head + FFN

Encoder (BERT-style)

Usa solo el encoder del Transformer. Atiende a todos los tokens bidireccionalmente.

Comprensión Clasificación, NER, QA

Decoder (GPT-style)

Usa solo el decoder con atención causal. Genera tokens de izquierda a derecha.

Generación Completado, traducción, chat

Encoder-Decoder (T5-style)

Arquitectura completa. El encoder procesa la entrada y el decoder genera la salida.

Secuencia-a-Secuencia Traducción, resumen

Arquitectura del Transformer

Haz clic en cualquier bloque del diagrama para ver qué información recibe, qué transforma y qué entrega a la siguiente capa.

Diagrama interactivo de flujo: encoder, decoder y memoria

El punto crítico es distinguir de dónde vienen Q, K y V. En self-attention los tres salen de la misma secuencia; en cross-attention, Q viene del decoder y K,V vienen de la memoria producida por el encoder.

Encoder: lee la entrada completa

Secuencia fuente

El gato negro corre

Todos los tokens entran en paralelo en cada capa del encoder.

K,V memoria del encoder hacia cross-attention

Decoder: genera la salida

Salida desplazada

<BOS> Le chat noir

Durante entrenamiento se desplaza un paso para no mirar el token objetivo actual.

1. El encoder construye memoria. Cada token de entrada termina como una representación contextual consultable.

2. El decoder mantiene causalidad. Su self-attention solo usa el prefijo ya visto o generado.

3. Cross-attention conecta ambos mundos. El decoder pregunta con Q; el encoder responde con K,V.

Selecciona un bloque para ver su descripción

El diagrama muestra el flujo de información por capa. Observa especialmente la ruta horizontal: la salida del encoder alimenta la cross-attention del decoder como memoria K,V.

Configuración base del paper original

Hiperparámetro	Valor base	Descripción
Capas encoder/decoder	`N = 6`	Número de bloques apilados
Dimensión del modelo	`d_model = 512`	Ancho de todas las representaciones
Cabezas de atención	`h = 8`	Atenciones paralelas
d_k = d_v	`64`	512 / 8 = 64 por cabeza
Dimensión FFN interna	`d_ff = 2048`	Capa oculta de la FFN
Dropout	`0.1`	Regularización

Mecanismos de Atención

Intuición

Al generar una palabra, no todas las palabras de entrada importan lo mismo. La atención aprende a asignar pesos a las posiciones relevantes.

Ejemplo: al traducir black cat → le chat noir, al generar noir el modelo debe atender principalmente a black, no a todas las palabras por igual.

Problema que resuelve: En RNNs, toda la oración se comprimía en un único vector de estado oculto. Eso creaba un cuello de botella. La atención permite al decoder consultar directamente todos los estados del encoder.

Cálculo básico (encoder-decoder attention)

Sea h₁, …, hₙ la secuencia de estados del encoder. En el paso t del decoder:

e_t,i = score(s_t, h_i)

α_t,i = exp(e_t,i) / Σⱼ exp(e_t,j)

c_t = Σᵢ α_t,i · h_i

Donde cₜ es el vector de contexto dinámico usado por el decoder en el paso t.

Scaled Dot-Product Attention — Paso a paso interactivo

Attention(Q, K, V) = softmax( QKᵀ / √d_k ) · V

Ejemplo con 3 tokens: gato negro corre — vectores de dimensión d_k = 2 para visualización.

Lectura del algoritmo: Q representa qué busca cada token; K representa contra qué se compara; QKᵀ produce scores de compatibilidad; softmax convierte cada fila en pesos que suman 1; V contiene la información que finalmente se mezcla con esos pesos.

Partimos con una matriz X de representaciones de tokens. La atención no usa X directamente: aprende tres proyecciones lineales distintas, Q = XW^Q, K = XW^K y V = XW^V.

Q — Query

Es la pregunta que hace cada token: “¿qué tipo de información necesito de la secuencia?”

K — Key

Es la etiqueta consultable de cada token: “¿qué información puedo ofrecer y cuándo soy relevante?”

V — Value

Es el contenido que se copiará o mezclará si el token recibe atención alta.

En self-attention, Q, K y V salen de la misma secuencia. En cross-attention, Q sale del decoder y K,V salen del encoder. La diferencia no es la fórmula; es la fuente de las matrices.

Q (queries, 3×2)

d=0

d=1

token

1.0

0.5

gato

0.2

0.8

negro

0.7

0.3

corre

K (keys, 3×2)

d=0

d=1

token

0.8

0.4

gato

0.3

0.9

negro

0.6

0.2

corre

V (values, 3×2)

d=0

d=1

token

1.0

0.0

gato

0.0

1.0

negro

0.5

corre

Calculamos S = QKᵀ. El elemento S_i,j mide la compatibilidad entre la query del token de la fila i y la key del token de la columna j. Estos valores todavía no son probabilidades: son scores brutos.

S_i,j = q_i · k_j = Σ_d Q_i,d · K_j,d

Producto punto alto
Los vectores apuntan en direcciones similares. El token de la fila considera relevante al token de la columna.

Producto punto intermedio
Hay relación parcial. Puede aportar algo, pero no domina la mezcla final.

Producto punto bajo
Poca compatibilidad. Después del softmax recibirá un peso menor.

S = QKᵀ (3×3) — scores brutos

gato

negro

corre

gato

1.00

0.75

0.70

negro

0.48

0.78

0.28

corre

0.68

0.48

Ejemplo fila gato:

S[gato,gato] = 1.0×0.8 + 0.5×0.4 = 1.00

S[gato,negro] = 1.0×0.3 + 0.5×0.9 = 0.75

S[gato,corre] = 1.0×0.6 + 0.5×0.2 = 0.70

Dividimos por √d_k = √2 ≈ 1.414 para evitar saturación del softmax. Luego aplicamos softmax por filas para obtener pesos que sumen 1.

A = softmax( S / √d_k ) = softmax( S / 1.414 )

¿Por qué escalar? Si d_k crece, los productos punto tienden a crecer en magnitud. Sin dividir por √d_k, el softmax se vuelve muy extremo y los gradientes se debilitan.

Softmax por filas Cada fila se normaliza independientemente. La fila “gato” responde: de todo lo disponible, ¿qué porcentaje miro en gato, negro y corre?

A es una matriz de mezcla Cada fila de A suma 1. No contiene los valores finales; contiene instrucciones de cuánto tomar de cada fila de V.

S / √2 — scores escalados

gato

negro

corre

gato

0.71

0.53

0.50

negro

0.34

0.55

0.20

corre

0.48

0.34

A = softmax(·) — pesos de atención

gato

negro

corre

gato

0.38

0.32

0.30

negro

0.32

0.40

0.28

corre

0.37

0.32

Cada fila suma 1. El valor más alto en cada fila (resaltado) indica el token al que más atiende cada posición.

A no contiene información semántica nueva: A contiene los pesos de atención. La información que se mezcla está en V. La salida se obtiene multiplicando la matriz de pesos A por la matriz de valores V.

Output = A · V ∈ ℝ^3×2

A — pesos de atención (3×3)

gato

negro

corre

gato

0.38

0.32

0.30

negro

0.32

0.40

0.28

corre

0.37

0.32

V — información a mezclar (3×2)

d=0

d=1

token

1.0

0.0

gato

0.0

1.0

negro

0.5

corre

Output — representaciones contextualizadas

d=0

d=1

token

0.53

0.47

gato

0.46

0.54

negro

0.53

0.48

corre

Pulsa un botón para resaltar una fila de A. Esa fila funciona como una receta de mezcla: cuánto tomar de cada fila de V para construir la salida del token seleccionado.

Qué significa el output: cada fila del output reemplaza la representación del token correspondiente por una versión contextualizada. En el ejemplo, la salida de gato no es solo el vector original de “gato”; es una mezcla ponderada de los values de gato, negro y corre. En un Transformer real esta salida pasa por la proyección de la cabeza, se concatena con otras cabezas, recibe una proyección final W^O y luego entra al bloque residual + LayerNorm.

Visualización de pesos de atención — Heatmap interactivo

Oración: "El gato negro corre rápido hoy" — pesos simulados de una capa de self-attention. Haz clic en una celda para interpretar la relación fila → columna.

Qué estás viendo: este heatmap representa la matriz A = softmax(QKᵀ / √d_k). Las filas son los tokens que consultan; las columnas son los tokens consultados. Cada fila suma 1 y se usa como receta para mezclar las filas de V. Sirve para inspeccionar qué posiciones influyen en la representación contextual de cada token, aunque no debe interpretarse automáticamente como “explicación causal” del modelo.

Bajo

Alto Filas = token que atiende · Columnas = token atendido

Selecciona una celda para ver qué token está consultando a cuál, el peso asignado y cómo se reparte la atención del token de la fila.

Multi-Head Attention

En lugar de calcular una sola atención, el Transformer calcula h atenciones en paralelo sobre subespacios distintos. Esto permite capturar diferentes tipos de relaciones simultáneamente.

Fórmula

MultiHead(Q,K,V) = Concat(head₁,…,head_h) · W^O

head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)

Dimensiones (modelo base)

h = 8 cabezas, d_model = 512
d_k = d_v = d_model/h = 64
W_i^Q, W_i^K ∈ ℝ^512×64
W_i^V ∈ ℝ^512×64
W^O ∈ ℝ^512×512

¿Por qué múltiples cabezas?

Una sola atención queda limitada a una única proyección. Las múltiples cabezas permiten:

Head 1: puede capturar relaciones locales / sintácticas
Head 2: puede capturar dependencias semánticas
Head 3: puede atender a posiciones o marcadores específicos
... cada cabeza aprende un criterio de compatibilidad diferente

La especialización de cabezas puede ocurrir pero no está garantizada. La interpretación de cada cabeza requiere cautela.

Flujo pedagógico — cómo trabaja Multi-Head

La intuición importante: no son h copias idénticas. Cada cabeza recibe proyecciones aprendidas distintas, atiende con sus propios criterios y luego todas sus salidas se recombinan.

1. Proyecciones por cabeza

X se multiplica por pesos distintos: W^Q_i, W^K_i, W^V_i. Cada cabeza ve un subespacio diferente.

2. Atención en paralelo

Cada cabeza calcula su propia matriz A_i y su propia mezcla A_iV_i. Esto ocurre simultáneamente.

local

sem.

suj-verbo

global

3. Concatenación

Las salidas de las cabezas se pegan en la dimensión de features: [head₁ | head₂ | ... | head_h].

...

4. Proyección W^O

W^O mezcla las cabezas y devuelve la representación al tamaño d_model para continuar con residual, LayerNorm y FFN.

d_model

512

salida

capa

Etapa 1: cada cabeza aprende sus propias proyecciones. Por eso una misma oración puede analizarse simultáneamente desde criterios distintos.

Visualización por cabeza — Patrones de atención simulados

Selecciona una cabeza para ver su patrón de atención. Tokens: Elgatonegrocorre

Componentes del Transformer

Positional Encoding

La self-attention no tiene noción intrínseca de orden. Sin positional encoding, permutaciones del mismo conjunto de tokens producirían los mismos outputs.

Fórmula sinusoidal (Vaswani et al.)

PE_(pos,2i) = sin( pos / 10000^2i/d_model )

PE_(pos,2i+1) = cos( pos / 10000^2i/d_model )

Donde pos es la posición del token e i es el índice de dimensión. Cada dimensión oscila a una frecuencia diferente.

Señal multiescala: dimensiones de alta frecuencia cambian rápido (distinguen posiciones cercanas), las de baja frecuencia cambian lento (distinguen posiciones lejanas).

Propiedad relativa: Para cualquier desplazamiento fijo k, PE_pos+k puede expresarse como transformación lineal de PE_pos, facilitando que el modelo aprenda relaciones relativas.

Sin parámetros: No agrega parámetros entrenables y puede extrapolarse a longitudes no vistas (con limitaciones).

Tipo	PPL ↓	BLEU ↑
Sinusoidal (Vaswani et al.)	4.92	25.8
Aprendida	4.92	25.7

En el paper original, el rendimiento fue casi idéntico. La sinusoidal se eligió por no agregar parámetros y por posibilitar extrapolación.

Visualización — patrones sinusoidales

Cada fila = posición (0-15). Cada columna = dimensión. Colores representan el valor del positional encoding.

Feed-Forward Network (FFN)

FFN(x) = max(0, xW₁ + b₁) W₂ + b₂

¿Qué hace?

Después de que la atención mezcla información entre tokens, la FFN transforma cada representación individualmente.

Se aplica posición por posición (los mismos pesos para todas las posiciones)
No introduce interacción nueva entre tokens
Atención = comunicación entre tokens
FFN = procesamiento local por token

Dimensiones (modelo base)

Capa	Tamaño
Entrada (x)	d_model = 512
Capa oculta (ReLU)	d_ff = 2048
Salida	d_model = 512

La FFN expande 4× la dimensión internamente (512 → 2048 → 512). Esto da capacidad expresiva adicional a la transformación no lineal por posición.

Add & LayerNorm (Residual + Normalización)

output = LayerNorm( x + Sublayer(x) )

Residual connection

Suma la entrada x con la salida de la subcapa. Esto:

Mejora el flujo de gradientes en redes profundas
Permite que el modelo aprenda correcciones sobre la identidad
Facilita entrenar N=6 o más capas sin degradación

Layer Normalization

Normaliza a lo largo de la dimensión de features (no del batch). Para cada token calcula media y varianza propias.

LN(x) = γ · (x − μ) / (σ + ε) + β

γ y β son parámetros aprendidos. Estabiliza las activaciones sin depender del tamaño de batch.

Comparación estructural: RNN vs CNN vs Self-Attention

Capa	Complejidad	Operaciones secuenciales	Longitud máx. de ruta
Self-Attention	O(n²d)	O(1)	O(1)
Recurrente (RNN)	O(nd²)	O(n)	O(n)
Convolucional	O(knd²)	O(1)	O(log_kn)

Trade-off: La ventaja de self-attention (ruta O(1), cálculo paralelo) viene con costo cuadrático O(n²) en la longitud de la secuencia. Para secuencias muy largas esto se vuelve un cuello de botella.

BERT — Bidirectional Encoder Representations from Transformers

Devlin et al., 2018: BERT usa solo el encoder del Transformer. A diferencia de GPT (unidireccional), BERT atiende al contexto izquierdo y derecho simultáneamente en cada capa.

Arquitectura

Variante	Capas	H	Cabezas	Parámetros
BERT Base	12	768	12	110M
BERT Large	24	1024	16	340M

Los embeddings de entrada combinan tres señales:
Input = TokenEmb + SegmentEmb + PositionEmb
Cada vector tiene dimensión H (768 en Base).

Pre-entrenamiento: dos tareas

Se enmascara el 15% de los tokens y se entrena al modelo para predecirlos usando el contexto completo (bidireccional).

Estrategia: 80% → [MASK], 10% → palabra aleatoria, 10% → sin cambio.

Esto evita que el modelo dependa exclusivamente del token [MASK] durante fine-tuning.

Dado un par (A, B), predecir si B sigue naturalmente a A en el texto.

50% pares reales (IsNext), 50% pares aleatorios (NotNext).

El vector [CLS] al final se usa para la clasificación binaria.

Nota: RoBERTa eliminó NSP y mejoró resultados entrenando más tiempo con más datos.

Demo interactivo — Masked Language Modeling

Haz clic en los tokens coloreados para enmascararlos. Luego pulsa Predecir para ver las predicciones del modelo (simuladas).

Enmascara tokens y pulsa Predecir para ver las top-5 predicciones por token enmascarado.

Fine-tuning: la misma arquitectura, distintas tareas

Clasificación

Agregar capa sobre [CLS]. Análisis de sentimiento, detección de spam.

NER — Etiquetado

Capa sobre cada token. Personas, organizaciones, lugares.

Question Answering

Predecir inicio/fin de respuesta en el párrafo. SQuAD benchmark.

Paradigma clave de BERT: una sola arquitectura universal puede pre-entrenarse sobre grandes corpus y luego adaptarse con mínimos cambios a múltiples tareas downstream.

Familia BERT — modelos derivados relevantes

Elimina NSP, entrena más tiempo con más datos y lotes más grandes. Mejora benchmarks sin cambiar la arquitectura base.

Destilación de conocimiento: 40% menos parámetros, 60% más rápido, conserva ~97% del rendimiento en GLUE.

Comparte parámetros entre capas y descompone la matriz de embeddings. Reduce parámetros manteniendo buen rendimiento.

Disentangled Attention: separa el cálculo de atención por contenido y por posición. Usa RTD (Replaced Token Detection) en vez de MLM. SOTA en múltiples benchmarks (GLUE 91.4, SuperGLUE 91.3).

mBERT (104 idiomas), BioBERT (biomédico), CodeBERT (código), BETO / bert-base-spanish-wwm (español).

GPT — Generative Pretrained Transformers

Radford et al., OpenAI (2018): GPT usa solo el decoder del Transformer con atención causal. Aprende a predecir el siguiente token, generando texto de izquierda a derecha.

Arquitectura — Decoder-only

Cada bloque del decoder en GPT incluye:

Masked self-attention — atiende solo a posiciones previas (máscara causal triangular)
Feed-Forward Network — transformación no lineal por token
Add & LayerNorm — residuales y normalización

No hay cross-attention: GPT no tiene encoder al que consultar. Solo procesa su propio contexto generado hasta ese momento.

Objetivo de pre-entrenamiento

P(x_t | x₁, …, x_t-1)

El modelo aprende a maximizar la probabilidad del siguiente token dado el contexto previo. Es autoregresivo: cada token generado se agrega al contexto para predecir el siguiente.

L = − Σ_t log P(x_t | x_<t; θ)

Evolución — GPT-1 a GPT-4

2018

GPT-1 — 117M parámetros

Proof of concept. Decoder-only con 12 capas. Demuestra que el pre-entrenamiento + fine-tuning funciona en NLP.

2019

GPT-2 — 1.5B parámetros, ctx: 1024

Entrenado en WebText (Reddit). Mayor coherencia de largo aliento. Demostró capacidad de generación de texto convincente.

2020

GPT-3 — 175B parámetros, ctx: 2048

Emergencia del few-shot in-context learning. Sin fine-tuning, puede resolver tareas con pocos ejemplos en el prompt.

2022

GPT-3.5 / ChatGPT — RLHF

Reinforcement Learning from Human Feedback. Modelo aprende a seguir instrucciones y genera respuestas más útiles y seguras.

2023

GPT-4 — Multimodal, ctx: 32k+

Procesa texto e imágenes. MMLU: 86.4%. Red-teaming y alineación. Escalamiento predecible via power laws.

Demo interactivo — Generación autoregresiva

Pulsa Siguiente token para ver cómo GPT genera texto token por token, con la distribución de probabilidad en cada paso.

Los transformers█

Técnicas modernas con modelos GPT

Diseñar la entrada al modelo para inducir el comportamiento deseado sin modificar los pesos.

Funciona bien en modelos instructivos (GPT-3.5+, GPT-4) entrenados con RLHF.

Ejemplo: "Eres un experto en… Responde concisamente…"

Incluir ejemplos (few-shot) directamente en el prompt. El modelo generaliza sin actualizar pesos.

Zero-shot: sin ejemplos. One-shot: un ejemplo. Few-shot: varios ejemplos.

Emerge con fuerza en modelos grandes (GPT-3+).

Incluir pasos de razonamiento intermedios en el prompt o pedirle al modelo que "piense paso a paso".

Mejora notablemente tareas de razonamiento, aritmética y lógica en modelos grandes.

Requiere modelos grandes: GPT-2 no puede hacer CoT efectivo.

Comparación: BERT vs GPT

BERT

Arquitectura: Solo encoder, atención bidireccional

Objetivo: MLM (predecir tokens enmascarados) + NSP

Contexto: Ve tokens a la izquierda Y a la derecha simultáneamente

Fortaleza: Comprensión del lenguaje, tareas de clasificación

No sirve para: Generación de texto libre

Benchmarks: GLUE, SQuAD, NER, clasificación

Uso: Pre-entrenamiento + fine-tuning por tarea

Familia: RoBERTa, DistilBERT, ALBERT, DeBERTa

GPT

Arquitectura: Solo decoder, atención causal unidireccional

Objetivo: LM autoregresivo (predecir siguiente token)

Contexto: Ve solo tokens a la izquierda (pasado)

Fortaleza: Generación de texto, completado, diálogo

Menos adecuado para: Comprensión bidireccional profunda

Benchmarks: MMLU, TruthfulQA, HumanEval (código)

Uso: Zero/few-shot, instrucciones, prompting

Familia: GPT-2/3/4, ChatGPT, LLaMA, Mistral

Tabla resumen completa

Aspecto	BERT	GPT
Arquitectura base	Encoder Transformer	Decoder Transformer
Dirección de atención	Bidireccional	Unidireccional (causal)
Objetivo de pre-entrenamiento	MLM + NSP	Autoregressive LM
Masked attention	No (excepto padding)	Sí (máscara causal)
Tarea principal	Comprensión (NLU)	Generación (NLG)
Fine-tuning típico	Por tarea, pesos actualizados	Zero/few-shot con prompts
Token especial de salida	[CLS] para clasificación	Último token → predicción
Paralelismo en entrenamiento	Sí (todos los tokens a la vez)	Sí (teacher forcing)
Paralelismo en inferencia	Sí	No (autoregresivo)

Literatura clave

Vaswani et al. (2017) — Attention Is All You Need. NeurIPS.
Devlin et al. (2018) — BERT: Pre-training of Deep Bidirectional Transformers.
Radford et al. (2018) — Improving Language Understanding by Generative Pre-Training. (GPT)
Radford et al. (2019) — Language Models are Unsupervised Multitask Learners. (GPT-2)
Brown et al. (2020) — Language Models are Few-Shot Learners. (GPT-3)
Liu et al. (2019) — RoBERTa: A Robustly Optimized BERT Pretraining Approach.
He et al. (2021) — DeBERTa: Decoding-enhanced BERT with Disentangled Attention.
Jain & Wallace (2019) — Attention is not Explanation.
Wiegreffe & Pinter (2019) — Attention is not not Explanation.
Wei et al. (2022) — Emergent Abilities of Large Language Models.