Entrenamiento de un modelo pequeño

Unos 23 minutos de lectura, con 7 ejemplos en 10 secciones.

Edición 2026.11.16 Ejemplos verificados el 19 de nov de 2026 86 de 86 ejemplos pasan Qué ha cambiado

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

Al final de este capítulo podrás entrenar un pequeño transformer de principio a fin y juzgar el resultado. Aprenderás a convertir textos en lotes, actualizar los pesos con AdamW, fijar la programación del tamaño de paso, leer la curva de entrenamiento, medir el modelo de forma justa frente a la línea base por conteo y descubrir qué aportan a esta escala más anchura, más texto y más entrenamiento, así como dónde el modelo supera al conteo y dónde necesita el conteo a su lado.

Capítulo 7 armó el modelo de la tienda y usó sus pesos entrenados para verificar cada parte. Este capítulo pregunta de dónde salieron esos pesos: de una sola ejecución de entrenamiento, registrada en recordings/transformer.py. Esa ejecución enseñó al modelo a predecir cada token siguiente del catálogo de la tienda: los nombres y las descripciones de los muebles y artículos para el hogar que vende en línea. Después, el capítulo mide el modelo en los dos usos para los que sirve: sugerir la siguiente palabra del nombre de un producto en el cuadro de búsqueda y predecir descripciones, donde el texto es lo bastante largo como para que importe el contexto lejano.

Como en el capítulo 5, el entrenamiento se ejecutó una vez, en PyTorch. Los ejemplos leen lo que guardó: los pesos, las curvas y la configuración, registrados en el manifiesto de la ejecución. Para entrenarlo tú mismo, instala recordings/requirements.txt en su propio entorno, lo que añade la versión de PyTorch para CPU, y ejecuta python recordings/transformer.py desde la carpeta del libro: escribe los mismos archivos en examples/data/recorded/transformer/ y funciona en el procesador de una laptop.

Convierte productos en lotes

Último cambio en la edición 2026.11.16

El entrenamiento empieza convirtiendo el catálogo de la tienda en números de los que el modelo puede aprender. Cada producto se convierte en un texto: el marcador de inicio, el nombre, el separador <sep>, la descripción y el marcador de fin, tokenizados con el tokenizador de la tienda. Un texto más largo que el límite del modelo se corta. Cada paso de entrenamiento toma un lote de textos a la vez, para que la aritmética se ejecute sobre matrices completas, y los textos de distinta longitud se rellenan hasta el más largo del lote con un token de relleno.

Cada texto da entonces al modelo una predicción por posición. Las entradas son los tokens de un texto sin el último, y los objetivos son los tokens del texto sin el primero, de modo que la posición i se entrena para predecir el token i + 1. Gracias a la máscara causal, un solo pase hacia delante hace todas esas predicciones a la vez. La pérdida se promedia sobre los objetivos que no son relleno: el relleno cuesta cómputo pero no enseña nada.

El relleno es el coste que hay que vigilar, así que construye los lotes de una época mezclada como lo hace el script de entrenamiento, y cuenta cuánto de cada lote es relleno:

training-batches.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Builds one shuffled epoch of batches the way the training script does, and measures the padding in them.The prose's point rests on the share of targets that are padding over that epoch."""import mathimport numpy as npfrom lib import transformerfrom lib.products import product_texts_, vocabulary, manifest = transformer.load()settings = manifest["settings"]pad, end = vocabulary.index(transformer.PAD), vocabulary.index(transformer.END)texts = [ids for ids, _ in product_texts("train")]size = settings["batch"]order = np.random.default_rng(settings["seed"]).permutation(len(texts))   # one shuffled epoch, from the run's seed, so it repeatspadding, targets_seen, shares = 0, 0, []for start in range(0, len(texts), size):    batch = [texts[i] for i in order[start:start + size]]                      # this step's texts: the next `size` in the shuffled order    longest = max(len(ids) for ids in batch)    padded = np.array([ids + [pad] * (longest - len(ids)) for ids in batch])   # short texts filled out with <pad>    inputs, targets = padded[:, :-1], padded[:, 1:]                            # each position predicts the next token    padding, targets_seen = padding + (targets == pad).sum(), targets_seen + targets.size    shares.append((targets == pad).mean())    if start == 0:        first_shape = (inputs.shape, targets.shape)print("training texts:", f"{len(texts):,}")print("tokens in them:", f"{sum(len(ids) for ids in texts):,}")print(f"texts cut at the length limit, {settings['longest']} tokens:", f"{np.mean([ids[-1] != end for ids in texts]):.1%}")   # a cut text lost its end markerprint("texts per batch:", size)print("one batch's inputs and targets:", *first_shape)print("share of targets that are padding, over one shuffled epoch:", f"{padding / targets_seen:.0%}")print("least and most padding in a batch:", f"{min(shares):.0%} and {max(shares):.0%}")print("steps per epoch:", f"{math.ceil(len(texts) / size):,}")   # the last, partly filled batch is a step tooprint("epochs in the recorded run:", settings["epochs"])print("steps in the recorded run:", f"{manifest['steps']:,}")
Salidapython training-batches.py
training texts: 34,252
tokens in them: 2,843,222
texts cut at the length limit, 160 tokens: 1.0%
texts per batch: 32
one batch's inputs and targets: (32, 151) (32, 151)
share of targets that are padding, over one shuffled epoch: 46%
least and most padding in a batch: 30% and 59%
steps per epoch: 1,071
epochs in the recorded run: 16
steps in the recorded run: 17,136

El conjunto de entrenamiento tiene 34,252 textos y 2,843,222 tokens. Ese recuento incluye los marcadores de inicio, separador y fin de cada texto, que el recuento del capítulo 4, de 2,744,320 tokens, omite, y excluye lo que el límite de longitud corta; solo 1.0% de los textos están cortados.

Cada lote contiene 32 textos, así que una pasada sobre los textos de entrenamiento, una época, toma 1,071 pasos, y la ejecución registrada tomó 17,136 pasos en 16 épocas.

En una época mezclada, 46% de los objetivos son relleno, entre 30% and 59% según el lote, porque una descripción larga fija el ancho de todos los textos más cortos que están junto a ella. Cada lote es un rectángulo: una fila por texto, una columna por posición.

Un relleno de esa magnitud es un desperdicio: casi la mitad de cada pase hacia delante calcula predicciones que la pérdida luego ignora. No cambia lo que el modelo aprende, ya que el relleno nunca cuenta, pero casi duplica el coste de cada paso. Krell y colaboradores encontraron relleno de hasta la mitad de todos los tokens en conjuntos de datos habituales, y propusieron el empaquetado, varios textos de extremo a extremo en cada fila, impidiendo que la atención cruce de un texto a otro (Krell et al., 2021). Agrupar en el mismo lote textos de longitud parecida también reduce el relleno.

Regla práctica: Construye los lotes como entradas y objetivos desplazados, enmascara el relleno fuera de la pérdida y mezcla los textos en cada época con una semilla fija, para que la ejecución pueda repetirse. Mide la proporción de relleno en tus lotes; si es grande, empaqueta los textos o agrúpalos por longitud antes de comprar una máquina más potente.

Actualización con AdamW y gradientes recortados

Último cambio en la edición 2026.11.16

Con los lotes preparados, cada paso es el bucle del capítulo 5: pase hacia adelante, pérdida, gradientes, actualización. Estas líneas de recordings/transformer.py son todo el proceso, ejecutado una vez por lote:

        ids = pad([train[i] for i in order[start:start + SETTINGS["batch"]]])
        logits = model(ids[:, :-1])
        loss = torch.nn.functional.cross_entropy(logits.transpose(1, 2), ids[:, 1:], ignore_index=index[PAD])
        optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        scheduler.step()

Las tres primeras líneas pertenecen a la sección anterior: un lote con relleno, entradas sin el último token y una pérdida sobre los objetivos desplazados que ignora el relleno. Dos líneas difieren del capítulo 5.

El optimizador es AdamW, el Adam del capítulo 5 con decaimiento de pesos aplicado aparte del gradiente. El decaimiento de pesos reduce cada peso en cada paso según su valor, multiplicado por el tamaño del paso y por un factor de decaimiento, aquí 0.1 (AdamW de PyTorch). Loshchilov y Hutter mostraron que aplicar el decaimiento de esta forma funciona mejor con Adam que sumarlo a la pérdida (Loshchilov y Hutter, 2019). El decaimiento es una forma de regularización, que le faltaba al modelo de ventana del capítulo 5: empuja cada peso hacia cero, de modo que un peso solo se mantiene grande mientras el texto de entrenamiento lo siga empujando en ese sentido.

El script de entrenamiento también recorta los gradientes: cuando su longitud combinada, medida como si cada gradiente fuera un único vector largo, supera 1.0, los escala a todos hasta alcanzar esa longitud (clip_grad_norm_ de PyTorch). Así, un lote inusual no puede desviar los pesos demasiado. Pascanu y sus colegas propusieron el recorte precisamente para eso: gradientes raros y muy grandes que, de otro modo, desharían gran parte de lo que el entrenamiento había aprendido (Pascanu et al., 2013).

Regla práctica: Usa AdamW con un decaimiento de pesos moderado, y recorta los gradientes según su longitud combinada. Mantén el paso de entrenamiento lo bastante corto como para leerlo completo, de modo que cada decisión sea visible: qué ignora la pérdida, qué decae el optimizador y qué se recorta.

Calentamiento y luego descenso del tamaño del paso

Último cambio en la edición 2026.11.16

La última línea del bucle, scheduler.step(), cambia el tamaño del paso después de cada lote, siguiendo un programa (schedule), que fija el tamaño del paso para cada paso de la ejecución. Durante los primeros 200 pasos, el tamaño del paso sube en línea recta desde casi cero hasta su valor máximo, 0.003: un calentamiento (warm-up), como el que tenía el programa del artículo sobre el transformador (Vaswani et al., 2017, sección 5.3). En los primeros pasos de Adam, su promedio móvil de gradientes al cuadrado descansa en solo unos pocos lotes, así que sus tamaños de paso varían mucho; Liu y colegas mostraron que el calentamiento funciona reduciendo esa varianza (Liu et al., 2020). Tras el calentamiento, el tamaño del paso desciende siguiendo media curva coseno, hasta una décima parte del máximo en el último paso (Loshchilov and Hutter, 2017). Los pasos grandes al principio avanzan terreno; los pasos pequeños al final permiten que los pesos se asienten en un punto bajo en lugar de rebotar a su alrededor. En símbolos, después del calentamiento:

tamaño del paso = máximo × (0.1 + 0.9 × ½ (1 + cos(π × progreso)))

donde el progreso va de 0 al final del calentamiento a 1 en el último paso.

Puedes comprobar si el programa coincide con el de la ejecución: calcúlalo a mano a partir de los ajustes registrados y compáralo con los tamaños de paso que el script de entrenamiento guardó cada diez pasos:

learning-rate-schedule.py Python 3.12.15 · numpy 2.5.5 Superado
"""Computes the warm-up and cosine schedule by hand from the recorded settings, and checks it against the step sizesthe training script saved. The prose relies on the check: the assert fails the run if the two ever differ."""import jsonimport mathfrom lib import transformer_, _, manifest = transformer.load()settings, total = manifest["settings"], manifest["steps"]recorded_rates = json.loads((transformer.RECORDED / "curves.json").read_text())["rates"]   # every 10th step's, after the scheduler's stepdef rate(step):    """Warm up linearly to the peak, then follow half a cosine down to a tenth of it."""    if step < settings["warmup_steps"]:        return settings["peak_rate"] * (step + 1) / settings["warmup_steps"]   # steps count from 0, so step 0 is already a share of the peak    progress = (step - settings["warmup_steps"]) / (total - settings["warmup_steps"])   # 0 at the warm-up's end, 1 at the last step    return settings["peak_rate"] * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * progress)))print("warm-up steps:", settings["warmup_steps"])print("peak step size:", settings["peak_rate"])print("weight decay:", settings["weight_decay"])for step in [0, settings["warmup_steps"] // 2, settings["warmup_steps"], total // 2, total - 1]:    print(f"step size at step {step:,}:", f"{rate(step):.2e}")gap = max(abs(recorded - rate(10 * i + 1)) for i, recorded in enumerate(recorded_rates))   # recorded_rates[i] was saved after step 10 * i, so it is the size used at step 10 * i + 1assert gap < 1e-9                   # every saved step size matches the hand calculation, to a billionthprint("same as the recorded step sizes:", "yes")
Salidapython learning-rate-schedule.py
warm-up steps: 200
peak step size: 0.003
weight decay: 0.1
step size at step 0: 1.50e-05
step size at step 100: 1.51e-03
step size at step 200: 3.00e-03
step size at step 8,568: 1.68e-03
step size at step 17,135: 3.00e-04
same as the recorded step sizes: yes

El cálculo a mano coincide con cada tamaño de paso guardado. El tamaño del paso empieza en 1.50e-05, alcanza su máximo en 3.00e-03 al final del calentamiento, y vale 3.00e-04 en el último paso, una décima parte de ese máximo.

El descenso importa. La ejecución de comparación entrenó durante cuatro épocas con el mismo ancho, la misma semilla y los mismos lotes, así que su programa terminó el descenso en el paso 4,284, y en ese paso obtuvo 27.6 sobre los nombres de validación. La ejecución registrada seguía cerca de su tamaño de paso máximo en ese paso, y obtuvo 32.6. Mismos datos, mismos pasos: la diferencia es el descenso.

Regla práctica: Calienta el tamaño del paso durante los primeros cientos de pasos y después hazlo descender, y ajusta la duración del programa a la de la ejecución. Guarda el tamaño del paso mientras entrenas, como hace el script de entrenamiento, y compáralo con el programa que pretendías: un error en el programa parece un problema de entrenamiento, y así es mucho más fácil de encontrar.

Lee la curva de entrenamiento

Último cambio en la edición 2026.11.11

Con sus lotes, actualizaciones y calendario configurados, el modelo de la tienda entrenó durante 16 épocas, y el script lo midió sobre la partición de validación después de cada una, en nombres y descripciones por separado. Conservó los pesos de la época con la menor pérdida de validación en nombres y descripciones sumadas, igual que el capítulo 5 conservó su mejor época.

Leídas como perplejidad por token, las curvas registradas, época por época, se ven así:

transformer-training-curve.py Python 3.12.15 · numpy 2.5.5 Superado
"""Prints the recorded run's perplexity for each epoch, then the epoch kept and its validation perplexities.The prose's point rests on the two validation columns and the epoch kept."""import jsonimport mathfrom lib import transformer_, _, manifest = transformer.load()curves = json.loads((transformer.RECORDED / "curves.json").read_text())["epochs"]print("perplexity per token; training mixes names and descriptions, as the training text does")print("epoch  training  validation names  validation descriptions")for curve in curves:    print(f"{curve['epoch']:>5}  {math.exp(curve['train_loss']):>8.1f}  {math.exp(curve['validation_name_loss']):>16.1f}"          f"  {math.exp(curve['validation_description_loss']):>23.1f}")kept = next(curve for curve in curves if curve["epoch"] == manifest["kept_epoch"])   # the epoch whose weights were keptprint("epoch kept, the lowest name and description losses added together:", manifest["kept_epoch"])print("validation perplexity on names, kept epoch:", f"{math.exp(kept['validation_name_loss']):.1f}")print("validation perplexity on descriptions, kept epoch:", f"{math.exp(kept['validation_description_loss']):.1f}")print("validation perplexity on names, epoch 4:", f"{math.exp(curves[3]['validation_name_loss']):.1f}")   # the list starts at epoch 1, so index 3 is epoch 4
Salidapython transformer-training-curve.py
perplexity per token; training mixes names and descriptions, as the training text does
epoch  training  validation names  validation descriptions
    1     131.4              50.5                     50.4
    2      41.4              38.8                     36.2
    3      32.8              34.5                     31.5
    4      29.0              32.6                     29.3
    5      26.6              30.9                     27.8
    6      24.8              30.2                     26.4
    7      23.3              28.9                     25.0
    8      21.8              28.1                     23.9
    9      20.5              27.1                     22.9
   10      19.2              26.5                     22.2
   11      17.9              25.8                     21.6
   12      16.8              25.1                     20.8
   13      15.8              24.6                     20.4
   14      14.9              24.2                     20.0
   15      14.2              24.0                     19.9
   16      13.8              24.1                     19.9
epoch kept, the lowest name and description losses added together: 15
validation perplexity on names, kept epoch: 24.0
validation perplexity on descriptions, kept epoch: 19.9
validation perplexity on names, epoch 4: 32.6

La perplejidad de validación baja hasta la época 15, la época conservada, y luego se estabiliza: la última época no es mejor. En la época conservada es 24.0 en nombres y 19.9 en descripciones. Como en el capítulo 5, la perplejidad de entrenamiento de la época 1 está por encima de la de validación, porque promedia sobre los primeros lotes de la época, cuando el modelo no sabía nada. La columna de entrenamiento mezcla nombres y descripciones, como lo hace el texto de entrenamiento, así que muestra la tendencia, no un número para comparar con ninguna de las dos columnas de validación.

El modelo de ventana del capítulo 5 dejó de mejorar después de la época 5; este modelo siguió mejorando mucho más tiempo. Las dos ejecuciones difieren en varios aspectos que podrían explicarlo. Este modelo aprendió de nombres y descripciones, 2,843,222 tokens, frente a los 337,071 del modelo de ventana, que usó solo nombres; su tamaño de paso decae; tiene decaimiento de pesos; y la atención aplica los mismos pesos en cada posición. La ejecución no separa esas razones. Lo que sí muestra es la brecha entre entrenamiento y validación, que crece en cada época: al final, el modelo predice sus textos de entrenamiento mucho mejor que los nuevos, así que empieza a memorizar.

Las descripciones obtienen una puntuación menor que los nombres, pero eso no significa que el modelo sea mejor en descripciones. Cada tipo de texto tiene su propia previsibilidad: las descripciones repiten frases de sus plantillas y de sus nombres, y los nombres condensan un producto nuevo en unas pocas palabras. Las perplejidades comparan modelos sobre el mismo texto, nunca textos entre sí.

Regla práctica: Registra la pérdida de validación por época en cada tipo de texto que te importe, y conserva los pesos de la mejor época. Lee la brecha entre entrenamiento y validación como la advertencia, no solo la pérdida de entrenamiento. Nunca compares perplejidades entre distintos tipos de texto.

Compara con la línea base en nombres

Último cambio en la edición 2026.11.11

Con la lectura de entrenamiento, el resultado puede medirse. El modelo contado más fuerte para nombres es el 4-grama de línea base entrenado con los nombres de entrenamiento. Obtiene 23.1 en los nombres de validación, la referencia del libro: desde el capítulo 3 todos los modelos se han evaluado con ellos. El mismo 4-grama entrenado con textos completos, nombres y descripciones, obtiene 27.7 en ellos, porque las descripciones diluyen sus recuentos de cómo se desarrollan los nombres.

La comparación tiene que contar las mismas predicciones. El 4-grama predice los tokens de cada nombre y luego su marca de fin; el transformador predice los tokens de cada nombre y luego <sep>, que cumple el mismo papel, ya que marca dónde termina el nombre. Un nombre no necesita nada después de él, así que el transformador lee solo el nombre. Ambos modelos puntúan las mismas 46,704 predicciones.

Haz primero una suposición: ¿puede el transformador por sí solo superar a la línea base contada que el modelo de ventana del capítulo 5 no pudo superar? Después puntúa ambos modelos, y las mezclas de los dos, tal como lo hizo el capítulo 5:

transformer-on-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Scores every validation name, its end included, with the 4-gram baseline and with the transformer, then mixes themat several shares. The prose's point rests on the share 0.5 line, the lowest of the five."""import numpy as npfrom lib import transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey, ngrams, padded_, vocabulary, _ = transformer.load()index = {token: i for i, token in enumerate(vocabulary)}   # each token's id in the vocabulary, which is its column in the model's outputcounted = KneserNey(name_tokens("train"), 4)                     # chapter 3's baseline, trained on namesfrom_counts, from_transformer = [], []for name in name_tokens("validation"):    ids = [index[transformer.START]] + [index[token] for token in name] + [index[transformer.SEP]]   # the name as the model reads it    probabilities = transformer.softmax(transformer.forward(ids)[:-1])   # the last position predicts past <sep>, which a name never needs    from_transformer += list(probabilities[np.arange(len(ids) - 1), ids[1:]])   # each position's probability for the token after it    from_counts += [counted.probability(context, token) for context, token in ngrams(padded(name, 4), 4)]   # then </s>from_counts, from_transformer = np.array(from_counts), np.array(from_transformer)print("validation tokens scored, each name's end included:", f"{len(from_counts):,}")for share in [0.0, 0.3, 0.5, 0.7, 1.0]:    mixed = (1 - share) * from_counts + share * from_transformer    print(f"validation perplexity on names, transformer share {share:.1f}:", f"{np.exp(-np.log(mixed).mean()):.1f}")
Salidapython transformer-on-names.py
validation tokens scored, each name's end included: 46,704
validation perplexity on names, transformer share 0.0: 23.1
validation perplexity on names, transformer share 0.3: 18.7
validation perplexity on names, transformer share 0.5: 18.4
validation perplexity on names, transformer share 0.7: 18.8
validation perplexity on names, transformer share 1.0: 24.0

Mezclados a partes iguales, el transformador y los recuentos obtienen 18.4 en nombres, la mejor puntuación de cualquier modelo de este libro para nombres. Por sí solo, el transformador obtiene 24.0, algo peor que los 23.1 de la línea base.

El transformador por sí solo es mucho mejor que el modelo de ventana del capítulo 5, que obtuvo 36.4, y la mezcla supera la mejor mezcla del capítulo 5, 21.9.

Así que, en nombres, contar sigue siendo difícil de superar por sí solo, por la razón que dio el capítulo 5: los nombres son cortos y formulaicos, y tres tokens de contexto ven la mayor parte de lo que contiene un nombre. Pero el transformador se equivoca en lugares distintos a los de los recuentos, y la mezcla se beneficia de ambos. La proporción se eligió sobre los nombres de validación, así que la mejora es algo optimista; los nombres de prueba se mantienen intactos para la comparación final del libro.

Regla práctica: Compara un modelo nuevo con la línea base contada más fuerte que puedas construir, sobre exactamente las mismas predicciones, incluida la forma en que cada uno marca el fin de un texto. Cuando un modelo aprendido y uno contado están cerca, mézclalos, y elige la proporción sobre texto reservado.

Comparar en las descripciones

Último cambio en la edición 2026.11.11

La comparación de nombres favorece el conteo, porque los nombres son cortos. Las descripciones son muchas veces más largas, y el capítulo 6 mostró que el modelo copia desde el nombre muchos tokens atrás, así que aquí es donde su mayor alcance debería rendir. Una línea base justa en este caso es un 4-grama entrenado con los mismos textos con los que aprendió el transformer, el nombre, <sep> y la descripción unidos, y evaluado sobre los mismos tokens: los tokens de cada descripción y su final, con el mismo texto antes de ellos.

Pon a prueba ese mayor alcance en las descripciones: ajusta el 4-grama con todos los textos de entrenamiento y luego evalúalo, junto con el transformer y una mezcla a partes iguales, sobre las descripciones de los primeros 500 productos de validación, dejando fuera los textos cortados por el límite de longitud y los productos sin descripción. También separa los tokens, como hizo el capítulo 5, según si su contexto de tres tokens aparece en los textos de entrenamiento:

transformer-on-descriptions.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Scores the descriptions of the first 500 validation products with a 4-gram trained on whole texts, with the transformer,and with their even mix, then splits the tokens by whether their context was seen in training. The prose's point rests on the4-gram baseline and transformer lines, the half-and-half line and the unseen-context lines."""import numpy as npfrom lib import transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey, ngrams, paddedfrom lib.products import product_texts_, vocabulary, _ = transformer.load()end = vocabulary.index(transformer.END)as_tokens = lambda ids: [vocabulary[i] for i in ids[1:] if i != end]          # padded() adds its own <s> and </s>counted = KneserNey([as_tokens(ids) for ids, _ in product_texts("train")], 4)   # whole texts: name, <sep>, descriptionfrom_counts, from_transformer, seen, products = [], [], [], 0for ids, sep in product_texts("validation", 500):    if ids[-1] != end or sep == len(ids) - 2:        continue                                          # cut at the length limit, or no description    pairs = list(ngrams(padded(as_tokens(ids), 4), 4))[sep:]    # from <sep> on: the description's tokens, then </s>    from_counts += [counted.probability(context, token) for context, token in pairs]    seen += [context in counted.totals[4] for context, _ in pairs]   # was this 3-token context in the training texts?    probabilities = transformer.softmax(transformer.forward(ids)[sep:-1])   # from <sep> on: each position predicts the next token    from_transformer += list(probabilities[np.arange(len(probabilities)), ids[sep + 1:]])   # the description starts after <sep>, at sep + 1    products += 1from_counts, from_transformer, seen = np.array(from_counts), np.array(from_transformer), np.array(seen)perplexity = lambda p: f"{np.exp(-np.log(p).mean()):.1f}"print("products scored:", products)print("description tokens scored:", f"{len(from_counts):,}")mixed = (from_counts + from_transformer) / 2for label, p in [("4-gram baseline", from_counts), ("transformer", from_transformer), ("half and half", mixed)]:    print(f"{label}, validation perplexity on descriptions:", perplexity(p))print("description tokens whose 3-token context is in the training texts:", f"{seen.mean():.0%}")for part, where in [("seen", seen), ("unseen", ~seen)]:    print(f"4-gram, {part} contexts:", perplexity(from_counts[where]))    print(f"transformer, {part} contexts:", perplexity(from_transformer[where]))names = [list(ngrams(padded(name + [transformer.SEP], 4), 4))[:-1] for name in name_tokens("validation")]   # to <sep>: the last pair predicts </s>, which a name stops short ofon_names = [counted.probability(context, token) for pairs in names for context, token in pairs]print("this 4-gram, trained on whole texts, validation perplexity on names:", perplexity(np.array(on_names)))
Salidapython transformer-on-descriptions.py
products scored: 446
description tokens scored: 35,651
4-gram baseline, validation perplexity on descriptions: 22.5
transformer, validation perplexity on descriptions: 20.1
half and half, validation perplexity on descriptions: 14.7
description tokens whose 3-token context is in the training texts: 74%
4-gram, seen contexts: 16.3
transformer, seen contexts: 16.6
4-gram, unseen contexts: 57.6
transformer, unseen contexts: 35.0
this 4-gram, trained on whole texts, validation perplexity on names: 27.7

En las descripciones, el transformer supera al conteo por sí solo: obtiene 20.1 sobre los 35,651 tokens de descripción de 446 productos, frente al 22.5 del 4-grama. Es el primer modelo aprendido de este libro que supera a un modelo basado en conteos del mismo texto.

La separación muestra dónde se diferencian. 74% de los tokens tienen un contexto que aparece en los textos de entrenamiento, y en esos casos los dos modelos empatan: 16.3 para el 4-grama, 16.6 para el transformer. En el resto, el transformer obtiene 35.0 mientras que el 4-grama obtiene 57.6. Las descripciones son lo bastante repetitivas como para que los conteos igualen al transformer allí donde ya han visto el contexto; donde no lo han visto, el transformer lee más atrás y relaciona lo que ve con lo que aprendió, mientras que los conteos solo pueden retroceder a contextos más cortos.

Por eso la mezcla funciona tan bien. A partes iguales, los dos obtienen 14.7, muy por debajo de cualquiera de ellos por separado: en un token cualquiera, al menos uno de los dos suele estar seguro y acertar, y la mezcla a partes iguales conserva la mitad de esa probabilidad, lo justo para evitar las peores sorpresas de cada uno.

Regla práctica: Mide un modelo sobre el tipo de texto que va a predecir, frente a una línea base que vea el mismo texto, y espera que el orden cambie de un tipo de texto a otro. Separa la comparación según contextos vistos y no vistos para ver dónde gana cada modelo. Prueba una mezcla antes de concluir que basta con uno de los dos modelos: la mezcla ganó más que cualquier cambio en cualquiera de los dos modelos que este capítulo midió.

Qué aportan el ancho, los datos y los pasos

Último cambio en la edición 2026.11.11

El modelo registrado es una elección entre muchas: 128 números de ancho, entrenado con todo el texto de entrenamiento durante 16 épocas. Los estudios de modelos mucho más grandes encontraron que la pérdida baja de forma suave a medida que los modelos crecen, ven más texto y entrenan más tiempo, y que los modelos más grandes aprenden más de cada token que ven (Kaplan et al., 2020). Para un presupuesto fijo de cómputo, Hoffmann y sus colegas encontraron que el tamaño del modelo y el texto de entrenamiento deben crecer juntos (Hoffmann et al., 2022). Y Muennighoff y sus colegas encontraron que repetir el mismo texto hasta unas cuatro épocas es casi tan bueno como texto nuevo, con menos ganancia por cada repetición adicional (Muennighoff et al., 2023). Si algo de eso se cumple a esta escala de juguete es algo que hay que medir, no dar por supuesto.

Por eso el script de entrenamiento registró siete ejecuciones más baratas junto a la principal, cambiando cada una una sola cosa:

  • tres anchos, 64, 128 y 256, cada uno entrenado durante cuatro épocas, manteniendo cada cabeza de 32 números de ancho;
  • cuartos y mitades aleatorios de los productos de entrenamiento, cada uno entrenado durante cuatro épocas;
  • el mismo cuarto y la misma mitad entrenados durante tantos pasos como las cuatro épocas de todos los datos, repitiéndolos con más frecuencia.

¿Qué cambio aporta más? Lee las ocho ejecuciones una al lado de otra, con el tamaño, los pasos y las perplejidades de cada una en sus épocas mejor y última:

width-data-and-steps.py Python 3.12.15 · numpy 2.5.5 Superado
"""Reads eight recorded runs and prints each one's parameters, steps, best epoch, and validation perplexities at its bestand last epochs. The prose's point rests on the perplexity-on-names lines."""import jsonimport mathfrom lib import transformerruns = [("width 64, 4 epochs", "transformer-width-64"), ("width 128, 4 epochs", "transformer-width-128"),        ("width 256, 4 epochs", "transformer-width-256"), ("width 128, 16 epochs", "transformer"),        ("a quarter of the data, 4 epochs", "transformer-data-25"), ("half the data, 4 epochs", "transformer-data-50"),        ("a quarter of the data, 16 epochs", "transformer-data-25-same-steps"),        ("half the data, 8 epochs", "transformer-data-50-same-steps")]for label, folder in runs:    run = transformer.RECORDED.parent / folder   # every run sits in the folder beside the main run's    manifest = json.loads((run / "manifest.json").read_text())    curves = json.loads((run / "curves.json").read_text())["epochs"]    best = min(curves, key=lambda curve: curve["validation_name_loss"] + curve["validation_description_loss"])   # the epoch the script kept    print(f"{label}, parameters:", f"{manifest['parameters']:,}")    print(f"{label}, steps:", f"{manifest['steps']:,}")    print(f"{label}, best epoch:", best["epoch"])    print(f"{label}, perplexity on names:", f"{math.exp(best['validation_name_loss']):.1f}")    print(f"{label}, perplexity on descriptions:", f"{math.exp(best['validation_description_loss']):.1f}")    print(f"{label}, perplexity on names, last epoch:", f"{math.exp(curves[-1]['validation_name_loss']):.1f}")   # the last epoch trained, not the one kept    print(f"{label}, perplexity on descriptions, last epoch:", f"{math.exp(curves[-1]['validation_description_loss']):.1f}")
Salidapython width-data-and-steps.py
width 64, 4 epochs, parameters: 478,656
width 64, 4 epochs, steps: 4,284
width 64, 4 epochs, best epoch: 4
width 64, 4 epochs, perplexity on names: 36.9
width 64, 4 epochs, perplexity on descriptions: 35.9
width 64, 4 epochs, perplexity on names, last epoch: 36.9
width 64, 4 epochs, perplexity on descriptions, last epoch: 35.9
width 128, 4 epochs, parameters: 1,334,144
width 128, 4 epochs, steps: 4,284
width 128, 4 epochs, best epoch: 4
width 128, 4 epochs, perplexity on names: 27.6
width 128, 4 epochs, perplexity on descriptions: 24.7
width 128, 4 epochs, perplexity on names, last epoch: 27.6
width 128, 4 epochs, perplexity on descriptions, last epoch: 24.7
width 256, 4 epochs, parameters: 4,273,920
width 256, 4 epochs, steps: 4,284
width 256, 4 epochs, best epoch: 4
width 256, 4 epochs, perplexity on names: 23.5
width 256, 4 epochs, perplexity on descriptions: 19.5
width 256, 4 epochs, perplexity on names, last epoch: 23.5
width 256, 4 epochs, perplexity on descriptions, last epoch: 19.5
width 128, 16 epochs, parameters: 1,334,144
width 128, 16 epochs, steps: 17,136
width 128, 16 epochs, best epoch: 15
width 128, 16 epochs, perplexity on names: 24.0
width 128, 16 epochs, perplexity on descriptions: 19.9
width 128, 16 epochs, perplexity on names, last epoch: 24.1
width 128, 16 epochs, perplexity on descriptions, last epoch: 19.9
a quarter of the data, 4 epochs, parameters: 1,334,144
a quarter of the data, 4 epochs, steps: 1,072
a quarter of the data, 4 epochs, best epoch: 4
a quarter of the data, 4 epochs, perplexity on names: 51.9
a quarter of the data, 4 epochs, perplexity on descriptions: 54.1
a quarter of the data, 4 epochs, perplexity on names, last epoch: 51.9
a quarter of the data, 4 epochs, perplexity on descriptions, last epoch: 54.1
half the data, 4 epochs, parameters: 1,334,144
half the data, 4 epochs, steps: 2,144
half the data, 4 epochs, best epoch: 4
half the data, 4 epochs, perplexity on names: 35.2
half the data, 4 epochs, perplexity on descriptions: 34.8
half the data, 4 epochs, perplexity on names, last epoch: 35.2
half the data, 4 epochs, perplexity on descriptions, last epoch: 34.8
a quarter of the data, 16 epochs, parameters: 1,334,144
a quarter of the data, 16 epochs, steps: 4,288
a quarter of the data, 16 epochs, best epoch: 11
a quarter of the data, 16 epochs, perplexity on names: 40.0
a quarter of the data, 16 epochs, perplexity on descriptions: 39.6
a quarter of the data, 16 epochs, perplexity on names, last epoch: 44.1
a quarter of the data, 16 epochs, perplexity on descriptions, last epoch: 45.9
half the data, 8 epochs, parameters: 1,334,144
half the data, 8 epochs, steps: 4,288
half the data, 8 epochs, best epoch: 8
half the data, 8 epochs, perplexity on names: 30.4
half the data, 8 epochs, perplexity on descriptions: 28.6
half the data, 8 epochs, perplexity on names, last epoch: 30.4
half the data, 8 epochs, perplexity on descriptions, last epoch: 28.6

El ancho ayuda mucho, pero tiene un precio. Con los mismos pasos, la perplejidad en los nombres baja de 36.9 con ancho 64 a 27.6 con 128 y 23.5 con 256. En los nombres, el modelo más ancho, entrenado durante cuatro épocas, incluso supera al modelo registrado entrenado durante dieciséis, 24.0. Pero el ancho 256 tiene 4,273,920 parámetros frente a 1,334,144 con ancho 128, y cada paso cuesta aproximadamente esa proporción más.

El texto nuevo ayuda sin coste extra por paso. Con los mismos pasos, un cuarto aleatorio de los productos obtiene 40.0 en los nombres en su mejor punto, la mitad 30.4, y todos ellos 27.6. Pasar de la mitad a la totalidad del texto ganó menos que duplicar el ancho de 128 a 256, pero no costó cómputo adicional, y la primera duplicación, de un cuarto a la mitad, ganó más que cualquiera de las dos.

La repetición ayuda durante un tiempo y luego perjudica. Un cuarto del texto visto cuatro veces obtiene 51.9; visto con más frecuencia, mejora hasta la época 11 y luego empeora, terminando en 44.1 tras dieciséis pasadas: el modelo memoriza lo que ha visto demasiadas veces. El texto repetido nunca alcanzó al texto nuevo con el mismo número de pasos.

Más pasos ayudan lo menos. Las dieciséis épocas del modelo registrado mejoran sobre cuatro, 24.0 frente a 27.6 en los nombres, por cuatro veces más pasos.

Estas ejecuciones también muestran los límites de la escala de este libro. El texto de entrenamiento de la tienda está fijado en lo que contiene su catálogo, 2,843,222 tokens. SmolLM2-360M, cuyo diseño el capítulo 7 comparó con el modelo de la tienda, se entrenó con 4 billones (4 millones de millones) de tokens (model card), más de un millón de veces más, lo que permite a un modelo de 960 números de ancho y 32 capas seguir aprendiendo de texto nuevo en lugar de memorizar el antiguo.

Regla práctica: Consigue más texto del tipo que vas a predecir antes de repetir lo que tienes más de unas pocas veces; no cuesta nada por paso. Si te sobra cómputo, prueba un modelo más ancho durante menos épocas antes de entrenar uno estrecho más tiempo, y mide ambos. Cambia una sola cosa por ejecución y mantén fijo el número de pasos donde importe, o la comparación medirá dos cosas a la vez.

Último cambio en la edición 2026.11.11

Los promedios indican qué tan bueno es un modelo; el cuadro de búsqueda muestra qué significa eso para un comprador. El 4-gram del capítulo 3 sugirió & y with después de outdoor bar, un contexto que ningún nombre de entrenamiento contiene, y el modelo de ventana del capítulo 5 sugirió stool. Algunas descripciones de entrenamiento sí contienen outdoor bar, y el transformador aprendió de ellas tanto como de los nombres, mientras que el 4-gram aprendió solo de los nombres.

Un comprador vería los tres siguientes tokens más probables del transformador, y los de la mezcla mitad y mitad que favoreció la comparación de nombres, después de los mismos cinco prefijos, tratados cada uno como el inicio de un nombre. Una sugerencia de <sep> significa que el modelo espera que el nombre termine ahí:

transformer-autocomplete.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Asks the transformer and its half-and-half mix with the 4-gram for their three likeliest next tokens after five prefixes,treated as the start of a name, and prints the probability of stool after outdoor bar. The prose's point rests on thestool lines and the control prefixes beside them."""import numpy as npfrom lib import bpe, transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey_, vocabulary, _ = transformer.load()index = {token: i for i, token in enumerate(vocabulary)}counted = KneserNey(name_tokens("train"), 4)tokenizer = bpe.store_tokenizer()as_counted = [{transformer.SEP: "</s>"}.get(token, token) for token in vocabulary]   # <sep> ends a name, as </s> doesshow = lambda token: token.replace("</w>", "")for prefix in ["bar", "patio bar", "outdoor bar", "kitchen bar", "wine bar"]:    tokens = tokenizer.encode(prefix)    ids = [index[transformer.START]] + [index[token] for token in tokens]    from_transformer = transformer.softmax(transformer.forward(ids)[-1])    context = tuple(["<s>"] * 3 + tokens)[-3:]   # the 4-gram looks at the last three tokens, padded with start markers for a short prefix    from_counts = np.array([counted.probability(context, token) for token in as_counted])    mixed = (from_transformer + from_counts) / 2    for label, p in [("transformer", from_transformer), ("half and half", mixed)]:        top = np.argsort(-p, kind="stable")[:3]   # the three likeliest; a stable sort keeps tied tokens in vocabulary order        print(f"{prefix:<12} {label:<13} -> " + ", ".join(f"{show(vocabulary[i])} {p[i]:.2f}" for i in top))    if prefix == "outdoor bar":        stool = index["stool</w>"]   # </w> marks the end of a word in the tokenizer, so this is the whole word stool        print("P(stool | outdoor bar), transformer:", f"{from_transformer[stool]:.2f}")        print("P(stool | outdoor bar), 4-gram:", f"{from_counts[stool]:.2f}")        print("P(stool | outdoor bar), half and half:", f"{mixed[stool]:.2f}")
Salidapython transformer-autocomplete.py
bar          transformer   -> with 0.17, & 0.14, and 0.09
bar          half and half -> & 0.19, with 0.14, unit 0.07
patio bar    transformer   -> stool 0.51, table 0.25, set 0.02
patio bar    half and half -> stool 0.69, table 0.13, & 0.01
outdoor bar  transformer   -> stool 0.50, with 0.05, table 0.04
outdoor bar  half and half -> stool 0.28, & 0.12, with 0.12
P(stool | outdoor bar), transformer: 0.50
P(stool | outdoor bar), 4-gram: 0.06
P(stool | outdoor bar), half and half: 0.28
kitchen bar  transformer   -> room 0.14, with 0.08, cabinet 0.08
kitchen bar  half and half -> with 0.14, & 0.12, room 0.07
wine bar     transformer   -> with 0.43, <sep> 0.22, cabinet 0.08
wine bar     half and half -> with 0.30, <sep> 0.21, cabinet 0.13

Después de outdoor bar, el transformador le asigna stool 0.50, mientras que el 4-gram le asigna 0.06; la mezcla, con 0.28, sigue colocándola primera. Los prefijos de control muestran que los modelos no sugieren stool después de cada bar: después de kitchen bar y wine bar sugieren otras continuaciones, y después de wine bar ambos esperan, con buena razón, que el nombre ya pueda estar completo. Después de patio bar, un contexto que los nombres contienen con frecuencia, la mezcla confía más en stool que el transformador por sí solo.

Un prefijo es un ejemplo, no una medida. La medida es la comparación de nombres, y ahí ganó la mezcla. Para el cuadro de búsqueda, ese es el modelo que debes usar.

Regla práctica: Usa la mezcla para el autocompletado y pruébala con prefijos poco frecuentes además de los comunes, con prefijos de control junto a cada uno. Trata una única sugerencia llamativa como una ilustración de una mejora medida, nunca como la prueba de ella.

Qué sale mal en producción

El entrenamiento falla de maneras que parecen correctas mientras ocurren:

  • El relleno desperdicia cómputo. Casi la mitad de las predicciones de cada paso eran relleno. Empaqueta los textos, o agrúpalos por longitud, antes de comprar más cómputo.
  • Un error en el calendario parece un problema del modelo. Como regla general, un calentamiento que nunca termina, o una reducción que empieza demasiado pronto, aparece como una pérdida que baja con demasiada lentitud; la comparación de reducciones de arriba muestra cuánto puede cambiar el resultado un calendario. Guarda el tamaño del paso y compáralo con el calendario que pretendías.
  • Las decisiones tomadas con datos de validación inflan el resultado. La época conservada y la proporción de mezcla se eligieron ambas con la partición de validación, así que sus cifras son ligeramente optimistas. Mantén una partición de prueba sin tocar hasta el final.
  • El texto repetido se memoriza. Un conjunto de datos pequeño visto muchas veces se ve bien en la pérdida de entrenamiento y mal con texto nuevo. Cuenta cuántas veces ve el entrenamiento cada texto, y prefiere texto nuevo a más épocas.
  • Un modelo se mide con un solo tipo de texto. El transformador quedó segundo frente a los conteos en nombres y primero en descripciones. Evalúa cada modelo en cada tipo de texto que vaya a atender antes de elegir cuál desplegar.
  • Los resultados dependen de la máquina. PyTorch no garantiza resultados idénticos entre versiones o plataformas (Reproducibilidad). Registra los pesos, las curvas y el script exacto, como hace recordings/transformer.py con el hash del script, y guárdalos juntos.

Lo que decidió este capítulo

  • El modelo de la tienda se entrena en una sola ejecución registrada: lotes de 32 textos de productos, AdamW con un decaimiento de pesos de 0.1, gradientes recortados, un calentamiento de 200 pasos hasta un tamaño de paso máximo de 0.003, decaimiento coseno hasta una décima parte, y los pesos conservados de la época 15 de 16.
  • Cada comparación cuenta las mismas predicciones. En los nombres, ambos modelos predicen los tokens de cada nombre y su fin, frente a la línea base solo de nombres del capítulo 3, la más fuerte para los nombres. En las descripciones, un 4-grama entrenado con los mismos textos puntúa los mismos tokens, con el mismo texto antes de ellos.
  • En los nombres de validación, el transformador por sí solo empata aproximadamente con la línea base de 4-gramas, y la mezcla al cincuenta por ciento con ella obtiene 18.4, la mejor puntuación en nombres de este libro hasta ahora. La mezcla es el modelo que el libro usa para el autocompletado, sustituyendo la mezcla del capítulo 5 entre el modelo de ventana y los conteos.
  • A partir de este capítulo, los modelos también se miden sobre las descripciones de validación. Allí el transformador por sí solo supera a la línea base, 20.1 frente a 22.5, al ganar donde los conteos no han visto el contexto, y la mezcla obtiene 14.7.
  • A esta escala, el texto nuevo es la mejora más barata, el ancho la mayor y con un coste, y la repetición ayuda solo durante unas pocas pasadas. El modelo registrado se mantiene con un ancho de 128, porque todos los ejemplos desde el capítulo 6 en adelante lo usan y los ejemplos tienen que ejecutarse en segundos en un portátil; uno más ancho puntuaría mejor.

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.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 8 de 11: Entrenamiento de un modelo pequeño

  1. Convierte productos en lotes
  2. Actualización con AdamW y gradientes recortados
  3. Calentamiento y luego descenso del tamaño del paso
  4. Lee la curva de entrenamiento
  5. Compara con la línea base en nombres
  6. Comparar en las descripciones
  7. Qué aportan el ancho, los datos y los pasos
  8. Sugiere la siguiente palabra en el cuadro de búsqueda
  9. Qué sale mal en producción
  10. Lo que decidió este capítulo

Volver arribaTodos los capítulos