Atención
Unos 24 minutos de lectura, con 8 ejemplos en 10 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.16. Lee el original
En esta página
- Mirar atrás con un promedio ponderado
- Oculta el futuro con una máscara causal
- Escalar las puntuaciones
- Varias cabezas buscan cosas distintas
- Lee a qué prestan atención las cabezas entrenadas
- Prueba qué copia el modelo
- Algunas cabezas atienden al token anterior
- Llegar más allá de la ventana
- Qué sale mal en producción
- Qué decidió este capítulo
Al final de este capítulo podrás calcular la atención a mano: puntuar qué tan bien coincide la consulta de cada token con la clave de cada token anterior, convertir las puntuaciones en pesos y promediar los valores que esos pesos seleccionan. Añadirás la máscara causal que impide que un modelo de lenguaje vea el futuro, el escalado que evita que los pesos se concentren en un solo token, y varias cabezas que buscan cosas distintas a la vez. Después leerás a qué atiende un modelo entrenado, comprobarás qué copia y medirás cuán atrás mira.
El modelo de ventana del capítulo 5 predecía el siguiente token de los nombres y descripciones de la tienda a partir de exactamente cuatro tokens anteriores, unidos uno al lado del otro, cada posición con sus propios pesos. Ese diseño tiene dos límites. No puede ver un quinto token hacia atrás, por importante que sea, y aprende sobre un token en la primera posición por separado del mismo token en la tercera. La tienda vende muebles y artículos para el hogar en línea, y sus descripciones muestran por qué el primer límite perjudica: una descripción a menudo repite palabras del nombre del producto, decenas de tokens después, como en protect your outdoor patio furniture from harsh elements with this outdoor patio furniture cover. Un modelo que puede mirar hacia atrás al nombre ve qué palabra viene después. Uno que solo ve los últimos cuatro tokens, this outdoor patio furniture, tiene que adivinar entre todo lo que sigue a esas palabras en otros productos.
Atención permite que cada posición mire a todas las anteriores y decida, según sus contenidos, cuánto importa cada una. Se introdujo para que un modelo de traducción pudiera volver a mirar las palabras de la oración que estaba traduciendo (Bahdanau et al., 2015). Es el núcleo del transformador (Vaswani et al., 2017), el diseño de los modelos abiertos que este libro estudia en el capítulo 10. Este capítulo construye la atención por sí misma y luego la lee dentro del pequeño transformador del libro, que este libro llama el modelo de la tienda: un transformador entrenado una sola vez con el texto de la tienda, que el capítulo 7 ensambla pieza por pieza.
Mirar atrás con un promedio ponderado
La atención reemplaza las ranuras fijas del capítulo 5 por un promedio ponderado. En cada posición, el modelo calcula un vector nuevo como promedio de los vectores de las posiciones que puede ver, con pesos que elige a partir de su contenido: altos para las posiciones que importan aquí, bajos para el resto. Los pesos provienen de tres vectores en los que se convierte el embedding de cada token, mediante tres matrices aprendidas:
- una consulta (query), un vector que representa lo que esta posición busca,
- una clave (key), un vector que representa lo que esta posición ofrece a las posiciones que la miran,
- un valor (value), un vector que representa lo que esta posición transmite cuando es mirada.
La puntuación de la posición j para la posición i es el producto escalar de la consulta de i con la clave de j, dividido entre la raíz cuadrada de d, el tamaño de cada consulta y clave, es decir, cuántos números contiene. Softmax convierte cada fila de puntuaciones en pesos positivos que suman uno, y la salida en la posición i es la suma ponderada de los valores. En forma matricial, para todas las posiciones a la vez:
Attention(Q, K, V) = softmax(QKᵀ / √d) V
donde Q, K y V contienen la consulta, la clave y el valor de cada posición como filas (Vaswani et al., 2017, sección 3.2.1). La división entre √d es el tema de una sección posterior.
Para ver la aritmética en algo pequeño, toma cuatro tokens del texto de la tienda: el marcador de inicio y sled coffee table, una mesa cuya base tiene la forma de los patines de un trineo. Asigna a cada uno un vector aleatorio de 8 números, como lo haría una tabla de embeddings sin entrenar, y calcula la atención con matrices aleatorias de consulta, clave y valor de 8 por 4:
1"""Computes one attention layer by hand for four tokens, with random matrices. The prose's point rests on the2printed weight matrix: each row says which positions one position draws from, and how much."""3import numpy as np45tokens = ["<s>", "sled</w>", "coffee</w>", "table</w>"]6rng = np.random.default_rng(2026) # a fixed seed, so the same numbers come out on every run7x = rng.normal(0, 1, (4, 8)) # one 8-number vector per token, as an embedding table gives8w_query, w_key, w_value = (rng.normal(0, 0.5, (8, 4)) for _ in range(3))910queries, keys, values = x @ w_query, x @ w_key, x @ w_value # what each token looks for, offers, and passes on11scores = queries @ keys.T / np.sqrt(4) # how well each query matches each key, scaled12weights = np.exp(scores - scores.max(1, keepdims=True)) # subtracting each row's largest score keeps exp from overflowing13weights /= weights.sum(1, keepdims=True) # softmax along each row: each row sums to 114output = weights @ values # each token: a weighted average of all the values1516np.set_printoptions(precision=2, suppress=True)17print("attention weights (rows attend to columns):")18for token, row in zip(tokens, weights):19 print(f" {token:<11}", row)20assert np.allclose(weights.sum(1), 1) # each row sums to 1, which the prose relies on21print("output shape:", output.shape)
python attention-by-hand.pyattention weights (rows attend to columns):
<s> [0.02 0.97 0.01 0. ]
sled</w> [0.21 0.52 0.16 0.11]
coffee</w> [0.04 0. 0.03 0.94]
table</w> [0.16 0. 0.03 0.81]
output shape: (4, 4)
Cada fila de los pesos impresos es el promedio de una posición: de qué posiciones toma datos y en qué medida. Cada fila suma uno, como afirma el ejemplo, y la salida tiene un vector de 4 números por posición. Los pesos son aleatorios porque lo son las matrices, pero ya muestran la libertad de la atención: coffee concentra la mayor parte de su peso en table, un token posterior, y el marcador de inicio concentra la mayor parte de su peso en sled. Nada en la aritmética impide que una posición mire hacia adelante. Para predecir el siguiente token, esa libertad es un error, como muestra la sección siguiente.
Tres propiedades de esta aritmética importan para todo lo que sigue. Los pesos dependen del contenido, a través de las consultas y las claves, de modo que un mismo token puede atender a lugares distintos en textos distintos. El número de posiciones no importa: las mismas tres matrices sirven para un nombre de 4 tokens o para una descripción de 150, así que el modelo aprende una sola manera de mirar atrás, no una por ranura. Y un promedio ponderado ignora el orden de lo que promedia. Sin máscara, la atención da a bar la misma salida en bar stool que en stool bar. La máscara causal de la sección siguiente deja entrar un poco de orden, porque cada token ve entonces un número distinto de tokens anteriores, y Haviv y sus colegas encontraron que los modelos de lenguaje pueden inferir posiciones solo a partir de eso (Haviv et al., 2022). Aun así, los modelos añaden información de posición explícita, como hace el capítulo 7.
Regla práctica: Escribe una vez las cuatro líneas de la atención, como hace este ejemplo, e imprime la matriz de pesos: sus filas indican exactamente dónde mira cada posición. Mantén las consultas, las claves y los valores como matrices separadas mientras aprende. Las bibliotecas suelen guardarlos en una sola matriz, como lo hace MultiheadAttention de PyTorch con su in_proj_weight (fuente), y luego lo separan, lo que calcula lo mismo.
Oculta el futuro con una máscara causal
En la primera sección, coffee tomó la mayor parte de su promedio de table, un token posterior. Un modelo de lenguaje no puede permitirse eso, porque predice cada token a partir de los tokens que lo preceden. Si la posición i pudiera atender a la posición i + 1, vería la respuesta: el entrenamiento premiaría copiar el token siguiente, y el modelo no aprendería nada útil para generar texto, donde el token siguiente todavía no existe. La solución es la máscara causal: antes del softmax, se asigna menos infinito a cada puntuación de una posición posterior. La exponencial de menos infinito es cero, así que esas posiciones reciben un peso de cero, y cada posición promedia solo sobre sí misma y sobre las posiciones anteriores.
La máscara también hace eficiente el entrenamiento. Con ella, una sola pasada sobre un texto predice todas las posiciones a la vez, cada una a partir de su propio pasado, mientras que el modelo de ventana del capítulo 5 necesitaba una ventana distinta para cada predicción.
Un cambio en el último token solo puede llegar a coffee si coffee tiene permitido mirar hacia adelante. Aplica la máscara a las puntuaciones de los mismos cuatro tokens, reemplaza table por un vector distinto y mide cuánto se mueve la salida en coffee, sin máscara y con máscara:
1"""Applies the causal mask to the same four tokens, then changes the last token and measures how far the output at2coffee moves, with and without the mask. The prose's point rests on the last printed line: with the mask, that change is zero."""3import numpy as np45tokens = ["<s>", "sled</w>", "coffee</w>", "table</w>"]6rng = np.random.default_rng(2026)7x = rng.normal(0, 1, (4, 8))8w_query, w_key, w_value = (rng.normal(0, 0.5, (8, 4)) for _ in range(3)) # the same draws as attention-by-hand9allowed = np.tril(np.ones((4, 4), dtype=bool)) # position i may look at positions 0 to i only101112def attend(x, mask):13 scores = (x @ w_query) @ (x @ w_key).T / np.sqrt(4)14 if mask:15 scores = np.where(allowed, scores, -np.inf) # a score of minus infinity becomes a weight of 016 weights = np.exp(scores - scores.max(1, keepdims=True))17 weights /= weights.sum(1, keepdims=True)18 return weights, weights @ (x @ w_value)192021weights, _ = attend(x, mask=True)22np.set_printoptions(precision=2, suppress=True)23print("weights with the causal mask:")24for token, row in zip(tokens, weights):25 print(f" {token:<11}", row)26print("weight on later tokens:", float(weights[~allowed].sum())) # ~allowed marks the positions above the diagonal2728changed = x.copy()29changed[3] = rng.normal(0, 1, 8) # a different last token in place of `table`30for mask in [False, True]:31 before, after = attend(x, mask)[1][2], attend(changed, mask)[1][2] # attend returns (weights, output); 2 is coffee32 change = float(np.abs(after - before).max())33 print(f"largest change in coffee's output, {'with' if mask else 'without'} the mask: {change:.2f}")34 assert (change == 0) == mask # the mask's job: with it, nothing after coffee reaches coffee, so the change is zero
python causal-mask.pyweights with the causal mask:
<s> [1. 0. 0. 0.]
sled</w> [0.29 0.71 0. 0. ]
coffee</w> [0.58 0.01 0.41 0. ]
table</w> [0.16 0. 0.03 0.81]
weight on later tokens: 0.0
largest change in coffee's output, without the mask: 4.69
largest change in coffee's output, with the mask: 0.00
La matriz de pesos es ahora triangular inferior, con ceros por encima de la diagonal, así que el peso total sobre los tokens posteriores es 0.0. El marcador de inicio solo puede atender a sí mismo, por lo que su fila es un único 1. sled reparte su peso entre el marcador de inicio y sí mismo. coffee, que antes de la máscara concentraba casi todo su peso en table posterior, ahora lo distribuye entre las posiciones permitidas, porque el softmax solo divide entre las posiciones que quedan. La última fila, table, no cambia, ya que no tenía posiciones posteriores que perder.
Las dos últimas líneas muestran la filtración que cierra la máscara. Sin máscara, cambiar el último token mueve la salida en coffee tanto como 4.69. Con máscara, la salida de coffee no puede depender de lo que viene después, y el ejemplo afirma que el cambio es cero. Un modelo entrenado sin máscara puede aprender a copiar cada respuesta desde la posición siguiente, de modo que su pérdida de entrenamiento puede caer cerca de cero mientras no aprende nada útil para generar texto. Nada falla durante el proceso, y eso es lo que hace difícil notar una máscara incorrecta.
Regla práctica: Aplica la máscara a las puntuaciones antes del softmax, nunca a los pesos después de él, para que cada fila siga sumando uno. Pruébalo como lo hace este ejemplo: comprueba que el peso sobre las posiciones posteriores es exactamente cero, y que cambiar un token posterior deja sin cambios las salidas anteriores. Si la pérdida de entrenamiento de un modelo baja mucho más rápido de lo esperado, revisa primero la máscara.
Escalar las puntuaciones
La fórmula de la atención divide cada puntuación entre √d, y la razón está en el producto escalar. El producto escalar de dos vectores suma un producto por cada número. Si los números de las consultas y las claves son independientes y aleatorios, con media 0 y varianza 1, una puntuación tiene varianza d, de modo que consultas y claves de mayor tamaño dan puntuaciones más grandes (Vaswani et al., 2017, sección 3.2.1, nota 4). El softmax convierte las diferencias grandes entre puntuaciones en pesos extremos: una posición recibe casi todo el peso, y el resto casi nada. Vaswani y sus colegas sospecharon que un modelo en ese estado aprende despacio, porque los gradientes del softmax son diminutos cuando un peso está cerca de 1. Dividir entre √d devuelve las puntuaciones a varianza 1, sea cual sea el tamaño.
El modelo de la tienda lo hace concreto: sus cabezas trabajan con consultas y claves de 32 números. Genera consultas y claves aleatorias de tres tamaños, 4, 32 y 256, puntúa cada consulta frente a 16 claves con y sin la división, e informa del mayor peso de cada fila, promediado sobre 1,000 consultas. Intenta adivinar primero: con 256 números y sin división, ¿cuánto vale de media el mayor peso de una fila?
1"""Measures the largest softmax weight in each row, at three sizes of query and key, with and without dividing by the2square root of the size. The prose's point rests on the unscaled averages growing with the size, and the scaled ones staying level."""3import numpy as np45rng = np.random.default_rng(2026) # a fixed seed, so the printed averages are the same on every run6for size in [4, 32, 256]:7 # numbers with mean 0 and variance 1, the case the scaling argument assumes; 1,000 queries against 16 keys8 queries, keys = rng.normal(0, 1, (1000, size)), rng.normal(0, 1, (16, size))9 for divide in [False, True]:10 scores = queries @ keys.T / (np.sqrt(size) if divide else 1)11 weights = np.exp(scores - scores.max(1, keepdims=True))12 weights /= weights.sum(1, keepdims=True)13 label = "scaled" if divide else "unscaled"14 print(f"size {size}, {label}, average largest weight in a row: {weights.max(1).mean():.2f}")
python scaling-matters.pysize 4, unscaled, average largest weight in a row: 0.45
size 4, scaled, average largest weight in a row: 0.25
size 32, unscaled, average largest weight in a row: 0.78
size 32, scaled, average largest weight in a row: 0.24
size 256, unscaled, average largest weight in a row: 0.92
size 256, scaled, average largest weight in a row: 0.25
Sin la división, el mayor peso crece con el tamaño: 0.45 con 4 números, 0.78 con 32, el tamaño de las cabezas del modelo de la tienda, y 0.92 con 256. En los tamaños mayores, cada consulta atiende sobre todo a una clave antes de que haya ocurrido ningún entrenamiento. Con la división, el mayor peso se mantiene en 0.25 en todos los tamaños: repartido entre varias claves, aunque no de manera uniforme, ya que 16 pesos iguales valdrían unos 0.06 cada uno.
Ese es el estado desde el que conviene empezar el entrenamiento. Cada posición mira a varias otras, de modo que los gradientes llegan a todas ellas, y el entrenamiento agudiza los pesos allí donde los pesos agudos ayudan. Una cabeza entrenada puede seguir poniendo la mayor parte de su peso en una sola posición, como algunas de las cabezas del modelo de la tienda; el escalado solo evita que las cabezas empiecen en ese punto.
Regla práctica: Divide las puntuaciones de atención entre la raíz cuadrada del tamaño de la consulta, como hace el artículo del transformador. Unos pocos modelos, como T5, omiten la división e incorporan el factor en la forma en que se inicializan los pesos de las consultas (fuente), así que comprueba cuál usa un modelo antes de cargar sus pesos. Si cambias cómo se calculan o inicializan las consultas y las claves, imprime el mayor peso medio de un modelo sin entrenar y espera que sea bastante menor que 1.
Varias cabezas buscan cosas distintas
Cada cálculo de atención hasta ahora da un conjunto de pesos por posición, que puede buscar un solo tipo de cosa: el token anterior, por ejemplo, o el nombre del producto. Un modelo normalmente necesita varios a la vez. La atención multicabeza ejecuta varios cálculos de atención, llamados cabezas, uno al lado del otro, cada uno con sus propias matrices de consulta, clave y valor, y cada uno en una parte de los números del vector: con 8 números y 2 cabezas, cada cabeza trabaja con 4. Las salidas de las cabezas se unen una al lado de otra y las mezcla de nuevo una matriz aprendida adicional, la proyección de salida (Vaswani et al., 2017, sección 3.2.2).
Dividir los números mantiene el costo prácticamente igual al de una sola cabeza sobre todos ellos, y da a cada cabeza su propio patrón de pesos. El modelo de la tienda tiene 4 cabezas en cada capa, y cada una trabaja con 32 números.
Ejecuta dos cabezas sobre cuatro posiciones de vectores aleatorios, con la máscara causal, y observa si la última posición mira los mismos lugares en cada una:
1"""Runs two heads of causal attention over four positions, each head working in four of the eight numbers, then mixes2the heads with an output projection. The prose's point rests on the last position's weights differing between the heads,3and on the output keeping the input's shape."""4import numpy as np56rng = np.random.default_rng(2026) # a fixed seed, so the printed weights are the same on every run7positions, dims, heads = 4, 8, 28size = dims // heads # each head works in 4 of the 8 dimensions9x = rng.normal(0, 1, (positions, dims))10w_query, w_key, w_value, output_projection = (rng.normal(0, 0.5, (dims, dims)) for _ in range(4))111213def split(m): # (positions, dims) -> (heads, positions, size)14 return m.reshape(positions, heads, size).transpose(1, 0, 2) # head 1 takes the first four numbers of each vector151617queries, keys, values = split(x @ w_query), split(x @ w_key), split(x @ w_value)18scores = queries @ keys.transpose(0, 2, 1) / np.sqrt(size) # one score matrix per head19scores = np.where(np.tril(np.ones((positions, positions), dtype=bool)), scores, -np.inf) # the causal mask, for both heads20weights = np.exp(scores - scores.max(-1, keepdims=True))21weights /= weights.sum(-1, keepdims=True)22joined = (weights @ values).transpose(1, 0, 2).reshape(positions, dims) # the heads' outputs side by side23output = joined @ output_projection # mixed back together by one more matrix2425print("weights shape (heads, positions, positions):", weights.shape)26print("what the last token attends to, head 1:", np.round(weights[0, -1], 2)) # -1 is the last position, which sees all four27print("what the last token attends to, head 2:", np.round(weights[1, -1], 2))28print("output shape:", output.shape)
python attention-heads.pyweights shape (heads, positions, positions): (2, 4, 4)
what the last token attends to, head 1: [0.41 0.18 0.29 0.11]
what the last token attends to, head 2: [0.04 0.32 0.14 0.5 ]
output shape: (4, 8)
Los pesos ahora tienen una matriz por cabeza, de forma (2, 4, 4). Las filas de la última posición difieren entre las cabezas, aunque ambas leen la misma entrada: la cabeza 1 pone su peso mayor en la primera posición, y la cabeza 2 en la última, la suya propia. Con matrices aleatorias la diferencia no significa nada todavía, pero ahí está el margen que aprovecha el entrenamiento: cada cabeza puede aprender una forma distinta de mirar hacia atrás, y la proyección de salida combina lo que encontraron. La salida tiene de nuevo la forma de la entrada, (4, 8), así que las capas de atención pueden apilarse, como lo hace el capítulo 7.
Regla práctica: Como regla general, mantén cada cabeza con al menos 32 números de ancho. En los experimentos del artículo del transformador, 16 cabezas de 32 dieron resultados igual de buenos que 8 cabezas de 64, mientras que 32 cabezas de 16 dieron peores resultados, y reducir el tamaño de las claves perjudicó (Vaswani et al., 2017, tabla 3). Revisa la forma del tensor de pesos, cabezas por posiciones por posiciones, cada vez que cambies el modelo: un eje de cabezas en el lugar equivocado mezcla las cabezas entre sí sin ningún error.
Lee a qué prestan atención las cabezas entrenadas
Las matrices aleatorias muestran la aritmética; un modelo entrenado muestra para qué sirve la atención. El modelo de la tienda tiene 4 capas, cada una con 4 cabezas de atención. Se entrenó una vez, en recordings/transformer.py, con los nombres y descripciones de entrenamiento de la tienda, cada producto como un único texto: el marcador de inicio, el nombre, un token separador <sep>, la descripción y el marcador de fin. La atención de cada capa lee la salida de la capa anterior, de modo que las capas posteriores pueden prestar atención a partir de lo que encontraron las anteriores. Como en el capítulo 5, los ejemplos leen los pesos guardados y recalculan el modelo en NumPy, con lib.transformer, que además devuelve los pesos de cada cabeza.
La pregunta es dónde mira el modelo para predecir cover en un producto de validación con el que nunca se entrenó, double chaise patio furniture cover, cuya descripción repite el final de su nombre. Detente en la segunda furniture de la descripción, donde el siguiente token es cover, muestra la probabilidad del modelo para cover y los tres pesos más grandes de cada cabeza en la primera y en la última capa. current: marca la posición desde la que se predice, name: un token del nombre y description: un token anterior de la descripción:
1"""Runs the store's trained model on one validation product, up to the description's second furniture, and prints where2its heads attend there. The prose's point rests on the last layer's head with the most weight on the name's cover, and on3the probability it gives cover."""4import numpy as np56from lib import transformer7from lib.store import load_products89_, vocabulary, manifest = transformer.load() # forward reads the weights itself, so only the vocabulary and manifest are kept10settings = manifest["settings"]11index = {t: i for i, t in enumerate(vocabulary)}12product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]13ids = transformer.product_ids(product["name"], product["description"], index, settings["longest"])14sep = ids.index(index[transformer.SEP])15position = ids.index(ids[sep - 1], sep) - 1 # just before the description first repeats the name's last token16logits, attention = transformer.forward(ids, keep=True)17probabilities = transformer.softmax(logits[position])181920def label(i):21 """Where a token sits: the current position, the name, the description, or a marker."""22 if i == position:23 return f"current:{vocabulary[ids[i]]}"24 if i == 0 or i == sep:25 return vocabulary[ids[i]]26 return f"{'name' if i < sep else 'description'}:{vocabulary[ids[i]]}"272829print("layers:", settings["layers"])30print("heads per layer:", settings["heads"])31print("dimensions per head:", settings["dimensions"] // settings["heads"])32print("name:", " ".join(vocabulary[i] for i in ids[1:sep]))33# after <sep>, up to and including the current position34print("description so far:", " ".join(vocabulary[i] for i in ids[sep + 1:position + 1]))35# position + 1 is the token that really comes next in the text36print(f"P(next token is {vocabulary[ids[position + 1]]}): {probabilities[ids[position + 1]]:.2f}")37for layer in [0, len(attention) - 1]:38 for head, weights in enumerate(attention[layer]):39 top = np.argsort(-weights[position], kind="stable")[:3]40 print(f"layer {layer + 1}, head {head + 1}: " + ", ".join(f"{label(i)} {weights[position, i]:.2f}" for i in top))4142name_cover = sep - 1 # the name's last token, `cover`43earlier = ids.index(ids[position], sep + 1) # the description's earlier `furniture`44last = attention[-1][:, position] # the last layer's heads, at the current position45head = int(last[:, name_cover].argmax())46print("last-layer head with the most weight on the name's cover:", f"head {head + 1}")47print("its weight on the name's cover:", f"{last[head, name_cover]:.2f}")48print(f"its weight on {vocabulary[ids[earlier + 1]].removesuffix('</w>')}, after the description's earlier furniture:", # earlier + 1: the token after the first furniture49 f"{last[head, earlier + 1]:.2f}")
python trained-attention.pylayers: 4
heads per layer: 4
dimensions per head: 32
name: double</w> chaise</w> patio</w> furniture</w> cover</w>
description so far: protect</w> your</w> outdoor</w> patio</w> furniture</w> from</w> har sh</w> elements</w> with</w> this</w> outdoor</w> patio</w> furniture</w>
P(next token is cover</w>): 0.97
layer 1, head 1: current:furniture</w> 0.80, description:furniture</w> 0.11, description:elements</w> 0.03
layer 1, head 2: current:furniture</w> 0.31, name:furniture</w> 0.13, description:furniture</w> 0.11
layer 1, head 3: current:furniture</w> 0.18, description:patio</w> 0.18, <sep> 0.12
layer 1, head 4: description:protect</w> 0.17, current:furniture</w> 0.14, description:patio</w> 0.11
layer 4, head 1: name:cover</w> 0.48, name:double</w> 0.18, name:furniture</w> 0.13
layer 4, head 2: name:cover</w> 0.37, <s> 0.13, name:chaise</w> 0.11
layer 4, head 3: description:patio</w> 0.27, current:furniture</w> 0.25, description:outdoor</w> 0.21
layer 4, head 4: description:with</w> 0.38, description:from</w> 0.21, description:elements</w> 0.06
last-layer head with the most weight on the name's cover: head 1
its weight on the name's cover: 0.48
its weight on from, after the description's earlier furniture: 0.00
El modelo asigna a cover una probabilidad de 0.97, y las cabezas muestran dónde pudo haber mirado. En la primera capa, una cabeza presta atención sobre todo al token actual, furniture, y las otras tres reparten su peso entre la descripción y el nombre hasta ese punto. En la última capa, head 1 pone 0.48 de su peso en cover del nombre, muchos tokens atrás: el token que siguió a furniture en el nombre. La anterior furniture de la descripción fue seguida por from, y esa cabeza le da a from solo 0.00. Una segunda cabeza de la última capa también pone su mayor peso en el cover del nombre.
Ese patrón tiene nombre. Olsson y colaboradores encontraron pares de cabezas que funcionan así en modelos pequeños formados solo por capas de atención, y cabezas con el mismo comportamiento en modelos grandes. Llaman cabeza de inducción a la cabeza posterior de cada par: una cabeza de una capa anterior copia el predecesor de cada token en su posición, y la cabeza de inducción usa eso para encontrar posiciones anteriores que siguieron al token actual, y les presta atención (Olsson et al., 2022). Los pesos anteriores son coherentes con ese comportamiento, pero los pesos muestran de dónde tomó una cabeza su promedio, no lo que usó el modelo, así que la sección siguiente lo comprueba.
Regla práctica: Inspecciona un modelo entrenado empezando por tokens concretos en textos que entiendas, donde sepas qué debería mirar el modelo. Trata lo que sugieren los pesos como una hipótesis, y compruébala cambiando la entrada, como hace la sección siguiente.
Prueba qué copia el modelo
Si el modelo predice cover copiándolo del nombre, entonces cambiar el nombre debería cambiar la predicción. Si predice cover porque las descripciones de este tipo suelen continuar así, el nombre no debería importar mucho. Una prueba que cambia la entrada y observa la salida responde eso, algo que los pesos de atención no pueden responder.
Mantén la descripción y cambia el nombre: tal como se vende, sin cover, o terminando en set. Las probabilidades de cover y set en una misma posición muestran si la predicción sigue al nombre. Después cuenta qué sigue a this outdoor patio furniture en las descripciones de entrenamiento, los cuatro tokens que vería un modelo de ventana:
1"""Changes the name of one validation product and reads the model's probabilities for cover and set at the same position,2then counts what follows this outdoor patio furniture in the training descriptions. The prose's point rests on P(cover)3falling when cover leaves the name, and on how rarely this outdoor patio furniture is followed by cover in the training4descriptions, which is all the four tokens alone give."""5from lib import transformer6from lib.store import load_products78_, vocabulary, manifest = transformer.load() # forward reads the weights itself, so only the vocabulary and manifest are kept9index = {t: i for i, t in enumerate(vocabulary)}10product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]11cover, other = index["cover</w>"], index["set</w>"]1213for name, label in [("double chaise patio furniture cover", "name as sold"),14 ("double chaise patio furniture", "name without cover"),15 ("double chaise patio furniture set", "name ending in set")]:16 ids = transformer.product_ids(name, product["description"], index, manifest["settings"]["longest"])17 sep = ids.index(index[transformer.SEP])18 furniture = [i for i in range(sep + 1, len(ids)) if ids[i] == index["furniture</w>"]]19 p = transformer.softmax(transformer.forward(ids)[furniture[1]]) # at the description's second `furniture`20 print(f"{label}, P(cover): {p[cover]:.2f}")21 print(f"{label}, P(set): {p[other]:.2f}")2223phrase = "this outdoor patio furniture " # the trailing space makes the phrase end at a word boundary24# the word after the phrase, in each description that has one; a phrase at the very end has no next word and is skipped25after = [d.split(phrase, 1)[1].split()[0] for d in load_products("train")["description"]26 if isinstance(d, str) and phrase in d and d.split(phrase, 1)[1].split()]27print("training descriptions with 'this outdoor patio furniture':", len(after))28print("followed by cover:", after.count("cover"))
python copy-from-the-name.pyname as sold, P(cover): 0.97
name as sold, P(set): 0.02
name without cover, P(cover): 0.00
name without cover, P(set): 0.29
name ending in set, P(cover): 0.00
name ending in set, P(set): 0.70
training descriptions with 'this outdoor patio furniture': 6
followed by cover: 2
El nombre decide la predicción. Con el nombre tal como se vende, el modelo da cover 0.97, y sin cover en el nombre baja a 0.00. Si terminas el nombre en set, el modelo da set 0.70 y cover 0.00.
Los cuatro tokens por sí solos apuntan solo débilmente a cover: de las 6 descripciones de entrenamiento que contienen this outdoor patio furniture, 2 continúan con cover.
Ese es el comportamiento que sugerían los pesos de la sección anterior, ahora mostrado por su efecto: el modelo copia una palabra del nombre del producto, muchos tokens atrás, algo que un modelo limitado a una ventana de cuatro tokens no puede hacer. Un solo producto no mide con qué frecuencia lo hace el modelo; las dos secciones siguientes miden sus cabezas sobre muchos productos.
Regla práctica: Prueba una afirmación sobre lo que usa un modelo cambiando esa entrada y midiendo la salida, e incluye un cambio que no debería alterar la salida. Lee los pesos de atención para formular hipótesis, y usa pruebas como esta para llegar a conclusiones.
Algunas cabezas atienden al token anterior
Un solo texto puede engañar; un promedio sobre muchos muestra las costumbres de una cabeza. Un hábito que vale la pena medir es atender al token anterior. Una cabeza que lo hace traslada el predecesor de cada token a su posición, de modo que las capas posteriores ven pares de tokens, como lo hacían los conteos de bigramas del capítulo 1, y la copia de las secciones anteriores depende de ello: para encontrar qué siguió antes a furniture, una cabeza necesita que cada posición anterior conozca a su predecesor.
Promedia el peso de cada cabeza sobre el token anterior en los primeros 300 productos de validación, y compara la cabeza con mayor peso sobre el token anterior con una distribución uniforme, que asigna 1 / (i + 1) a cada uno de los i + 1 tokens que la posición i puede ver:
1"""Averages each head's weight on the previous token over 300 validation products, and sets the largest average beside2an even spread. The prose's point rests on the head with the most weight on the previous token, and on the even spread beside it."""3import numpy as np45from lib import transformer6from lib.products import product_texts78texts = product_texts("validation", 300) # the first 300 validation products, which the model never trained on9# with keep=True, forward's second value is every layer's weights; the head count is in the manifest's settings10layers, heads = len(transformer.forward(texts[0][0], keep=True)[1]), transformer.load()[2]["settings"]["heads"]11on_previous = np.zeros((layers, heads))12for ids, _ in texts:13 _, attention = transformer.forward(ids, keep=True)14 for layer, weights in enumerate(attention): # weights: (heads, positions, positions)15 on_previous[layer] += weights[:, np.arange(1, len(ids)), np.arange(len(ids) - 1)].mean(1) # position i's weight on i - 1, for i after the start16on_previous /= len(texts)17even = np.mean([np.mean(1 / np.arange(2, len(ids) + 1)) for ids, _ in texts]) # position i sees i + 1 tokens, so 1 / (i + 1) each1819print("average weight on the previous token (rows: layers, columns: heads):")20for layer, row in enumerate(on_previous, start=1):21 print(f" layer {layer}: " + " ".join(f"{w:.2f}" for w in row))22layer, head = np.unravel_index(on_previous.argmax(), on_previous.shape)23print("head with the most weight on the previous token:", f"layer {layer + 1}, head {head + 1}")24print("its weight on the previous token:", f"{on_previous.max():.2f}")25print("an even spread's weight on the previous token:", f"{even:.2f}")
python previous-token-heads.pyaverage weight on the previous token (rows: layers, columns: heads):
layer 1: 0.03 0.06 0.13 0.10
layer 2: 0.32 0.13 0.27 0.24
layer 3: 0.13 0.33 0.09 0.07
layer 4: 0.11 0.07 0.35 0.27
head with the most weight on the previous token: layer 4, head 3
its weight on the previous token: 0.35
an even spread's weight on the previous token: 0.07
La cabeza que pone mayor peso sobre el token anterior es layer 4, head 3, con 0.35 en promedio. Una distribución uniforme, promediada de la misma manera, daría 0.07 en ese lugar, de modo que esa cabeza favorece al token anterior unas cinco veces más. Varias cabezas de las capas posteriores ponen un cuarto o más de su peso allí, y las cabezas de la primera capa ponen mucho menos: en el ejemplo de atención entrenada, una de ellas atendía sobre todo al token actual.
Ninguna cabeza es puramente una cabeza de token anterior; cada una mezcla ese hábito con otros. El promedio de una cabeza indica lo que hace sobre todo, no todo lo que hace, así que describir una cabeza como si tuviera una sola función resulta una simplificación excesiva.
Regla práctica: Describe una cabeza entrenada mediante promedios medidos, como su peso sobre el token anterior, sobre el token actual o sobre el marcador de inicio, sobre unos cuantos cientos de textos. Compara cada uno con lo que daría una distribución uniforme, promediada de la misma manera, de modo que un número como 0.3 pueda leerse como grande o pequeño.
Llegar más allá de la ventana
La promesa de la atención era ver más allá de la ventana de cuatro tokens del capítulo 5, que predice a partir del token actual y de los tres anteriores. Si el modelo de la tienda lo hace, es algo que puede medirse. ¿Cuánto cae más allá de la ventana? Para cada token de descripción de los primeros 300 productos de validación, sin contar el marcador de fin, suma el peso que cada cabeza pone en los tokens situados 4 o más posiciones atrás, los más cercanos que una ventana de cuatro tokens no puede ver, y por separado el peso en los dos marcadores, <s> y <sep>. Promedia sobre tokens, cabezas y capas, y compara con una distribución uniforme sobre las posiciones que cada token puede ver:
1"""Measures how much attention a description token puts on tokens four or more positions back, and on the two markers,2against an even spread, over 300 validation products. The prose's point rests on the all-layers share four or more back,3and on the count of descriptions that repeat a token of the name."""4import numpy as np56from lib import transformer7from lib.products import product_texts89_, vocabulary, manifest = transformer.load()10end = vocabulary.index(transformer.END)11texts = product_texts("validation", 300) # the first 300 validation products, which the model never trained on12layers = manifest["settings"]["layers"]13far, markers, even_far, even_markers, counted = np.zeros(layers), np.zeros(layers), 0.0, 0.0, 014for ids, sep in texts:15 # the description's tokens: after <sep>, so not the name, and without the end marker16 queries = np.array([i for i in range(sep + 1, len(ids)) if ids[i] != end])17 if len(queries) == 0:18 continue # a product with no description19 _, attention = transformer.forward(ids, keep=True)20 stacked = np.stack(attention)[:, :, queries] # (layers, heads, description tokens, positions)21 positions = np.arange(len(ids))22 is_marker = np.isin(positions, [0, sep]) # <s> and <sep>23 beyond = (queries[:, None] - positions[None, :] >= 4) & ~is_marker # 4 positions back is the nearest a four-token window can't see24 far += (stacked * beyond).sum(-1).mean(1).sum(-1)25 markers += (stacked * is_marker).sum(-1).mean(1).sum(-1)26 even_far += (beyond.sum(1) / (queries + 1)).sum() # an even spread over the positions each token can see27 even_markers += (2 / (queries + 1)).sum() # two markers among the query's i + 1 visible positions28 counted += len(queries)2930print("description tokens measured:", f"{counted:,}")31print("average attention weight of a description token, by layer:")32for layer in range(layers):33 print(f" layer {layer + 1}: 4 or more tokens back {far[layer] / counted:.2f}, on <s> and <sep> {markers[layer] / counted:.2f}")34print("all layers, weight 4 or more tokens back:", f"{far.mean() / counted:.2f}")35print("an even spread's weight 4 or more tokens back:", f"{even_far / counted:.2f}")36print("all layers, weight on <s> and <sep>:", f"{markers.mean() / counted:.2f}")37print("an even spread's weight on <s> and <sep>:", f"{even_markers / counted:.2f}")38# the name without <s>, and what follows <sep>; a product counts as described if anything but the end marker follows39described = [(ids[1:sep], ids[sep + 1:]) for ids, sep in texts if any(i != end for i in ids[sep + 1:])]40print("products with a description:", len(described))41print("descriptions that repeat a token of the name:", sum(bool(set(n) & set(d)) for n, d in described))
python attention-reaches-back.pydescription tokens measured: 20,571
average attention weight of a description token, by layer:
layer 1: 4 or more tokens back 0.42, on <s> and <sep> 0.12
layer 2: 4 or more tokens back 0.39, on <s> and <sep> 0.04
layer 3: 4 or more tokens back 0.58, on <s> and <sep> 0.13
layer 4: 4 or more tokens back 0.47, on <s> and <sep> 0.13
all layers, weight 4 or more tokens back: 0.46
an even spread's weight 4 or more tokens back: 0.85
all layers, weight on <s> and <sep>: 0.11
an even spread's weight on <s> and <sep>: 0.05
products with a description: 262
descriptions that repeat a token of the name: 244
Las cabezas favorecen los tokens cercanos, como cabría esperar para predecir la siguiente palabra, y aun así envían una gran parte de su atención más allá de la ventana, algo que ningún modelo anterior de este libro podía aprovechar. En todas las capas, los tokens de descripción dedican 0.46 de su atención a tokens situados 4 o más atrás, donde una distribución uniforme daría 0.85, porque la mayor parte de lo que un token de descripción puede ver está lejos.
Eso importa para este texto: de los 262 productos con descripción, 244 tienen una que repite al menos un token del nombre.
Los marcadores reciben 0.11 de la atención, frente a 0.05 de una distribución uniforme: aproximadamente el doble de lo que dictaría el azar, aunque ellos mismos no predicen ninguna palabra. Una razón probable es un patrón observado en modelos más grandes. El softmax hace que cada fila de pesos sume uno, de modo que una cabeza que no encuentra nada útil en una posición aun así tiene que colocar su peso en algún sitio, y Xiao y colaboradores comprobaron que los modelos de lenguaje asignan pesos grandes a los primeros tokens de un texto sea cual sea su contenido, y los llamaron sumideros de atención (Xiao et al., 2024). En el modelo de la tienda, <s> siempre aparece primero y <sep> está en todos los textos, así que ambos podrían cumplir esa función; <sep> además marca dónde empieza la descripción, lo cual es útil por sí mismo. Este ejemplo no permite distinguir entre los dos marcadores.
Regla práctica: Mide hasta dónde atiende un modelo entrenado antes de decidir qué longitud necesita su contexto, y compara con una distribución uniforme para que el número tenga sentido. Informa del peso en los marcadores por separado, para que el peso en marcadores no parezca atención a larga distancia, y conserva los primeros tokens cuando reduzcas el contexto de un modelo para ahorrar espacio.
Qué sale mal en producción
La atención es la parte de un modelo de lenguaje cuyo coste crece más rápido con la longitud del texto, y la parte que más a menudo se interpreta mal:
- El coste crece con el cuadrado de la longitud. Cada posición puntúa a todas las anteriores, así que un texto del doble de largo cuesta cuatro veces más en atención. Fija una longitud máxima, como hace el modelo de la tienda con 160 tokens, y comprueba cuántos de tus textos corta ese límite.
- Una máscara incorrecta falla en silencio. Un modelo que puede ver el futuro puede alcanzar una pérdida baja en el entrenamiento y aun así ser inútil para generar texto. Comprueba que el peso sobre las posiciones posteriores es cero, y que cambiar un token posterior no altera las salidas anteriores, tanto en el código de entrenamiento como en el de generación.
- Los pesos de atención no son explicaciones. Un peso alto indica de dónde tomó su promedio una cabeza, no por qué el modelo predijo lo que predijo. En un mismo modelo, pesos de atención muy distintos pueden dar la misma predicción (Jain y Wallace, 2019, sobre clasificadores recurrentes y convolucionales). Usa los pesos para formular hipótesis, y pruébalas cambiando la entrada, como hizo este capítulo con el nombre del producto.
- El peso en los marcadores parece importancia. Un peso elevado en el primer token o en un separador puede significar que una cabeza no tiene nada que hacer allí. No elimines esos tokens, y no interpretes su peso como un significado.
- Softmax desborda si no se tiene cuidado. Resta la puntuación máxima de cada fila antes de exponenciar, como hace
lib.transformer.softmax. Asegúrate de que cada fila conserve al menos una posición sin enmascarar, o la fila se convierte en NaN: una máscara causal siempre deja cada posición consigo misma, pero una máscara que oculta el relleno puede ocultar una fila entera.
Qué decidió este capítulo
- Los modelos del libro usan atención causal, escalada y multicabezal, tal como la definieron Vaswani et al.: las puntuaciones se dividen por la raíz cuadrada del tamaño de las consultas y las claves de cada cabezal, se les resta infinito en cada posición posterior antes del softmax, y los cabezales, que trabajan cada uno con una parte de los números, se mezclan mediante una proyección de salida.
- El modelo de la tienda tiene 4 capas de 4 cabezales, cada cabezal con 32 números de ancho, entrenado una vez en
recordings/transformer.pycon nombres y descripciones unidos por un marcador<sep>, y recalculado en NumPy mediantelib.transformer. - Las afirmaciones sobre lo que usa un modelo se comprueban cambiando su entrada. Los pesos de atención sugieren hipótesis; al cambiar el nombre del producto se comprobó que el modelo copia
covera partir de él. - Los cabezales entrenados se describen mediante promedios medidos sobre muchos textos, comparados con una distribución uniforme: el peso sobre el token anterior, el peso sobre los tokens a 4 o más posiciones atrás, y el peso sobre los marcadores, contados por separado.
- En las descripciones de la tienda, la atención llega mucho más allá de la ventana del capítulo 5. Los tokens de descripción dedican 0.46 de su atención a tokens situados 4 o más posiciones atrás, y el modelo copia del nombre, algo que una ventana fija no puede hacer.
- La atención necesita información de posición explícita. Un promedio ponderado ignora el orden, y la máscara causal recupera solo una parte de él, por eso el capítulo 7 añade posiciones rotatorias, como hace el modelo de la tienda dentro de cada cabezal.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 8 de 8 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.