En el Módulo 1 convertimos el texto en vectores: cada token es ahora un punto en un mapa de significado. Pero esos vectores son estáticos —el embedding de “banco” es el mismo escriba lo que escriba a su alrededor—. Y ese es el problema: el significado real de una palabra depende de sus vecinas. “Me senté en el banco del río” y “saqué plata del banco” usan el mismo token, pero no significan lo mismo. Hace falta un mecanismo que deje a cada token mirar el contexto y ajustar su representación. Ese mecanismo es la atención, y es la idea central de todo este curso.

La tesis del módulo

La atención es un promedio ponderado aprendido, no magia. Cada token pregunta “¿quién de ustedes me importa?”, puntúa a todos los demás, convierte esos puntajes en pesos que suman 1, y se queda con la mezcla de la información de todos según esos pesos. Eso es todo. El resto del Transformer es infraestructura alrededor de esta operación.

La intuición: cada token mira a los demás

Volvamos a “banco del río”. Cuando el modelo procesa el token “banco”, queremos que incorpore algo de “río” a su representación, para desambiguar. La atención hace exactamente eso: para cada token, arma una nueva versión de su vector que es una mezcla de los vectores de todos los tokens de la frase, dándole más peso a los que le importan.

La palabra clave es self-attention (autoatención): “self” porque los tokens se miran entre ellos, dentro de la misma frase. La pregunta es cómo decide un token a quién mirar. Ahí entran tres piezas.

Query, Key y Value: la analogía de la búsqueda

Imagina que buscas algo en YouTube. Escribes una consulta (query). Cada video tiene una etiqueta que lo describe (key). Y cada video tiene un contenido (value). El buscador compara tu query contra todas las keys, decide cuáles calzan mejor y te devuelve el contenido de esos.

La atención hace lo mismo, pero cada token juega los tres roles a la vez. De cada vector de token se derivan tres vectores nuevos, multiplicándolo por tres matrices de pesos aprendidas (W_Q, W_K, W_V):

Query (Q) — “qué estoy buscando”. El vector que un token usa para consultar a los demás.
Key (K) — “qué ofrezco”. El vector con el que un token se anuncia para ser encontrado.
Value (V) — “qué información entrego” si me eligen.

El flujo, para un token que consulta:


  token "banco"
       │
       ▼   proyecciones aprendidas
  ┌─────────┬─────────┬─────────┐
  │ Query   │ Key     │ Value   │
  └────┬────┴─────────┴─────────┘
       │
       ▼   comparar mi Query con TODAS las Keys
  puntajes  (banco·rio alto, banco·el bajo)
       │
       ▼   softmax  ►  pesos que suman 1
  pesos de atención
       │
       ▼   promedio ponderado de los Values
  nuevo vector de "banco" (ya con contexto)

Paso a paso, con la matemática mínima

Sean q la query de un token y k₁, k₂, ... las keys de todos los tokens (incluido él mismo).

1. Puntajes. El puntaje entre mi query y cada key es su producto punto (dot product): multiplicar componente a componente y sumar. Es una medida de alineación: si q y k apuntan en la misma dirección, el puntaje es alto; si son perpendiculares, cero. Alto puntaje = “este token me interesa”.

2. Escalar. Se divide cada puntaje por la raíz de d_k (el largo de los vectores query/key). Este es el “scaled” de scaled dot-product attention (atención por producto punto escalado). ¿Por qué? Porque con dimensiones grandes los productos punto crecen mucho, y puntajes enormes empujan al softmax a valores extremos (casi 0 o casi 1), donde los gradientes casi desaparecen y el entrenamiento se estanca. Dividir por √d_k mantiene los puntajes en un rango sano. Es puramente por estabilidad.

3. Softmax. El softmax convierte una lista de puntajes (cualquier número, positivo o negativo) en una lista de pesos entre 0 y 1 que suman exactamente 1. Es lo que transforma “puntajes crudos” en “porcentajes de atención”: si un token se lleva 0.7, otro 0.2 y otro 0.1, esos son los pesos de la mezcla.

4. Promedio ponderado. Con los pesos listos, el nuevo vector del token es la suma de los Values, cada uno multiplicado por su peso. Literalmente un promedio ponderado. El token “banco” termina siendo, digamos, 60% él mismo + 30% “río” + 10% el resto.

Ojo: no hay ninguna regla escrita a mano que diga “banco debe mirar a río”. Las matrices W_Q, W_K, W_V se aprenden en el entrenamiento. El modelo descubre solo qué conviene mirar. Por eso la atención es aprendida, no programada.

En código: la fórmula completa

Todo lo anterior, para toda la frase de una vez, se escribe con álgebra de matrices. Apilamos las queries de todos los tokens en una matriz Q, las keys en K y los values en V:

import numpy as np

def softmax(x, eje=-1):
    # Resta el máximo por estabilidad numérica (evita overflow del exp).
    x = x - x.max(axis=eje, keepdims=True)
    e = np.exp(x)
    return e / e.sum(axis=eje, keepdims=True)

def atencion(Q, K, V):
    # Q, K, V tienen forma (n_tokens, d_k)
    d_k = Q.shape[-1]

    # 1. Puntajes: cada query contra cada key -> matriz (n, n).
    #    K.T transpone para que el producto dé todas las combinaciones.
    puntajes = Q @ K.T

    # 2. Escalar por raíz de d_k (estabilidad).
    puntajes = puntajes / np.sqrt(d_k)

    # 3. Softmax por fila: cada token reparte 1.0 de atención
    #    entre todos los tokens.
    pesos = softmax(puntajes, eje=-1)   # forma (n, n), cada fila suma 1

    # 4. Promedio ponderado de los Values.
    salida = pesos @ V                  # forma (n, d_k)
    return salida, pesos

# Ejemplo mínimo: 3 tokens, vectores de dimensión 4.
n, d_k = 3, 4
Q = np.random.randn(n, d_k)
K = np.random.randn(n, d_k)
V = np.random.randn(n, d_k)

salida, pesos = atencion(Q, K, V)
print(pesos.round(2))   # cada fila suma 1.0
print(salida.shape)     # (3, 4): un vector nuevo por token

La fórmula, resumida, es la que verás en todos los papers:

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

La matriz pesos es la joya: la fila i te dice cuánta atención pone el token i en cada token. Es interpretable —se puede visualizar como un mapa de calor y ver, por ejemplo, que un pronombre “mira” al sustantivo al que reemplaza—.

Una operación, comparada

Antes de la atención	Después de la atención
Cada vector de token es estático	Cada vector mezcla contexto de la frase
”banco” idéntico en cualquier frase	”banco” ajustado por “río” o “plata”
Los tokens no se comunican	Cada token vio a todos los demás
Solo significado aislado	Significado contextual

Errores comunes

Creer que la atención “entiende”. No: calcula productos punto, un softmax y un promedio ponderado. La sofisticación emerge de apilar muchas de estas operaciones, no de una sola.
Pensar que Q, K y V son cosas distintas de fábrica. Los tres salen del mismo vector de token, multiplicado por tres matrices aprendidas distintas. Un token es query, key y value a la vez.
Olvidar el √d_k. Sin escalar, con dimensiones grandes el softmax se satura, los gradientes se apagan y el modelo no aprende. Es estabilidad, no un adorno.
Confundir los pesos con los values. El softmax produce los pesos (cuánto mirar a cada uno); lo que se mezcla son los values (qué información entrega cada uno). Son dos cosas separadas.
Suponer que un token no se mira a sí mismo. Sí lo hace: su propia key está en la comparación, y a menudo se lleva buena parte del peso.

La frase para llevarse

“La atención no es más que esto: cada palabra pregunta al resto ‘¿quién me importa?’, reparte 100 puntos de interés entre todos, y se queda con la mezcla. Aprendida, repetida millones de veces, se vuelve lenguaje.”

Qué viene

Módulo 3: multi-head attention. Una sola atención capta una relación a la vez. Pero una frase tiene varias en juego —sintaxis, correferencia, posición—. La solución es correr varias atenciones en paralelo, cada una mirando algo distinto, y juntar sus miradas.

Transformers — Módulo 2: el mecanismo de atención, desde cero