🏗️ Arquitectura Transformer

Una fábrica de palabras

El Transformer procesa la información en una cadena de estaciones:

Cada Capa (Transformer Block) tiene 2 estaciones:

1. Atención: cada palabra "mira a las demás" para entender contexto
2. Feed-Forward: cada palabra "piensa en lo que ha visto"

Al final, una estación de salida convierte los vectores en probabilidades para elegir la siguiente palabra.

Diagrama de una capa

     ┌─────────────────────────────────────┐
     │         ENTRADA (x)                 │
     │    [seq_len × d_model]              │
     └────────────┬────────────────────────┘
                  │
                  ▼
     ┌──────────────────────┐
     │     RMSNorm          │  ← normalización
     └────────────┬─────────┘
                  │
                  ▼
     ┌─────────────────────────────────────┐
     │  Multi-Head Self-Attention          │
     │                                     │
     │  Q = x · W_Q   [d_model → d_model] │
     │  K = x · W_K   [d_model → d_model] │
     │  V = x · W_V   [d_model → d_model] │
     │                                     │
     │  heads = split(Q,K,V, n_heads)     │
     │  for each head:                     │
     │    attn = softmax(Q·K^T/√d_k)·V     │
     │                                     │
     │  out = concat(heads) · W_O          │
     └────────────┬────────────────────────┘
                  │
                  ▼
     ┌──────────────────────┐
     │  Residual: x + out   │  ← la conexión que salva el gradiente
     └────────────┬─────────┘
                  │
                  ▼
     ┌──────────────────────┐
     │     RMSNorm          │
     └────────────┬─────────┘
                  │
                  ▼
     ┌─────────────────────────────────────┐
     │  Feed-Forward (SwiGLU)              │
     │                                     │
     │  gate = SiLU(x · W_gate)            │
     │  up   = x · W_up                    │
     │  hidden = gate × up                 │
     │  out   = hidden · W_down            │
     │                                     │
     │  d_model → d_ff → d_model           │
     │  (d_ff ≈ 4 × d_model)              │
     └────────────┬────────────────────────┘
                  │
                  ▼
     ┌──────────────────────┐
     │  Residual: x + out   │
     └────────────┬─────────┘
                  │
                  ▼
     ┌──────────────────────┐
     │        SALIDA        │
     │   (misma forma)      │
     └──────────────────────┘

Parámetros clave por tamaño de modelo

Fórmula de total de parámetros (LLaMA-like):

Total = vocab × d_model                     (embedding + LM head)
      + n_layers × 4 × d_model²             (attention: Q,K,V,O)
      + n_layers × 3 × d_model × d_ff       (FFN: gate, up, down)
      + n_layers × 2 × d_model              (2× RMSNorm por capa)
      + 1 × d_model                         (RMSNorm final)

El núcleo del Transformer

La atención es el mecanismo que permite a cada palabra mirar a las demás para entender el contexto.

Scaled Dot-Product Attention

Para cada token, creamos tres vectores:

• Q (Query): "¿qué estoy buscando?"
• K (Key): "¿qué información tengo?"
• V (Value): "¿qué información doy?"

Score = Q · K^T           ← similitud entre cada par de tokens
Scale: / √d_k             ← evitar que scores crezcan con dimensión
Mask (causal): −∞ para tokens futuros ← en autoatención causal
Softmax: normalizar a [0,1]
Output: scores × V         ← suma ponderada de valores

Multi-Head Attention

En lugar de una atención, hacemos h en paralelo. Para un modelo 7B: h=32 cabezas, d_head=128. Cada cabeza aprende un tipo de relación diferente:

• Cabeza 1: relaciones sintácticas (sujeto-verbo)
• Cabeza 2: relaciones anafóricas (pronombre → referente)
• Cabeza 3: patrones posicionales
• Cabeza 4: relaciones semánticas profundas
• Cabeza 5-8: relaciones de negación, condición...

Variantes de atención

La memoria del conocimiento

Si la atención decide qué información considerar, el Feed-Forward decide qué hacer con ella.

Es como preguntar a un experto: le das la información, el experto consulta su memoria (expansión), filtra lo relevante (activación), y te da una respuesta elaborada (compresión).

SwiGLU en detalle

En LLaMA y modelos modernos se usa SwiGLU (una variante de GLU con activación SiLU):

RMSNorm(x)   → normalización

x · W_up     → proyección UP: [d_model] → [d_ff]     (expansión)
x · W_gate   → proyección GATE: [d_model] → [d_ff]   (control)
SiLU(x_gate) × x_up   → activación elemento a elemento
resultado · W_down   → proyección DOWN: [d_ff] → [d_model] (compresión)

Donde d_ff ≈ 4 × d_model (para 7B: 4096 → 11008).

¿Qué hace realmente cada neurona?

Se ha observado que neuronas individuales se especializan:

• Neurona 5723: se activa con contextos relacionados a París
• Neurona 8921: se activa con términos de programación
• Neurona 1452: se activa con conceptos matemáticos

Eliminar una neurona específica puede eliminar la capacidad de hablar de un tema concreto. Esto se llama "surgical model editing" y se usa para corregir hechos sin reentrenar.

Activaciones en modelos modernos