El bloque transformer
Unos 24 minutos de lectura, con 8 ejemplos en 11 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
- Add each part's output to a residual stream
- Normalizar antes de cada parte
- Transform each position with a gated feed-forward layer
- Dar posiciones a la atención con rotaciones
- Vincular la capa de salida a los embeddings
- Verifica el modelo contra PyTorch
- Quita un bloque para ver lo que hace
- Mide lo que cuesta un detalle que no coincide
- Cuenta dónde van los parámetros
- Qué sale mal en producción
- Lo que decidió este capítulo
Al terminar este capítulo podrás ensamblar un bloque transformer a partir de sus partes, unidas por conexiones residuales: atención, normalización, una capa feed-forward con compuerta y la información de posición. Después podrás apilar bloques para formar un modelo de lenguaje completo. Comprobarás cada parte con el modelo entrenado de la tienda, comprobarás el conjunto con las implementaciones propias de PyTorch, medirás qué aporta cada bloque y cada detalle, y contarás dónde van los parámetros.
Capítulo 6 construyó la atención: cada posición mira hacia las posiciones anteriores y toma un promedio ponderado de lo que encuentra. La atención por sí sola no es un modelo de lenguaje, y la tienda, una tienda en línea de muebles y artículos para el hogar, necesita más que atención. Esta mueve información entre posiciones pero transforma poco esa información, y casi no tiene noción del orden de las palabras. Además, las capas de atención apiladas directamente se degradan: sin las demás partes de un bloque, la salida de la atención pura tiende al mismo vector en todas las posiciones, y más rápido a medida que se añaden capas (Dong et al., 2021). El bloque transformer añade partes alrededor de la atención que transforman cada posición, le dan orden a las palabras y evitan que una pila profunda se degrade (Vaswani et al., 2017).
Este capítulo construye el bloque en la forma popularizada por los modelos LLaMA: normalización de la entrada de cada parte con RMSNorm, una capa feed-forward con compuerta y embeddings de posición rotatorios en cada capa (Touvron et al., 2023, sección 2.2). SmolLM2, cuyo tokenizador leíste en el capítulo 2, se construye de la misma manera. Su modelo de 360 millones de parámetros tiene 960 dimensiones, 32 capas y 15 cabezas, y se diferencia del modelo de la tienda en dos detalles que se explican más abajo: sus cabezas comparten claves y valores, y sus posiciones rotatorias giran más lentamente (configuración).
El modelo de la tienda, entrenado con el texto de productos de la tienda, consta de 4 de estos bloques entre una tabla de embeddings y una capa de salida, y el capítulo 6 leyó sus cabezas. Este libro llama capa del modelo a cada bloque. En cada posición, cada bloque hace dos cosas en orden:
- normaliza el vector, ejecuta la atención y suma el resultado al vector;
- normaliza de nuevo, ejecuta una capa feed-forward y suma también ese resultado.
Esta parte aún no está traducida, así que está en inglés.
Add each part's output to a residual stream
In chapter 5's window model, each layer replaced its input: the hidden layer's output was all the output layer saw. A transformer block adds to its input instead. Each part computes something from the current vector and adds its output to it: x ← x + attention(x), then x ← x + feed-forward(x). Adding a part's output to its input, instead of replacing the input, is a residual connection. It comes from image models, where very deep stacks of layers trained well only once each layer added to its input instead of replacing it (He et al., 2016).
Two consequences follow. With the additions, the signal can pass "directly from one block to any other block", forwards and, as gradients, backwards, so a deep stack trains far more reliably than it would without them (He et al., 2016b). And every position's vector becomes a shared workspace that each part reads from and writes to: the token's embedding goes in at the bottom, each part adds what it computes, and the output layer reads the sum at the top. Elhage and colleagues call this running sum, each position's vector with every part's output added to it, the residual stream (Elhage et al., 2021).
Run the store's model on one validation product and, at every layer, measure the length of what attention adds, of what the feed-forward layer adds, and of the vectors after both additions, averaged over positions. A vector's length here is the square root of the sum of its squared numbers:
1"""Runs the store's model on one validation product, one block at a time, and prints how much attention and the2feed-forward layer add to the residual stream at each layer. The prose's point rests on the two lengths printed3first and last: the vectors entering layer 1 and leaving the last layer."""4import numpy as np56from lib import transformer7from lib.products import product_texts89weights, _, manifest = transformer.load()10ids, sep = product_texts("validation", 1)[0] # the first validation product; sep, its <sep> position, isn't needed here11x = weights["embedding"][np.array(ids)] # the stream entering block 1: each token's embedding12print("length of the vectors entering layer 1:", f"{np.linalg.norm(x, axis=1).mean():.2f}")13for layer in range(manifest["settings"]["layers"]):14 layer_weights = transformer.layer_weights(layer)15 added_by_attention, _ = transformer.attention(transformer.rms_norm(x, layer_weights["norm1"]), layer_weights, manifest["settings"]["heads"])16 x = x + added_by_attention17 normalized = transformer.rms_norm(x, layer_weights["norm2"])18 added_by_feed_forward = (transformer.silu(normalized @ layer_weights["gate"]) * (normalized @ layer_weights["up"])) @ layer_weights["down"]19 x = x + added_by_feed_forward20 print(f"layer {layer + 1}: attention adds {np.linalg.norm(added_by_attention, axis=1).mean():.2f}, "21 f"feed-forward adds {np.linalg.norm(added_by_feed_forward, axis=1).mean():.2f}, "22 f"vectors now {np.linalg.norm(x, axis=1).mean():.2f}")23print("length of the vectors leaving the last layer:", f"{np.linalg.norm(x, axis=1).mean():.2f}")24print("largest number in the stream:", f"{np.abs(x).max():.1f}")
python residual-stream.pylength of the vectors entering layer 1: 1.17
layer 1: attention adds 2.90, feed-forward adds 3.00, vectors now 4.65
layer 2: attention adds 2.05, feed-forward adds 2.90, vectors now 6.14
layer 3: attention adds 2.26, feed-forward adds 4.12, vectors now 8.46
layer 4: attention adds 4.08, feed-forward adds 6.33, vectors now 13.16
length of the vectors leaving the last layer: 13.16
largest number in the stream: 50.6
The stream grows through the layers, because each addition piles onto the last. It goes from an average length of 1.17 entering the first layer to 13.16 leaving the last. Every layer adds to it, and what attention adds is comparable in size to what the feed-forward layer adds, though the feed-forward layer adds more at every layer, and by more in the later ones: both parts do real work at every layer. A layer reading the long vectors near the top would need very differently scaled weights from one reading the short ones at the bottom, unless something rescales what each layer reads; the next section does.
Working rule: Write every block as additions to the residual stream, never as replacements, and keep the stream's width the same through the whole model so the additions line up. When you debug a deep model, measure what each part adds: a part that adds almost nothing is doing almost nothing.
Normalizar antes de cada parte
El flujo residual crece a través de las capas, como midió la sección anterior, así que cada parte debería leer una copia reescalada de él. La normalización reescala un vector a un tamaño estándar antes de que una parte lo lea, de modo que los pesos de esa parte funcionen igual tanto si el flujo es corto como si es largo. El transformador original normalizaba después de cada suma, con normalización por capa, que resta la media de cada vector y lo divide entre su desviación estándar (Ba et al., 2016). Xiong y sus colegas demostraron que normalizar antes de cada parte entrena de forma más estable, porque solo se reescala la copia que lee cada parte, nunca el flujo en sí (Xiong et al., 2020). Y RMSNorm prescinde de la media: divide cada vector entre su raíz cuadrática media, es decir, la raíz cuadrada del promedio de sus números al cuadrado, y multiplica cada dimensión por una ganancia aprendida (Zhang y Sennrich, 2019):
RMSNorm(x) = x / √(media(x²) + ε) · g
donde ε es un número muy pequeño, 10⁻⁵ aquí, que mantiene segura la división, y g es la ganancia, que empieza en 1. Zhang y Sennrich comprobaron que RMSNorm es casi tan preciso como la normalización por capa, y más rápido. El modelo de la tienda lo usa antes de la atención, antes de la capa de avance y una vez más antes de la capa de salida.
Normaliza a mano el flujo del mismo producto de validación en ambos extremos del modelo, al entrar en el primer bloque y al salir del último, con la ganancia en 1, y compara el vector de cada posición con lib.transformer.rms_norm:
1"""Normalizes one validation product's residual stream by hand, entering the first block and leaving the last, and2asserts that the result matches the shared module's rms_norm. The prose's point rests on the root mean square before3and after normalizing, and on the largest mean of a position's numbers, which RMSNorm does not remove."""4import numpy as np56from lib import transformer7from lib.products import product_texts89ids, _ = product_texts("validation", 1)[0] # the first validation product; its <sep> position isn't needed10streams, _ = transformer.run(ids) # the residual stream entering block 1 and leaving each block11gain = np.ones(streams[0].shape[1]) # the learned gain set to 1, to show the normalization alone12for label, x in [("entering block 1", streams[0]), ("leaving the last block", streams[-1])]:13 root_mean_square = np.sqrt((x ** 2).mean(1, keepdims=True) + 1e-5) # one per position; 1e-5 is the ε14 by_hand = x / root_mean_square * gain15 print(f"root mean square {label}, before:", f"{root_mean_square.mean():.2f}")16 print(f"root mean square {label}, after:", f"{np.sqrt((by_hand ** 2).mean(1)).mean():.2f}")17 assert np.allclose(by_hand, transformer.rms_norm(x, gain), atol=1e-4) # the library's function, to 4 decimal places18 print(f"same as lib.transformer.rms_norm, {label}:", "yes")19 # layer normalization would subtract the mean first; RMSNorm doesn't, so this mean need not be zero20 print(f"largest mean of a position's numbers after, {label}:", f"{np.abs(by_hand.mean(1)).max():.2f}")
python rms-norm-by-hand.pyroot mean square entering block 1, before: 0.10
root mean square entering block 1, after: 1.00
same as lib.transformer.rms_norm, entering block 1: yes
largest mean of a position's numbers after, entering block 1: 0.23
root mean square leaving the last block, before: 1.16
root mean square leaving the last block, after: 1.00
same as lib.transformer.rms_norm, leaving the last block: yes
largest mean of a position's numbers after, leaving the last block: 0.26
Normalizar lleva ambos extremos a la misma escala. La raíz cuadrática media vale en promedio 0.10 al entrar en el primer bloque y 1.16 al salir del último, y 1.00 en ambos una vez normalizados; el cálculo a mano coincide con el de la biblioteca en los dos extremos. RMSNorm reescala pero no centra: los números de una posición pueden seguir promediando lejos de cero después, hasta 0.26 aquí. Ese es el paso que se ahorra frente a la normalización por capa.
Así, aunque el flujo creció muchas veces en longitud a lo largo de las capas, cada capa de atención y de avance lee vectores de la misma escala, multiplicados por sus ganancias aprendidas.
Regla práctica: Normaliza antes de cada parte del bloque, no después, y normaliza el flujo una vez más antes de la capa de salida. Usa RMSNorm a menos que estés replicando un modelo que use normalización por capa. Cuando cargues los pesos de otro modelo, comprueba primero qué normalización usa, dónde y con qué ε, antes que nada: el ejemplo de detalles desajustados muestra lo que cuesta un pequeño desajuste.
Esta parte aún no está traducida, así que está en inglés.
Transform each position with a gated feed-forward layer
Attention moves information between positions; the feed-forward layer transforms it, at each position separately. It's the same idea as chapter 5's hidden layer: widen the vector, apply a function that isn't a straight line, and narrow the result back to the stream's width. The store's model widens 128 numbers to 352.
The form the LLaMA models use is gated. A gated feed-forward layer computes two widened vectors from the input, passes one through a function called SiLU, and multiplies the two number by number, so the first decides how much of the second gets through (Shazeer, 2020):
FFN(x) = (SiLU(x W_gate) ⊙ (x W_up)) W_down
where ⊙ multiplies number by number, and SiLU(z) = z · σ(z), with σ the logistic function from chapter 4. SiLU passes large positive numbers almost unchanged and turns large negative ones to nearly zero, smoothly. Shazeer compared several gated forms with the plain one, at the same number of parameters, and found the gated ones predicted better; this form is called SwiGLU.
What does the gate shut? Compute SiLU at three points, then run the first block's real feed-forward layer on the same validation product and count, at each position, how many of its hidden units the gate nearly shuts:
1"""Computes SiLU at three points, then runs block 1's feed-forward layer on one validation product and counts the hidden2units its gate nearly shuts at each position. The prose's point rests on the three SiLU values and on that count."""3import numpy as np45from lib import transformer6from lib.products import product_texts78print("silu(-3), silu(0), silu(3):", ", ".join(f"{v:.2f}" for v in transformer.silu(np.array([-3.0, 0.0, 3.0]))))910ids, _ = product_texts("validation", 1)[0] # the first validation product; its <sep> position isn't needed11heads = transformer.load()[2]["settings"]["heads"] # load returns (weights, vocabulary, manifest): index 2 is the manifest12first = transformer.layer_weights(0) # block 1's weights13x = transformer.load()[0]["embedding"][np.array(ids)] # index 0 is the weights: the embeddings, the stream entering block 114attended, _ = transformer.attention(transformer.rms_norm(x, first["norm1"]), first, heads)15normalized = transformer.rms_norm(x + attended, first["norm2"]) # what block 1's feed-forward layer reads16gate = transformer.silu(normalized @ first["gate"]) # how much of each hidden unit to let through17up = normalized @ first["up"] # what each hidden unit carries18output = (gate * up) @ first["down"] # gated, then projected back to the stream's width19shut = (np.abs(gate) < 0.05).sum(1) # per position; 0.05 is the threshold for "nearly shut"20print("hidden units:", gate.shape[1])21print("hidden units nearly shut at a position (gate under 0.05 in size), on average:", f"{shut.mean():.0f}")22print("fewest and most nearly shut at a position:", f"{shut.min()} and {shut.max()}")23print("positions:", len(ids))24print("output shape:", output.shape)
python gated-feed-forward.pysilu(-3), silu(0), silu(3): -0.14, 0.00, 2.86
hidden units: 352
hidden units nearly shut at a position (gate under 0.05 in size), on average: 49
fewest and most nearly shut at a position: 33 and 67
positions: 133
output shape: (133, 128)
SiLU of −3, 0 and 3 gives -0.14, 0.00, 2.86: nearly zero for the negative number, nearly unchanged for the positive one.
Which units the gate shuts depends on the input. At a typical position it nearly shuts 49 of the first block's 352 hidden units, and the count ranges between 33 and 67 over the positions. So each position uses its own mix of them. The output has one vector per position at the stream's width again, (133, 128), ready to add.
The feed-forward layers hold most of a block's parameters: in the store's model, three matrices of 128 by 352, against attention's four of 128 by 128. Geva and colleagues found that in trained models these layers work like stores of patterns: each hidden unit responds to particular patterns in the text, and pushes the prediction towards particular next tokens (Geva et al., 2021).
Working rule: Use a gated feed-forward layer with SiLU. Set its width so its three matrices hold as many parameters as a plain layer four times the stream's width, the original transformer's ratio, 2,048 for 512 (Vaswani et al., 2017, section 3.3): that's about 8/3 times the width. SmolLM2-360M uses exactly 8/3, 2,560 for 960. The store's model rounds 8/3 of its width up to a multiple of 32, a rule of thumb that keeps matrix sizes convenient for hardware. When you load another model, check whether its feed-forward layer is gated, since a gated layer has three matrices where a plain one has two.
Dar posiciones a la atención con rotaciones
Un promedio ponderado ignora el orden de lo que promedia, como mostró el capítulo 6, así que la atención obtiene un sentido débil de la posición solo a partir de la máscara causal. El transformador original sumaba un vector para cada posición al embedding de cada token (Vaswani et al., 2017, sección 3.5). Los modelos LLaMA, en cambio, usan embeddings de posición rotatorios, RoPE, que actúan dentro de la atención, en cada capa (Su et al., 2021; Touvron et al., 2023, sección 2.2). Antes de puntuar, RoPE rota cada query y cada key según ángulos que crecen con su posición. Los d números del vector se toman en pares, el número i con el número i + d/2 en el modelo de la tienda, y cada par (a, b) se trata como un punto en un plano y gira alrededor del origen. En la posición p, el par i gira el ángulo p·θᵢ, donde θᵢ = 10000^(−i/(d/2)):
(a, b) → (a cos pθᵢ − b sin pθᵢ, a sin pθᵢ + b cos pθᵢ)
Así, los primeros pares giran rápido, un radián completo por posición, y los últimos giran despacio. La línea angles = ... en lib.transformer.rope calcula p·θᵢ para cada posición y cada par, y la línea siguiente aplica la rotación.
La rotación tiene dos propiedades que encajan con la atención. No cambia la longitud de un vector, así que añade posición sin distorsionar el contenido. Y si una query en la posición m se gira mθᵢ y una key en la posición n se gira nθᵢ, su producto punto depende solo de la diferencia, (m − n)θᵢ: la puntuación depende de cuán separados están, no de dónde se sitúan en el texto. Una cabeza puede aprender a mirar 3 tokens atrás, y funciona igual al principio de un nombre que en mitad de una descripción.
Rota una query y una key aleatorias de 32 números, el tamaño de las cabezas del modelo de la tienda, para las posiciones 0 a 19, y compara las puntuaciones escaladas, tal como las define el capítulo 6, en tres pares, lo que pone a prueba esto:
1"""Rotates one random query and key for each of 20 positions, checks that the rotation keeps their lengths, and scores2three pairs of positions. The prose's point rests on the two scores for pairs 3 apart, which match, and the score for3the pair 6 apart, which doesn't."""4import numpy as np56from lib.transformer import rope78rng = np.random.default_rng(2026) # a fixed seed: the same random query and key on every run9size = 32 # 32 numbers: the store's width of 128 split across 4 heads10query, key = rng.normal(0, 1, size), rng.normal(0, 1, size)11positions = 2012rotated_q = rope(np.tile(query, (positions, 1))) # the same query, rotated for each position 0 to 1913rotated_k = rope(np.tile(key, (positions, 1)))14kept = np.allclose(np.linalg.norm(rotated_q, axis=1), np.linalg.norm(query)) and \15 np.allclose(np.linalg.norm(rotated_k, axis=1), np.linalg.norm(key)) # rotation turns a vector, never changes its length16assert kept17print("length kept by the rotation, for the query and the key:", "yes")18for i, j in [(2, 5), (12, 15), (2, 8)]: # (key position, query position): the first two are 3 apart, the third 619 print(f"score with the key at {i} and the query at {j}:", f"{rotated_q[j] @ rotated_k[i] / np.sqrt(size):.3f}") # scaled, as chapter 6 defines it
python rope-by-hand.pylength kept by the rotation, for the query and the key: yes
score with the key at 2 and the query at 5: 0.217
score with the key at 12 and the query at 15: 0.217
score with the key at 2 and the query at 8: -0.765
Los pares separados por la misma distancia puntúan igual, estén donde estén. La key en la posición 2 y la query en la 5 puntúan 0.217, y la key en la 12 y la query en la 15 puntúan 0.217, lo mismo, porque ambos pares están separados por 3. La key en la 2 y la query en la 8, separadas por 6, puntúan -0.765: la misma query y la misma key, puntuadas de forma distinta porque están más alejadas. La rotación conserva la longitud de ambos vectores, lo que el ejemplo verifica.
RoPE no tiene parámetros aprendidos: los ángulos son fijos, y el modelo aprende queries y keys que los usan. El modelo de la tienda lo aplica a las queries y keys de cada cabeza en cada capa, lo que da a las cabezas de token anterior del capítulo 6 una forma directa de encontrar el token previo, junto con la señal débil que proporciona la máscara.
Regla práctica: Usa embeddings de posición rotatorios, aplicados a las queries y las keys, nunca a los values. Cuando cargues los pesos de otro modelo, comprueba cómo su RoPE empareja los números y qué base usa. Algunas implementaciones emparejan números vecinos; otras emparejan la primera mitad con la segunda, como hace lib.transformer.rope y como indica la configuración de SmolLM2 con "rope_interleaved": false. SmolLM2 usa una base de 100,000, donde el modelo de la tienda usa 10,000.
Vincular la capa de salida a los embeddings
Con todas las piezas construidas, el modelo completo es lo bastante corto como para leerlo de una vez. lib.transformer.block es un bloque, tal como lo ha descrito el capítulo:
def block(x: np.ndarray, layer_weights: dict[str, np.ndarray], heads: int, positions=rope):
"""One transformer block: attention, then the gated feed-forward layer, each added to the residual stream."""
attended, weights = attention(rms_norm(x, layer_weights["norm1"]), layer_weights, heads, positions)
x = x + attended
normalized = rms_norm(x, layer_weights["norm2"])
x = x + (silu(normalized @ layer_weights["gate"]) * (normalized @ layer_weights["up"])) @ layer_weights["down"]
return x, weights
lib.transformer.run pasa el embedding de cada token por los bloques en orden, y estas líneas de lib.transformer.forward convierten el flujo final en un logit por token del vocabulario, las puntuaciones que el softmax del capítulo 5 convierte en probabilidades:
streams, kept = run(ids, name, positions, skip)
weights, _, _ = load(name)
logits = rms_norm(streams[-1], weights["final_norm"]) @ weights["embedding"].T
La última línea contiene una idea más, el vinculado de pesos (weight tying): la capa de salida reutiliza la tabla de embeddings, transpuesta, en lugar de aprender una matriz propia. El logit de un token es el producto escalar del vector final con el embedding de ese token. Press y Wolf comprobaron que el vinculado reduce la perplejidad y, además, ahorra los parámetros de la capa de salida (Press y Wolf, 2017). SmolLM2 también los vincula (la capa de salida y los embeddings) ("tie_word_embeddings": true en su configuración), ya que, para un modelo de su tamaño, una capa de salida separada supondría una parte importante del total. El recuento de parámetros muestra lo que ahorra el vinculado en el modelo del almacén.
Regla práctica: vincula la capa de salida a los embeddings en un modelo pequeño, y comprueba si un modelo que cargues vincula los pesos antes de buscar una matriz de salida separada. Mantén tu propio paso hacia delante lo bastante corto como para leerlo completo, como lo está lib.transformer, de modo que cada detalle que comprueben las siguientes secciones sea visible.
Verifica el modelo contra PyTorch
PyTorch entrenó el modelo de la tienda una vez, en recordings/transformer.py, como entrenó el del capítulo 5 (véase Entrena con PyTorch), y el script guardó los logits propios de PyTorch para cada posición de un producto de validación. El script de entrenamiento usa el RMSNorm, la atención causal y la SiLU propios de PyTorch, así que compararlos con lib.transformer verifica el código de NumPy contra el de una biblioteca, y no contra una segunda copia de sí mismo. RoPE es la excepción: PyTorch no tiene una versión integrada, así que ambos programas la escriben a mano, y la comprobación solo confirma que coinciden. El ejemplo de RoPE a mano comprueba sus propiedades en su lugar.
Para probar el paso hacia adelante completo, recalcula en NumPy los logits del producto guardado y compara cada posición con las de PyTorch:
1"""Recomputes the store's model's logits in NumPy for the validation product the training script saved, and checks every2one against PyTorch's to four decimal places. The prose's point rests on the count of logits compared, and on the3assertion that they all match."""4import numpy as np56from lib import transformer78_, _, manifest = transformer.load()9check = np.load("data/recorded/transformer/check.npz") # one validation product's ids, and PyTorch's logits1011ours = transformer.forward(list(check["ids"])) # forward takes a list of token ids, not an array12print("PyTorch version:", manifest["torch"])13print("positions compared:", len(check["ids"]))14print("logits compared:", f"{ours.size:,}")15assert np.abs(ours - check["logits"]).max() < 1e-4 # 1e-4 is four decimal places16print("same as PyTorch to 4 decimal places:", "yes")
python transformer-same-as-pytorch.pyPyTorch version: 2.14.1+cpu
positions compared: 133
logits compared: 550,886
same as PyTorch to 4 decimal places: yes
El modelo en NumPy reproduce los 550,886 logits de PyTorch, para 133 posiciones, con cuatro decimales, con PyTorch 2.14.1+cpu. Como la comprobación abarca un texto entero, cubre las partes que dependen de la posición, la máscara y las rotaciones, además de las normalizaciones, las puertas y la salida ligada.
Regla práctica: Compara tu paso hacia adelante con las salidas de la biblioteca de entrenamiento sobre un texto completo, no sobre una sola posición. Cuando la biblioteca tenga su propia implementación de una parte, entrena con ella, de modo que la comprobación compare dos implementaciones independientes; cuando no la tenga, como ocurre aquí con RoPE, prueba las propiedades de esa parte a mano.
Quita un bloque para ver lo que hace
El modelo está comprobado; ahora mide lo que aportan sus bloques. Como cada bloque suma al flujo residual, se puede quitar un bloque y el modelo sigue funcionando: el flujo lo atraviesa sin cambios y el bloque siguiente lo lee como antes. Quitar una parte permite hacer un experimento sencillo, llamado ablación: elimina una parte y mide lo que pierde el modelo. Muestra cuánto contribuye cada bloque a las predicciones del modelo entrenado, algo que no se puede leer en sus pesos.
¿Qué bloque, al quitarlo, perjudica más? Haz una predicción y puntúa los nombres y las descripciones de los primeros 100 productos de validación, 7,624 predicciones en total, con el modelo completo y con cada bloque quitado por turno:
1"""Scores the names and descriptions of the first 100 validation products with the full model, and with each block left2out in turn, reporting perplexity and the top token's average probability. The prose's point rests on the perplexity3with each block left out, set against the full model's."""4import numpy as np56from lib import transformer7from lib.products import product_texts89layers = transformer.load()[2]["settings"]["layers"] # load returns (weights, vocabulary, manifest): index 2 is the manifest10texts = [ids for ids, _ in product_texts("validation", 100)] # the <sep> positions aren't needed: each text is scored whole111213def measure(skip=None):14 """Perplexity per token, and the average probability of the top token, with one block left out."""15 surprise, top, count = 0.0, 0.0, 016 for ids in texts:17 p = transformer.softmax(transformer.forward(ids, skip=skip)[:-1]) # [:-1] drops the last position: nothing follows it18 surprise -= np.log(p[np.arange(len(ids) - 1), ids[1:]]).sum() # position i predicts token i + 119 top += p.max(1).sum()20 count += len(ids) - 121 return np.exp(surprise / count), top / count # perplexity: exp of the average surprise per token222324print("tokens scored, names and descriptions:", f"{sum(len(ids) - 1 for ids in texts):,}")25for skip in [None] + list(range(layers)): # None keeps all four blocks: the full model26 label = "all blocks" if skip is None else f"without block {skip + 1}" # skip counts blocks from 0, so block skip + 1 is left out27 perplexity, top = measure(skip)28 print(f"{label}:", f"{perplexity:,.1f}")29 print(f"{label}, average probability of the top token:", f"{top:.2f}")
python skip-a-block.pytokens scored, names and descriptions: 7,624
all blocks: 24.3
all blocks, average probability of the top token: 0.42
without block 1: 17,896.9
without block 1, average probability of the top token: 0.21
without block 2: 77.8
without block 2, average probability of the top token: 0.29
without block 3: 64.3
without block 3, average probability of the top token: 0.34
without block 4: 77.3
without block 4, average probability of the top token: 0.37
Quitar el bloque 2, 3 o 4 más que duplica la perplejidad por token, de 24.3 con los cuatro bloques a 77.8, 64.3 y 77.3: cada bloque posterior aporta una parte de la capacidad del modelo, y ninguno es prescindible. Esta perplejidad abarca nombres y descripciones juntos, así que no se puede comparar con la línea base del capítulo 3 ni con el modelo de ventana del capítulo 5, que se puntúan solo con los nombres de validación. El capítulo 8 hace esa comparación.
Quitar el bloque 1 falla de otra manera. La perplejidad sube a 17,896.9, peor que adivinar al azar entre los 4,142 tokens posibles, que daría 4,142.
La razón está en lo que esperan los bloques posteriores. Se entrenaron con un flujo en el que el bloque 1 ya había escrito antes que ellos, y sin él leen vectores distintos a cualquiera que vieron en el entrenamiento. Sus predicciones se vuelven menos seguras, con la probabilidad media del token más probable bajando de 0.42 a 0.21, y asignan esa probabilidad a los tokens equivocados. El bloque 1 convierte los embeddings en bruto en la forma sobre la que se construye todo lo que sigue, en parte reuniendo contexto del texto anterior, como hicieron tres de las cabezas de primera capa del capítulo 6. Los bloques de un modelo entrenado no son módulos independientes: cada uno depende de lo que escriben los anteriores.
Regla práctica: Para saber qué hace una parte de un modelo, quítala y mide, en lugar de deducirlo de sus pesos. Espera que el primer bloque sea el que más importa, ya que todo lo posterior se construye sobre él; más allá de eso, mide, porque aquí el segundo y el último bloque importaron más o menos lo mismo, y más que el tercero. Interpreta con cuidado una pequeña pérdida al quitar una parte: las partes restantes se entrenaron junto con ella, así que la medición dice lo que el modelo entrenado necesita, no lo que la parte podría hacer por sí sola.
Mide lo que cuesta un detalle que no coincide
Cada detalle de un bloque tiene que coincidir con los pesos con los que se ejecuta, y una discrepancia no avisa: el modelo sigue produciendo probabilidades. Los detalles que más a menudo están mal al cargar los pesos de otro modelo se encuentran en RoPE, porque las implementaciones difieren en cómo emparejan los números y en su base, como la de SmolLM2 difiere de la del modelo de la tienda.
Un detalle erróneo de RoPE a la vez muestra lo que cuesta cada uno: puntúa los mismos 100 productos de validación con los pesos entrenados, emparejando números contiguos en lugar de mitades, con una base de 100,000, la de SmolLM2, en lugar de los 10,000 de la tienda, y sin RoPE en absoluto:
1"""Scores the same 100 validation products with the trained weights, changing one detail of RoPE at a time: how it pairs2numbers, its base, and whether it is applied at all. The prose's point rests on each variant's perplexity, printed3beside the trained model's."""4import numpy as np56from lib import transformer7from lib.products import product_texts89texts = [ids for ids, _ in product_texts("validation", 100)] # the <sep> positions aren't needed: each text is scored whole101112def neighbours(x, base=10000.0):13 """RoPE that pairs neighbouring numbers, (0, 1), (2, 3) and so on, instead of the first half with the second."""14 half = x.shape[-1] // 215 rotated = transformer.rope(np.concatenate([x[..., 0::2], x[..., 1::2]], axis=-1), base) # even numbers, then odd: rope pairs halves, so these are neighbours16 out = np.empty_like(x)17 out[..., 0::2], out[..., 1::2] = rotated[..., :half], rotated[..., half:] # each rotated number back where its dimension was18 return out192021for label, positions in [("as trained", transformer.rope),22 ("RoPE pairing neighbouring numbers", neighbours),23 ("RoPE with base 100,000", lambda x: transformer.rope(x, base=100000.0)), # 100,000 is SmolLM2's base24 ("no RoPE", lambda x: x)]: # no RoPE: the queries and keys pass through unrotated25 print(f"perplexity, {label}:", f"{transformer.perplexity(texts, positions=positions):,.1f}")
python mismatched-details.pyperplexity, as trained: 24.3
perplexity, RoPE pairing neighbouring numbers: 112.2
perplexity, RoPE with base 100,000: 26.4
perplexity, no RoPE: 182.0
La primera muestra de texto generado detectaría dos de las discrepancias. Emparejar números contiguos en lugar de mitades eleva la perplejidad de 24.3 a 112.2, y omitir RoPE la eleva a 182.0.
La base es la más peligrosa. Con 100,000 la perplejidad es 26.4, algo peor que 24.3, sin ningún error y con una salida que parece fluida, un fallo que podría llegar a producción.
La otra diferencia con SmolLM2 es la atención de consultas agrupadas: sus 15 cabezas de consulta comparten 5 conjuntos de claves y valores, de modo que sus matrices de claves y valores tienen un tercio del tamaño de su matriz de consultas (Ainslie et al., 2023). Cargar esos pesos en un modelo que espera una clave y un valor por cabeza falla con un error de forma, que es el tipo de discrepancia que conviene tener.
Regla práctica: Revisa la configuración de otro modelo frente a tu código, línea por línea, al cargar sus pesos: la normalización y su ε, el emparejamiento y la base de RoPE, la compuerta de la capa de avance, las salidas ligadas y cuántas cabezas comparten claves y valores. Después puntúa texto que conozcas frente a las salidas de la implementación original; una pérdida pequeña sin error es el caso que hay que temer.
Cuenta dónde van los parámetros
Con todas las partes construidas, cuenta lo que aprende el modelo y dónde lo aprende. Los parámetros de un modelo son su capacidad de aprender, y dónde se ubican indica en qué gasta esa capacidad. El recuento del modelo entrenado, por parte:
1"""Counts the store's model's parameters by part from its saved weights, and prints its settings. The prose's point2rests on the total, the feed-forward count and the embedding's share of it."""3from lib import transformer45weights, vocabulary, manifest = transformer.load()6settings = manifest["settings"]7# one table serves as input and output, so the embedding is counted once; a weight's group is the last part of its name8groups = {"embedding (shared with the output)": ["embedding"], "attention": ["q", "k", "v", "o"],9 "feed-forward": ["gate", "up", "down"], "normalization": ["norm1", "norm2", "final_norm"]}10for group, parts in groups.items():11 count = sum(v.size for k, v in weights.items() if k.split(".")[-1] in parts) # a weight's name ends in its part: layer3.q is attention's q12 print(f"{group}:", f"{count:,}")13print("total:", f"{sum(v.size for v in weights.values()):,}")14print("embedding's share of the total:", f"{weights['embedding'].size / sum(v.size for v in weights.values()):.0%}")15print("layers:", settings["layers"])16print("width:", settings["dimensions"]) # the width of the residual stream, which the manifest calls dimensions17print("heads:", settings["heads"])18print("feed-forward width:", settings["feed_forward"])19print("longest text, in tokens:", settings["longest"]) # longer texts were cut to this many tokens20print("vocabulary:", f"{len(vocabulary):,}") # the store tokenizer's tokens, plus the four markers
python transformer-parameters.pyembedding (shared with the output): 530,176
attention: 262,144
feed-forward: 540,672
normalization: 1,152
total: 1,334,144
embedding's share of the total: 40%
layers: 4
width: 128
heads: 4
feed-forward width: 352
longest text, in tokens: 160
vocabulary: 4,142
El modelo tiene 1,334,144 parámetros, algo menos que los 1,394,732 del modelo de ventana del capítulo 5. Los dos tienen un tamaño parecido, pero distribuyen sus parámetros de forma distinta. El modelo de ventana puso alrededor de tres cuartas partes de sus parámetros en su capa de salida y solo podía ver cuatro tokens hacia atrás. El transformador pone la mayoría de sus parámetros en sus bloques, 540,672 de ellos solo en las capas feed-forward. Comparte sus embeddings con la salida y puede ver todos los tokens anteriores en un texto de hasta 160 tokens.
La tabla de embeddings, compartida con la capa de salida, contiene 530,176 parámetros, es decir, 40% del total, porque tiene una fila de 128 números por cada uno de los 4,142 tokens. Esos son el vocabulario del tokenizador de la tienda más cuatro marcadores: inicio, separador, fin y relleno, que completa los textos cortos en un lote de entrenamiento. El capítulo 8 explica cómo se entrenó el modelo y lo mide frente a la línea base.
Regla práctica: Cuenta los parámetros por parte siempre que diseñes o cargues un modelo. En tamaños pequeños, la tabla de embeddings es una parte grande del total, así que átala a la capa de salida y elige el tamaño del vocabulario teniendo ese coste en cuenta, como hizo la elección de fusiones del capítulo 2.
Qué sale mal en producción
Las partes de un transformador tienen que encajar exactamente, y la mayoría de los fallos se deben a una parte que casi encaja:
- Los detalles que no coinciden pueden fallar en silencio. Dónde van las normas, cómo RoPE empareja los números y su base, si la capa de propagación hacia delante es con compuerta y si la salida está ligada tienen que coincidir con los pesos entrenados. Algunas diferencias dan resultados absurdos de inmediato; otras, como la base de RoPE medida aquí, cuestan un poco de precisión sin ningún error. Compara con salidas de referencia.
- Las longitudes superiores a las del entrenamiento no están probadas. RoPE da un ángulo para cualquier posición, pero un modelo entrenado con textos de hasta 160 tokens nunca ha aprendido a usar los ángulos más allá. Trata la longitud de entrenamiento como el límite del modelo hasta que hayas medido más allá de ella.
- Los valores grandes pueden desbordarse con precisión reducida. Los formatos con menos bits mantienen la misma precisión relativa en cada magnitud habitual, pero float16 no puede representar valores por encima de 65,504, y en formatos de 8 bits unos pocos valores atípicos grandes arruinan la precisión de todos los demás (Dettmers et al., 2022). El flujo del modelo de la tienda alcanza 50.6 para el producto medido aquí, muy lejos del límite de float16; revisa los valores más grandes del flujo de tu modelo antes de servirlo con menor precisión.
- Guarda las salidas de referencia junto con los pesos. Los resultados dependen de la máquina, como explica el capítulo 4, así que guarda juntos los pesos, las salidas de referencia y el script de entrenamiento exacto, y vuelve a ejecutar la comprobación después de cualquier cambio en el código o en las bibliotecas.
- Cada parte se ejecuta en cada posición. Las capas de propagación hacia delante cuestan lo mismo en cada posición, y el coste de la atención crece con el cuadrado de la longitud, como mostró el capítulo 6. Mide cuál domina en tus textos antes de optimizar cualquiera de los dos.
Lo que decidió este capítulo
- El transformador de la tienda usa el bloque al estilo LLaMA, en un tamaño de juguete: RMSNorm antes de cada parte, posiciones rotatorias en la atención, una capa feed-forward SiLU con compuerta y una capa de salida atada a los embeddings. Tiene 4 capas, un ancho de 128, 4 cabezas y un ancho feed-forward de 352. SmolLM2-360M tiene los mismos tipos de partes, más grande, con atención de consultas agrupadas y una base RoPE de 100,000.
- El paso hacia adelante en NumPy de
lib.transformeres la referencia del libro, comprobada contra el RMSNorm, la atención y la SiLU propios de PyTorch en cada posición de un producto de validación, hasta cuatro decimales. Todo ejemplo posterior que use el modelo lo ejecuta. - Cada bloque suma a la corriente residual, y cada parte lee una copia normalizada de ella, de modo que la corriente puede crecer a través de las capas mientras cada parte ve vectores de escala fija.
- Las partes se juzgan midiendo el modelo sin ellas, o con ellas modificadas. Quitar cualquier bloque empeora mucho el modelo de la tienda, y quitar el primero lo vuelve inútil, así que el libro trata los bloques de un modelo entrenado como un solo sistema. Una base RoPE incorrecta cuesta poco y no produce ningún error, por lo que los pesos cargados siempre se verifican contra salidas de referencia.
- El modelo tiene aproximadamente el tamaño del modelo de ventana del capítulo 5, con sus parámetros invertidos en los bloques en lugar de en la capa de salida. La tabla de embeddings, compartida con la salida, sigue siendo 40% de él, así que el tamaño del vocabulario sigue siendo un costo que el libro vigila.
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.