Dentro de un modelo abierto
Unos 22 minutos de lectura, con 7 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
- Cuenta los parámetros a escala
- Compara los tamaños de una familia
- Calcula lo que cuesta ejecutarlo
- Puntúa el texto de la tienda con un modelo general
- Encuentra las mismas cabezas a escala
- Prueba de copia a gran escala
- Sugerir la siguiente palabra a escala
- Pon los dos modelos uno al lado del otro
- Qué sale mal en producción
- Lo que decidió este capítulo
Al terminar este capítulo podrás leer un modelo de lenguaje abierto con lo que este libro ha construido: contar en qué se reparten sus parámetros, calcular cuánto cuesta ejecutarlo, puntuar texto con él de forma justa frente a un modelo con otro tokenizador, encontrar en sus cabezas los patrones de atención del capítulo 6, comprobar qué copia, y averiguar qué le aporta su tamaño con los textos de la tienda y qué no.
El capítulo 9 terminó con descripciones del propio modelo de la tienda, que necesitan comprobación antes de que nadie las lea. Ese modelo es el pequeño transformador que los capítulos 6 a 9 construyeron, entrenaron y usaron con un único catálogo de muebles y artículos para el hogar. SmolLM2-360M, un modelo abierto publicado por Hugging Face bajo la licencia Apache 2.0, está formado por las mismas piezas, como mostró el capítulo 7. Tiene más de doscientas veces más parámetros y se entrenó con 4 billones (4 × 10^12) de tokens (ficha del modelo) de texto web, código, matemáticas y libros de texto sintéticos (Allal et al., 2025, sección 6). La pregunta que se plantea este capítulo es si un modelo libre y descargable, entrenado con mucho más texto, podría hacer las tareas del modelo propio de la tienda: sugerir la siguiente palabra en el cuadro de búsqueda y predecir descripciones. El capítulo 2 leyó el tokenizador de SmolLM2; este capítulo lee el modelo.
Ejecutar SmolLM2 requiere PyTorch y una descarga de unos 0.7 gigabytes, con sus pesos almacenados como números de 16 bits, así que se ejecutó una sola vez, como los demás resultados grabados del libro. El script recordings/open_model.py cargó el modelo base, el entrenado únicamente para predecir el siguiente token, como lo estaba el modelo de la tienda, en una revisión fijada, es decir, una versión concreta de su repositorio. Lo ejecutó sobre el texto de la tienda y guardó lo que este capítulo lee: la forma de cada peso, sus puntuaciones sobre los nombres y descripciones de validación de la tienda, los hábitos de atención de sus cabezas, la prueba de copia del capítulo 6 y los prefijos del cuadro de búsqueda del capítulo 8. Un segundo script, recordings/open_model_family.py, descargó solo los archivos de configuración de los tres tamaños de SmolLM2, también en revisiones fijadas. Los ejemplos leen ambas grabaciones, en examples/data/recorded/, a través de lib.open_model.
Cuenta los parámetros a escala
Las partes resultan familiares, así que la primera pregunta es dónde se encuentran los parámetros. El capítulo 7 contó el modelo de la tienda por partes: 1,334,144 parámetros, de los cuales 40% están en la tabla de embeddings que comparte con su salida.
Haz el mismo recuento con los pesos registrados de SmolLM2 y observa qué parte concentra ahora la mayor cantidad:
1"""Counts SmolLM2-360M's recorded weights by part, with the embedding table shared with the output counted once.2The point that the feed-forward layers hold most of the parameters rests on the feed-forward line."""3import math45from lib import open_model67shapes = {name: shape for name, shape in open_model.read("parameters").items()8 if name != "lm_head.weight"} # the output layer is tied to the embeddings: the same weights, counted once9# A part is matched by name: a weight counts toward the part whose key appears in the weight's name.10parts = {"embedding (shared with the output)": ["embed_tokens"], "attention": ["q_proj", "k_proj", "v_proj", "o_proj"],11 "feed-forward": ["gate_proj", "up_proj", "down_proj"], "normalization": ["layernorm", "model.norm"]}12total = sum(math.prod(shape) for shape in shapes.values())13for part, keys in parts.items():14 count = sum(math.prod(shape) for name, shape in shapes.items() if any(key in name for key in keys))15 print(f"{part}:", f"{count:,}", f"({count / total:.0%})")16print("total:", f"{total:,}")17config = open_model.read("manifest")["config"] # the configuration recorded with the weights18print("layers:", config["num_hidden_layers"])19print("width:", config["hidden_size"])20print("query heads:", config["num_attention_heads"])21print("key and value heads:", config["num_key_value_heads"])22print("feed-forward width:", config["intermediate_size"])23print("vocabulary:", f"{config['vocab_size']:,}")24# Layer 0 stands for every layer: each layer's weights have the same shapes.25print("one layer's query weights:", shapes["model.layers.0.self_attn.q_proj.weight"])26print("one layer's key weights:", shapes["model.layers.0.self_attn.k_proj.weight"])
python open-model-parameters.pyembedding (shared with the output): 47,185,920 (13%)
attention: 78,643,200 (22%)
feed-forward: 235,929,600 (65%)
normalization: 62,400 (0%)
total: 361,821,120
layers: 32
width: 960
query heads: 15
key and value heads: 5
feed-forward width: 2560
vocabulary: 49,152
one layer's query weights: [960, 960]
one layer's key weights: [320, 960]
El equilibrio ha cambiado respecto al modelo de la tienda. Las capas de feed-forward contienen 235,929,600 (65%) de los 361,821,120 parámetros de SmolLM2. La tabla de embeddings, que sigue compartida con la salida, contiene 47,185,920 (13%), la atención 78,643,200 (22%), y la normalización apenas aporta nada. Los bloques crecen con el número de capas multiplicado por el cuadrado del ancho, mientras que la tabla de embeddings, para un vocabulario fijo, crece solo con el ancho; por eso, a medida que un modelo crece, los bloques pasan a dominar.
La atención tiene menos parámetros de los que tendrían 15 cabezas completas, debido a la atención de consultas agrupadas, que comparte cada cabeza de claves y valores entre varias cabezas de consulta. Cada capa tiene 15 cabezas de consulta, pero solo 5 cabezas de claves y valores, cada una compartida por 3 cabezas de consulta (Ainslie et al., 2023). Los pesos lo muestran. Los pesos de consulta de una capa tienen la forma [960, 960], y sus pesos de clave [320, 960], un tercio de esa cantidad de números. Por capa, siendo el tamaño de cabeza el ancho dividido entre el número de cabezas de consulta:
parámetros de atención = 2 × ancho² + 2 × ancho × cabezas de claves y valores × tamaño de cabeza
para los pesos de consulta y de salida, y después los pesos de clave y valor. Durante la generación, un modelo guarda las claves y los valores de cada capa para cada token anterior, así que compartirlos reduce ese almacenamiento, como mide una sección posterior; Ainslie y sus colegas comprobaron que cuesta poco en calidad.
Regla práctica: Cuenta los parámetros de un modelo abierto por partes a partir de sus pesos antes de usarlo, y lee las formas para identificar sus decisiones de diseño: embeddings atados, claves y valores agrupados, una capa de feed-forward con compuerta. Espera que sean los bloques, y no los embeddings, los que concentren la mayor parte de los parámetros de un modelo grande.
Compara los tamaños de una familia
SmolLM2 se presenta en tres tamaños, cada uno construido con las mismas piezas, y sus configuraciones muestran cómo los creadores de un modelo invierten más parámetros. Cada archivo de configuración indica las capas, el ancho, las cabezas y el ancho de la red de avance, y eso basta para contar cada parámetro, pieza por pieza, con la aritmética del capítulo 7 y la fórmula de arriba. lib.open_model.parameters lo hace.
Cuenta los tres tamaños a partir de sus configuraciones registradas, y verifica el recuento del modelo de 360M contra los pesos que guardó el primer registro:
1"""Counts all three SmolLM2 sizes from their recorded configurations, part by part, and checks the 360M model's count2against its recorded weights. The claim that the counts match the weights rests on the 360M parameters line and the last line."""3import math45from lib import open_model67for name in open_model.SIZES:8 config = open_model.config(name)9 parts = open_model.parameters(config) # the count by part, from the configuration alone, grouped keys and values included10 print(f"{name}, layers:", config["num_hidden_layers"])11 print(f"{name}, width:", f"{config['hidden_size']:,}")12 print(f"{name}, query heads:", config["num_attention_heads"])13 print(f"{name}, query heads per key and value head:", config["num_attention_heads"] // config["num_key_value_heads"]) # query heads sharing each key and value head14 print(f"{name}, feed-forward width:", f"{config['intermediate_size']:,}")15 print(f"{name}, RoPE base:", f"{config['rope_theta']:,}") # the rotary base: a larger base makes positions turn more slowly16 print(f"{name}, parameters:", f"{parts['total']:,}")17 print(f"{name}, embedding's share:", f"{parts['embedding'] / parts['total']:.0%}")18# The output layer is tied to the embeddings, so its weights are skipped: the shared weights are counted once.19recorded = sum(math.prod(shape) for key, shape in open_model.read("parameters").items() if key != "lm_head.weight")20print("SmolLM2-360M, parameters in the recorded weights:", f"{recorded:,}")
python open-model-family.pySmolLM2-135M, layers: 30
SmolLM2-135M, width: 576
SmolLM2-135M, query heads: 9
SmolLM2-135M, query heads per key and value head: 3
SmolLM2-135M, feed-forward width: 1,536
SmolLM2-135M, RoPE base: 100,000
SmolLM2-135M, parameters: 134,515,008
SmolLM2-135M, embedding's share: 21%
SmolLM2-360M, layers: 32
SmolLM2-360M, width: 960
SmolLM2-360M, query heads: 15
SmolLM2-360M, query heads per key and value head: 3
SmolLM2-360M, feed-forward width: 2,560
SmolLM2-360M, RoPE base: 100,000
SmolLM2-360M, parameters: 361,821,120
SmolLM2-360M, embedding's share: 13%
SmolLM2-1.7B, layers: 24
SmolLM2-1.7B, width: 2,048
SmolLM2-1.7B, query heads: 32
SmolLM2-1.7B, query heads per key and value head: 1
SmolLM2-1.7B, feed-forward width: 8,192
SmolLM2-1.7B, RoPE base: 130,000
SmolLM2-1.7B, parameters: 1,711,376,384
SmolLM2-1.7B, embedding's share: 6%
SmolLM2-360M, parameters in the recorded weights: 361,821,120
El recuento a partir de la configuración del modelo de 360M coincide exactamente con sus pesos registrados: 361,821,120 contados frente a 361,821,120 registrados. El ancho, no la profundidad, es donde fue a parar la mayor parte de los parámetros adicionales del modelo más grande: SmolLM2-1.7B tiene 24 capas, menos que las 30 y 32 de los dos tamaños menores, con un ancho de 2,048, mucho mayor que los 576 y 960 de los otros.
La proporción de la tabla de embeddings cae a medida que los modelos crecen, de 21% a 13% y a 6%, porque los tres comparten un mismo vocabulario mientras sus bloques crecen. Y el más grande difiere en algo más que su tamaño. No agrupa claves y valores, y tiene 1 cabeza de consulta por cada cabeza de clave y valor, mientras que los dos más pequeños comparten cada una entre 3. Su capa de red de avance tiene un ancho de 8,192, cuatro veces su ancho, mientras que la del modelo de 360M es de 2,560, 8/3 de su ancho. Y sus posiciones rotatorias giran más lentamente, con una base de 130,000 frente a 100,000.
Regla práctica: Cuenta los parámetros de un modelo a partir de su configuración, y verifica el recuento contra sus pesos; una discrepancia significa que has leído mal algún detalle. Compara los tamaños de una familia para ver cómo sus creadores escalaron el diseño, y no des por hecho que un modelo más grande se diferencia de uno más pequeño solo en tamaño.
Calcula lo que cuesta ejecutarlo
Los parámetros fijan lo que un modelo puede aprender; también fijan lo que cuesta ejecutarlo. Sus pesos tienen que estar en memoria, a dos bytes cada uno en los formatos de 16 bits, la forma en que se almacenan los pesos de SmolLM2 (tarjeta del modelo). Y durante la generación, como señaló el capítulo 9, cada capa guarda una clave y un valor por cada token anterior, para que cada nuevo token no repita el trabajo del texto previo. La caché de claves y valores, las claves y los valores de cada capa para los tokens anteriores, crece con la longitud del texto:
caché por token, en bytes = capas × 2 × cabezas de clave y valor × tamaño de cabeza × 2
contando una clave y un valor por capa, y dos bytes por número.
Para presupuestar las necesidades, en cada tamaño hacen falta los pesos, la caché por token y la caché para el texto más largo para el que están configurados los modelos, 8,192 tokens, con y sin claves y valores agrupados:
1"""Works out each size's weights and key and value cache, with and without grouped keys and values, in decimal gigabytes2and kilobytes. The point that grouping cuts the 360M model's cache to a third rests on its two cache lines for the longest text."""3from lib import open_model45longest = open_model.config("SmolLM2-360M")["max_position_embeddings"] # the longest text the models are set up for6print("longest text, in tokens:", f"{longest:,}")7for name in open_model.SIZES:8 config = open_model.config(name)9 head_size = config["hidden_size"] // config["num_attention_heads"] # the width shared out over the query heads, grouped or not10 weights = open_model.parameters(config)["total"] * 2 # 16-bit numbers: 2 bytes each11 cache = config["num_hidden_layers"] * 2 * config["num_key_value_heads"] * head_size * 2 # a key and a value per layer, 2 bytes each12 # The same cache with every query head keeping its own key and value.13 ungrouped = config["num_hidden_layers"] * 2 * config["num_attention_heads"] * head_size * 214 # Decimal units: a gigabyte is 1e9 bytes and a kilobyte 1e3 bytes.15 print(f"{name}, weights in 16-bit numbers, in GB:", f"{weights / 1e9:.1f}")16 print(f"{name}, key and value cache per token, in KB:", f"{cache / 1e3:.0f}")17 print(f"{name}, cache for the longest text, in GB:", f"{cache * longest / 1e9:.2f}")18 print(f"{name}, cache for the longest text without grouping, in GB:", f"{ungrouped * longest / 1e9:.2f}")
python open-model-memory.pylongest text, in tokens: 8,192
SmolLM2-135M, weights in 16-bit numbers, in GB: 0.3
SmolLM2-135M, key and value cache per token, in KB: 23
SmolLM2-135M, cache for the longest text, in GB: 0.19
SmolLM2-135M, cache for the longest text without grouping, in GB: 0.57
SmolLM2-360M, weights in 16-bit numbers, in GB: 0.7
SmolLM2-360M, key and value cache per token, in KB: 41
SmolLM2-360M, cache for the longest text, in GB: 0.34
SmolLM2-360M, cache for the longest text without grouping, in GB: 1.01
SmolLM2-1.7B, weights in 16-bit numbers, in GB: 3.4
SmolLM2-1.7B, key and value cache per token, in KB: 197
SmolLM2-1.7B, cache for the longest text, in GB: 1.61
SmolLM2-1.7B, cache for the longest text without grouping, in GB: 1.61
Agrupar claves y valores mantiene pequeña la caché del modelo de 360M. Necesita 41 kilobytes por token, así que un texto de la longitud máxima necesita 0.34 gigabytes, un tercio de los 1.01 que necesitaría sin agrupación.
Un servicio que escribe muchas descripciones a la vez mantiene una caché por texto, así que con textos largos las cachés pueden superar a los pesos. El modelo de 1.7B, que no agrupa claves y valores, necesita 197 kilobytes por token, y 1.61 gigabytes para un texto largo, alrededor de la mitad de sus 3.4 gigabytes de pesos.
Regla práctica: Presupuesta la memoria de un modelo como sus pesos más una caché por cada texto en curso, calculada a partir de su configuración. Prefiere modelos que agrupen claves y valores cuando sirvas textos largos o muchos a la vez, y limita la longitud de texto que permites a la que hayas presupuestado.
Puntúa el texto de la tienda con un modelo general
Un modelo con doscientas veces los parámetros, entrenado con más de un millón de veces más tokens que el catálogo de la tienda, cabría esperar que prediga el texto de la tienda mejor que el modelo pequeño propio de la tienda. Comprobarlo requiere cuidado, porque los dos modelos usan tokenizadores distintos: el vocabulario de 49,152 tokens de SmolLM2 divide el texto de otra manera que el de la tienda, así que sus perplejidades por token cuentan cosas distintas. Lo que comparten es el texto. Una perplejidad por palabra divide la log-probabilidad total que un modelo asigna a un texto entre el número de palabras que tiene, en lugar de entre su número de tokens. En símbolos, para un texto de W palabras a cuyos tokens el modelo asigna probabilidades p₁ a pₙ, sea cual sea el número de tokens:
perplejidad por palabra = exp(−(log p₁ + … + log pₙ) / W)
Dividir el total de cada modelo entre el mismo número de palabras pone a los dos en una misma escala, sin importar cuántos tokens gasta cada uno.
Cada modelo puntúa los mismos eventos. Para un nombre, el modelo de la tienda parte de <s> y SmolLM2 de su propio token de inicio, <|endoftext|>, y ambos predicen las palabras del nombre y luego su final: <sep> para el modelo de la tienda, un salto de línea para SmolLM2. Para una descripción, a ambos se les da el nombre y predicen las palabras de la descripción y su final. Los nombres son los primeros 500 nombres de validación, y las descripciones son los 446 productos del capítulo 8. La grabación también puntuó cada nombre precedido de una etiqueta, Product name: , para comprobar si decirle a SmolLM2 lo que está leyendo le ayuda.
¿Qué modelo puntúa mejor los nombres de la tienda por palabra, y por cuánto? Decide antes de seguir leyendo. Luego calcula las puntuaciones del modelo de la tienda en NumPy, lee las de SmolLM2 de la grabación, y compáralas por token y por palabra:
1"""Scores the store's model and SmolLM2-360M on the same names and the same descriptions, per word, the unit the two share.2The point that the small model wins on both kinds of text rests on the per-word lines for names and for descriptions."""3import math45from lib import bpe, open_model, transformer6from lib.products import product_texts7from lib.store import load_products89_, vocabulary, _ = transformer.load() # load() returns the weights, the vocabulary and the manifest; only the vocabulary is used10index = {token: i for i, token in enumerate(vocabulary)}11scores, tokenizer = open_model.read("scores"), bpe.store_tokenizer()12per = lambda log_p, count: f"{math.exp(-log_p / count):,.1f}" # perplexity: e to the average negative log-probability per count1314# Names: each name's tokens and its end (<sep> for the store's model, a newline for SmolLM2), from the start token.15names = list(load_products("validation")["name"])[:len(scores["names"])] # as many names as SmolLM2 was scored on, from the top of the split16# The start marker, the name's tokens and <sep>: the model scores everything after the start marker.17encoded = [[index[transformer.START]] + [index[t] for t in tokenizer.encode(name)] + [index[transformer.SEP]] for name in names]18store = sum(transformer.total_log_probability(ids, 1) for ids in encoded) # scores ids[1:], every token after <s>19smollm2 = sum(row["log_p"] for row in scores["names"])20# Words are whitespace-separated, as the recording counted them; both models are divided by the same count.21words = sum(row["words"] for row in scores["names"])22print("validation names scored:", len(names))23print("names, per-token perplexity, the store's model:", per(store, sum(len(ids) - 1 for ids in encoded))) # all but <s>24print("names, per-token perplexity, SmolLM2-360M:", per(smollm2, sum(row["tokens"] for row in scores["names"]))) # SmolLM2's own count25print("names, per-word perplexity, the store's model:", per(store, words))26print("names, per-word perplexity, SmolLM2-360M:", per(smollm2, words))27# The label is context for the recording and is not scored; the same words count.28print("names after a label, per-word perplexity, SmolLM2-360M:", per(sum(r["log_p"] for r in scores["labelled names"]), words))2930# Descriptions: chapter 8's products, each description's tokens and its end, given the name.31end = index[transformer.END] # the end marker closes a description32# The first 500 validation products. Keeps those whose text ends rather than being cut at the length limit, and that have33# at least one description token after <sep>. Scores from sep + 1: the description and its end, given everything up to <sep>.34store = sum(transformer.total_log_probability(ids, sep + 1) for ids, sep in product_texts("validation", 500)35 if ids[-1] == end and sep < len(ids) - 2)36words = sum(row["words"] for row in scores["descriptions"])37print("descriptions scored:", len(scores["descriptions"]))38print("descriptions, per-word perplexity, the store's model:", per(store, words))39print("descriptions, per-word perplexity, SmolLM2-360M:", per(sum(r["log_p"] for r in scores["descriptions"]), words))
python open-model-on-the-store.pyvalidation names scored: 500
names, per-token perplexity, the store's model: 25.8
names, per-token perplexity, SmolLM2-360M: 564.8
names, per-word perplexity, the store's model: 199.3
names, per-word perplexity, SmolLM2-360M: 54,352.8
names after a label, per-word perplexity, SmolLM2-360M: 67,101.5
descriptions scored: 446
descriptions, per-word perplexity, the store's model: 37.0
descriptions, per-word perplexity, SmolLM2-360M: 61.2
El modelo pequeño gana en ambos tipos de texto, por un margen amplio en los nombres. Por palabra, el modelo de la tienda obtiene 199.3 en los nombres frente a 54,352.8 de SmolLM2, y 37.0 en las descripciones frente a 61.2. Por token, en estos nombres, el modelo de la tienda obtiene 25.8 y SmolLM2 564.8. La medición por token oculta la diferencia, porque SmolLM2 gasta más tokens en cada palabra de la tienda.
Decirle a SmolLM2 que está leyendo el nombre de un producto no cierra la diferencia. Tras la etiqueta, puntúa 67,101.5 por palabra, sin mejorar respecto a no usarla. Así que la diferencia no está en que SmolLM2 no sepa que viene un nombre; está en los propios nombres. Nuestra valoración, no comprobada aquí, es que dos rasgos del texto de la tienda explican buena parte de ello: muchos nombres empiezan por el nombre inventado de una línea de producto, que el modelo de la tienda ha visto a lo largo de su catálogo, y el texto de la tienda está en minúsculas y con espacios alrededor de los signos de puntuación, a diferencia de la mayor parte de lo que aprendió SmolLM2.
La lección no es que los modelos pequeños sean mejores. Un modelo predice mejor el tipo de texto del que aprendió: SmolLM2 conoce mucho más inglés que el modelo de la tienda, y poco de los hábitos de la tienda. Enseñarle esos hábitos requiere más entrenamiento con el texto de la tienda, que describe el capítulo 11.
Regla práctica: Compara modelos con tokenizadores distintos por palabra, o por carácter, sobre exactamente el mismo texto y los mismos eventos, nunca por token. Antes de elegir un modelo general grande frente a uno pequeño entrenado con tu propio texto, mide ambos con tu texto; el tamaño no compensa un texto que no se parece en nada a lo que aprendió el modelo.
Encuentra las mismas cabezas a escala
El capítulo 6 midió las cabezas del modelo de la tienda según sus hábitos, frente a una distribución uniforme, que pone 1 / (i + 1) del peso de una posición en cada uno de los i + 1 tokens que la posición i puede ver. Las mismas medidas funcionan en cualquier modelo, y SmolLM2 tiene 480 cabezas que medir.
Observa el peso medio registrado de cada cabeza sobre el token anterior y sobre el primer token, en los primeros 50 de los 446 productos puntuados arriba, donde cada texto consta de un nombre, un salto de línea y su descripción. La distribución uniforme se promedia de la misma manera, así que ambas pueden compararse lado a lado:
1"""Reads SmolLM2's recorded head averages over the recorded texts, and compares them with an even spread averaged the same way.2The point that a few heads specialize and many put their weight on the first token rests on the head counts and the first-token averages."""3import numpy as np4from tokenizers import Tokenizer56from lib import open_model, transformer7from lib.products import product_texts8from lib.store import load_products910heads = open_model.read("heads")11previous, first = np.array(heads["previous"]), np.array(heads["first"]) # (layers, heads)12print("texts averaged:", heads["texts"])13print("heads in all:", previous.size)14print("heads with more than half their weight on the previous token:", int((previous > 0.5).sum())) # a position's weights sum to 1, so above 0.5 is most of it15print("the most weight a head puts on the previous token:", f"{previous.max():.2f}")16print("average weight on the first token, layers 1 to 4:", f"{first[:4].mean():.2f}") # rows count layers from 0: rows 0 to 317print("average weight on the first token, layers 5 to 32:", f"{first[4:].mean():.2f}") # rows from 4 on are layers 5 to 3218print("heads with more than half their weight on the first token:", int((first > 0.5).sum()))1920# An even spread, averaged the same way: each position i shares its weight equally among the i + 1 tokens it sees.21smollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json")22end = transformer.load()[1].index(transformer.END) # [1] is the vocabulary: load() returns weights, vocabulary, manifest23rows = load_products("validation").head(500) # the first 500 validation products, the ones product_texts reads24# The same products as product_texts, with their names and descriptions, filtered the same way. Each text is a name, a newline25# and a description, as the recording wrote it.26texts = [f"{name}\n{description}\n" for (ids, sep), name, description in27 zip(product_texts("validation", 500), rows["name"], rows["description"]) if ids[-1] == end and sep < len(ids) - 2]28# Only the texts the recording averaged. The +1 is the start token the recording put before every text.29lengths = [len(smollm2.encode(text, add_special_tokens=False).ids) + 1 for text in texts[:heads["texts"]]]30# A position with k tokens to see gives an even spread 1 / k on each of them. k runs from 2 to the text's length.31print("an even spread's weight on the previous token, and on the first:",32 f"{np.mean([np.mean(1 / np.arange(2, n + 1)) for n in lengths]):.2f}")
python open-model-heads.pytexts averaged: 50
heads in all: 480
heads with more than half their weight on the previous token: 3
the most weight a head puts on the previous token: 0.79
average weight on the first token, layers 1 to 4: 0.13
average weight on the first token, layers 5 to 32: 0.61
heads with more than half their weight on the first token: 286
an even spread's weight on the previous token, and on the first: 0.05
Algunas cabezas se especializan con fuerza. 3 cabezas ponen más de la mitad de su peso en el token anterior, y la más fuerte pone 0.79 ahí, frente a los 0.05 de una distribución uniforme. La cabeza de token anterior más destacada del modelo de la tienda, medida de la misma forma, puso 0.35 en el token anterior. Con cientos de cabezas, un modelo puede permitirse asignar a unas pocas un trabajo concreto y estrecho.
El peso sobre el primer token es la sorpresa mayor. En las cuatro primeras capas, las cabezas ponen 0.13 de su peso en él de media; desde la capa 5 en adelante, 0.61, frente al 0.05 de una distribución uniforme, y 286 cabezas ponen ahí más de la mitad. Es el sumidero de atención que Xiao y colaboradores encontraron en modelos grandes (Xiao et al., 2024). Lo explican por la softmax: una cabeza sin nada útil a lo que atender aún debe colocar su peso en algún sitio, y el primer token siempre está presente. El capítulo 6 encontró el patrón solo débilmente en el modelo de la tienda, cuyos tokens de descripción ponen 0.11 de su atención en sus dos marcadores, frente a un 0.05 de una distribución uniforme.
Regla práctica: Describe las cabezas de un modelo grande con los mismos promedios medidos que usarías en uno pequeño, comparados con una distribución uniforme. Espera unas cuantas cabezas especializadas y muchas que pongan su peso en el primer token, y conserva ese token cuando recortes el contexto de un modelo para ahorrar memoria.
Prueba de copia a gran escala
El capítulo 6 mostró cómo el modelo de la tienda copia cover desde el nombre de un producto hacia su descripción, al cambiar el nombre y observar cómo la predicción lo seguía. La misma prueba pregunta si SmolLM2 también lo hace. No se puede comprobar si su texto de entrenamiento contenía el texto de este producto, y la prueba no lo necesita: si SmolLM2 predijera cover a partir de la memoria del producto, quitar cover del nombre no cambiaría la predicción.
Verifica las probabilidades registradas de SmolLM2 para cover y set en un punto de la descripción de double chaise patio furniture cover, después de this outdoor patio furniture, con el nombre tal como se vende, sin cover, y terminando en set:
1"""Prints SmolLM2's recorded probabilities of cover and set after the same words of a description, under three versions of the name.2The point that each word follows its own name rests on the cover lines for the name as sold and without cover, and the set line for the name ending in set."""3from lib import open_model45copying = open_model.read("copying") # keyed by the version of the name, each with the probabilities of the tokens after the same words6for label, probabilities in copying.items():7 for token, p in probabilities.items():8 print(f"SmolLM2-360M, {label}, P({token.strip()}):", f"{p:.2f}") # the recorded tokens carry the space before them; strip removes it
python open-model-copying.pySmolLM2-360M, name as sold, P(cover): 0.75
SmolLM2-360M, name as sold, P(set): 0.00
SmolLM2-360M, name without cover, P(cover): 0.02
SmolLM2-360M, name without cover, P(set): 0.02
SmolLM2-360M, name ending in set, P(cover): 0.01
SmolLM2-360M, name ending in set, P(set): 0.77
Ambos modelos copian la siguiente palabra de una frase anterior cuando la frase se repite. Con el nombre tal como se vende, SmolLM2 da cover 0.75. Si quitas cover del nombre, baja a 0.02; si terminas el nombre en set, set obtiene 0.77.
El modelo de la tienda se comportó igual, con 0.97, 0.00 y 0.70 para el nombre que termina en set. Esa copia es el comportamiento de las cabezas de inducción, cabezas que encuentran una copia anterior del token actual y atienden a lo que lo siguió. Olsson y sus colegas las encontraron en todos los modelos que estudiaron con más de una capa (Olsson et al., 2022).
Así, la copia no es algo que aporte la escala; el modelo de 4 capas de la tienda también la aprendió. Para una tienda como esta, el hábito es a la vez útil y arriesgado: un modelo que copia palabras del nombre del producto se mantiene en el producto, y uno que copia del texto del producto equivocado propaga su error.
Regla práctica: Prueba un comportamiento cambiando la entrada y observando la salida, y ejecuta la misma prueba en cada modelo que compares. Cuando dos modelos de tamaños muy distintos comparten un comportamiento, es un comportamiento básico; busca qué es lo que difiere en otros aspectos.
Sugerir la siguiente palabra a escala
El cuadro de búsqueda es donde más importa el texto de la tienda. Capítulo 8 mostró que el modelo de la tienda, por sí solo, le asignaba a stool una probabilidad de 0.50 después de outdoor bar, y que la mezcla del modelo de la tienda con sus recuentos, el modelo que sirve el cuadro de búsqueda, le asignaba 0.28.
Estos son los tres tokens siguientes más probables de SmolLM2 después de los mismos cinco prefijos, cada uno dado sin nada antes, tal como el modelo de la tienda los obtuvo:
1"""Prints SmolLM2's three likeliest next tokens after five search-box prefixes, and its probability of stool after outdoor bar.2The point that its suggestions are the wrong text rests on the top token after each prefix, and on the stool line."""3from lib import open_model45for prefix, recorded in open_model.read("prefixes").items():6 shown = ", ".join(f"{token!r} {p:.2f}" for token, p in recorded["top"][:3]) # the three likeliest tokens, as recorded7 print(f"{prefix:<12} -> {shown}")8# The recorded key keeps the space before stool. Four places: at two, this probability would print as 0.00.9print("P(stool | outdoor bar), SmolLM2-360M:", f"{open_model.read('prefixes')['outdoor bar']['P( stool)']:.4f}")
python open-model-autocomplete.pybar -> 'ry' 0.05, 'ley' 0.05, 'b' 0.04
patio bar -> '\n' 0.21, 'be' 0.06, ',' 0.06
outdoor bar -> '\n' 0.28, ',' 0.06, '\n\n' 0.04
kitchen bar -> '\n' 0.37, '\n\n' 0.03, ',' 0.02
wine bar -> '\n' 0.20, ',' 0.09, '\n\n' 0.03
P(stool | outdoor bar), SmolLM2-360M: 0.0002
Las sugerencias de SmolLM2 se leen como inglés general, no como el cuadro de búsqueda de la tienda. Después de outdoor bar, patio bar, kitchen bar y wine bar, su token siguiente más probable es un salto de línea: trata cada prefijo como una línea completa, probablemente porque en gran parte del texto con el que se entrenó, las líneas cortas como estas terminan con un salto de línea. Su probabilidad de stool después de outdoor bar es 0.0002. Después de bar por sí solo, sugiere fragmentos de palabras más largas, como ry y ley, como en barry o barley. Nada de eso es un inglés incorrecto; es el texto equivocado. Un cuadro de búsqueda necesita los hábitos de la tienda, y los propios modelos de la tienda los tienen. Además, un cuadro de búsqueda tiene que responder en el tiempo de una pulsación de tecla, y el modelo de la tienda realiza una pequeña fracción de la aritmética de SmolLM2 por token.
Regla práctica: No pongas un modelo general delante de los compradores sin medir sus sugerencias sobre tus propios prefijos frente a lo que ya tienes. Cuando un modelo entrenado con tu texto sugiera mejor, consérvalo, y mide un modelo general en las tareas donde su conocimiento más amplio podría importar.
Pon los dos modelos uno al lado del otro
Una vez tomadas todas las medidas, los dos modelos pueden compararse en una sola tabla. El modelo de la tienda es el propio del libro, medido en los capítulos 6 a 8; SmolLM2-360M se lee de sus registros en este capítulo.
| El modelo de la tienda | SmolLM2-360M | |
|---|---|---|
| Parámetros | 1,334,144 | 361,821,120 |
| Capas y anchura | 4 capas, 128 de anchura | 32 capas, 960 de anchura |
| Cabezas de consulta, y cabezas de clave y valor, por capa | 4 y 4 | 15 y 5 |
| Vocabulario | 4,142 | 49,152 |
| Texto, en tokens: el catálogo, o tokens con los que se entrenó | 2,843,222, el catálogo de la tienda | 4 billones (4 × 10^12) |
| Perplejidad por palabra en los nombres de la tienda | 199.3 | 54,352.8 |
| Perplejidad por palabra en las descripciones de la tienda | 37.0 | 61.2 |
P(cover) cuando la descripción repite el nombre |
0.97 | 0.75 |
| El mayor peso que un cabezal pone en el token anterior | 0.35 | 0.79 |
Lee las columnas de arriba abajo y verás el patrón de este capítulo. SmolLM2 es mucho mayor en todas las medidas de tamaño, y ambos modelos han aprendido los mismos comportamientos básicos: copiar y atender al token anterior. Todo lo que tiene que ver con el texto propio de la tienda favorece al modelo pequeño, porque eso es todo lo que aprendió. La elección de la tienda no es entre un modelo pequeño y uno grande; es qué trabajo hace cada uno.
Regla práctica: Pon uno al lado del otro todos los modelos entre los que estés eligiendo, según las medidas que importan para tus trabajos, con el mismo texto y las mismas pruebas en cada columna. Elige un modelo por trabajo, no un solo modelo para todo.
Qué sale mal en producción
Un modelo abierto trae consigo las decisiones de sus creadores, y no las anuncia:
- Su texto no es tu texto. SmolLM2 puntuó los nombres de la tienda muchísimo peor que el pequeño modelo propio de la tienda, y una etiqueta no ayudó. Mide cualquier modelo con tu propio texto antes de confiar en él para ese uso.
- Su tokenizer no es el tuyo. Las cifras por token de dos tokenizers no se pueden comparar; puntúa por palabra o por carácter, sobre los mismos eventos.
- Los detalles de un modelo tienen que coincidir con el código que lo ejecuta. Las claves y valores agrupados, una base RoPE de 100,000 y los embeddings ligados están todos en la configuración de SmolLM2-360M. El capítulo 7 midió lo que cuesta una base RoPE incorrecta: un poco de precisión y ningún error. Carga los modelos con el código que publican sus creadores, en una versión fijada, o comprueba cada detalle frente a él.
- Las revisiones cambian. El repositorio de un modelo puede actualizarse con el mismo nombre. Fija la revisión, como hace
recordings/open_model.py, y regístrala con cada resultado. - El primer token importa. La mayoría de las cabezas posteriores de SmolLM2 dependen del primer token. Consérvalo cuando recortes el contexto, y nunca dejes que una canalización lo descarte en silencio.
- El tamaño marca la velocidad. Cada token generado recorre todas las capas, así que un modelo cientos de veces más grande necesita cientos de veces más operaciones por token. Mide el tiempo por token en la máquina en la que vas a servir, con las longitudes de texto que vas a servir, antes de prometer un tiempo de respuesta.
- La licencia y los términos acompañan al modelo. SmolLM2 usa Apache 2.0; otros modelos abiertos tienen otros términos. Comprueba la licencia del modelo y la revisión exactos antes de construir sobre ellos.
Lo que decidió este capítulo
- El modelo abierto del libro es SmolLM2-360M, leído a partir de dos registros en revisiones fijadas: su ejecución sobre el texto de la tienda y las configuraciones de su familia. Cada ejemplo se ejecuta sin PyTorch ni descarga, y los resultados pueden verificarse contra lo registrado.
- Los modelos con tokenizers distintos se comparan por palabra, sobre el mismo texto y los mismos eventos: las palabras de cada nombre y su final, desde el token de inicio; las palabras de cada descripción y su final, dado el nombre.
- Sobre el texto de la tienda, el modelo pequeño de la tienda supera a SmolLM2, 199.3 frente a 54,352.8 por palabra en los nombres, y 37.0 frente a 61.2 en las descripciones. El cuadro de búsqueda conserva la mezcla del modelo de la tienda y sus recuentos que eligió el capítulo 8.
- Las cabezas se comparan entre modelos con las mismas medidas, frente a una distribución uniforme. SmolLM2 muestra los dos patrones del capítulo 6, de forma más marcada: unas pocas cabezas que se especializan en el token anterior, y muchas que concentran su peso en el primer token.
- Copiar de lo que aparece antes en un texto es algo básico, compartido por un modelo de 4 capas y otro de 32 capas, y probado del mismo modo en ambos.
- El coste de un modelo se calcula a partir de su configuración antes de ponerlo en servicio: sus pesos, más una caché de claves y valores por cada texto en curso. Entre los tamaños de SmolLM2, las claves y valores agrupados reducen a un tercio la caché del modelo de 360M.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 7 de 7 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.