Autoatención desde cero
Ya construiste una neurona y una pasada hacia delante. Ahora vas a construir la idea que convirtió las redes neuronales normales en transformers y, a partir de ahí, en los LLM que hay detrás de todos los asistentes de chat: la autoatención (self-attention). Son unas pocas multiplicaciones de matrices, y puedes hacerlo todo con numpy.
La intuición
Imagina que cada palabra de una frase quiere reunir información de las demás palabras. La autoatención le da a cada posición tres vectores:
- Una consulta (query, Q): lo que busca esta posición.
- Una clave (key, K): lo que ofrece cada posición, usado para emparejar.
- Un valor (value, V): la información real que lleva cada posición.
Una posición compara su consulta con todas las claves para decidir cuánto escuchar a cada una de las demás posiciones, y luego toma una mezcla ponderada de los valores con esas cantidades. Coincidencia fuerte -> peso grande -> ese valor aporta más. Ese es todo el mecanismo: las consultas atienden a las claves, y la respuesta es una mezcla ponderada de los valores.
Las matemáticas: atención de producto escalar escalado
La puntuación de coincidencia entre una consulta y una clave es su producto escalar (mayor cuando apuntan en la misma dirección). Apila todas las consultas en una matriz Q y todas las claves en K, y todas las puntuaciones a la vez son Q @ K.T. Dividimos entre sqrt(d_k) (la dimensión de las claves) para que las puntuaciones no se disparen a medida que los vectores se alargan:
scores = Q @ K.T / np.sqrt(d_k)¿Por qué dividir? Un producto escalar crece con la dimensión. Si d_k es 64 y las entradas rondan 1, las puntuaciones en bruto caen cerca de 64, y números tan grandes empujan la softmax hacia una sola clave y aplanan el gradiente. Dividir entre sqrt(d_k), aquí sqrt(64) = 8, devuelve las puntuaciones a un rango razonable para que la atención siga siendo suave y entrenable. En el diminuto ejemplo con d_k = 1 que ejecutas abajo el divisor es simplemente 1, así que no verás que muerda, pero con tamaños de modelo reales es esencial.
Cada fila de scores contiene las puntuaciones de una consulta frente a todas las claves. Convertimos cada fila en pesos positivos que suman 1 con una softmax sobre el último eje:
weights = softmax(scores, axis=-1) # each row sums to 1La softmax exponencia y normaliza. Hecho de forma ingenua, np.exp de una puntuación grande desborda a inf y los pesos salen nan. El arreglo es el truco estándar numéricamente estable: restar el máximo de cada fila antes de exponenciar. Matemáticamente no cambia el resultado (la misma constante se cancela arriba y abajo), pero mantiene todos los exponentes <= 0:
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # stability: largest exponent is now 0
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)Por último, la salida de cada consulta son sus pesos aplicados a los valores, que es una multiplicación de matrices más:
output = weights @ VJunto, la famosa fórmula es simplemente softmax(Q @ K.T / sqrt(d_k)) @ V. Si Q es (n, d_k), K es (m, d_k) y V es (m, d_v), entonces weights es (n, m) y output es (n, d_v): un vector de salida por consulta, cada uno una mezcla de las filas de valores.
Este es todo el truco del transformer
Un transformer real no se queda en un solo cálculo de atención. La atención multicabeza (multi-head attention) ejecuta varias en paralelo (cada cabeza aprende sus propias proyecciones Q, K y V, así que cabezas distintas atienden a cosas distintas) y concatena los resultados. Un bloque de transformer apila después la atención con una pequeña red de propagación hacia delante y una conexión residual, y un modelo apila docenas de esos bloques. Pero el corazón de cada uno de ellos es exactamente la función que vas a escribir: puntuaciones, softmax estable, suma ponderada de los valores. Constrúyela y entenderás la operación central que repite un LLM cuando "presta atención" al prompt.
Una advertencia honesta: aquí Q, K y V te los damos como arrays fijos. En un modelo real no vienen dados: se producen multiplicando el embedding de cada token por tres matrices de pesos aprendidas, W_q, W_k y W_v. Esas matrices, y las de cada bloque, son justo lo que ajusta el entrenamiento con el descenso de gradiente de la lección anterior. Así que lo que construyes aquí es el núcleo fijo de la atención, idéntico en todos los transformers; el aprendizaje vive en las proyecciones que lo alimentan.
Pulsa Ejecutar para ver cómo la atención convierte unas Q/K/V diminutas en una salida, e imprimir la matriz de pesos para que puedas leer quién atendió a quién.
Implementa la atención de producto escalar escalado con numpy. Escribe attention(Q, K, V), que devuelve una tupla (output, weights). Calcula scores = Q @ K.T / np.sqrt(d_k), donde d_k es la última dimensión de Q; aplica una softmax numéricamente estable sobre el último eje (resta el máximo de cada fila antes de np.exp) para obtener unos weights cuyas filas sumen 1; y luego output = weights @ V. Devuelve primero output y luego la matriz weights. Después asigna out, w = attention(Q, K, V) para los arrays que te damos.
¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección
Este ejercicio se abre pronto
Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.