De predecir a seguir instrucciones
Unos 23 minutos de lectura, con 9 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
- Calcula las dos pérdidas de entrenamiento a mano
- Pregunta al modelo base y al modelo ajustado
- Formatea la request como se ajustó el modelo
- Medir detalles inventados de productos
- Comprueba si la confianza te advierte
- Encuentra lo que pierde un contexto más largo
- Adapta un modelo a tu texto
- Repasa la vara de medir
- Qué sale mal en producción
- Lo que decidió este capítulo
Al terminar este capítulo podrás explicar cómo un modelo que predice el siguiente token se convierte en uno que sigue peticiones, construir las dos funciones de pérdida que lo logran y medir qué cambia y qué no corrige ese cambio. Compararás un modelo base con su versión ajustada a instrucciones ante las mismas peticiones, medirás con qué frecuencia cada uno inventa un detalle de producto, comprobarás si su confianza te advierte cuando lo hace y averiguarás en qué punto de un contexto largo un modelo deja de encontrar lo que se le dio.
Los nombres y descripciones de productos de la tienda de muebles y artículos para el hogar son el texto que este libro modela, y todos los modelos del libro hasta ahora han hecho una sola cosa: predecir el siguiente token de texto como los de su texto de entrenamiento. El capítulo 10 usó SmolLM2-360M, un modelo abierto entrenado así con texto general, y comprobó que puntuaba peor, por palabra, los nombres de la tienda que el pequeño modelo propio de la tienda, y también peor sus descripciones. La gente no quiere una continuación de su texto; quiere una respuesta a su petición. A los modelos se les enseña eso en dos pasos adicionales de entrenamiento.
El ajuste por instrucciones, o ajuste fino supervisado, sigue entrenando un modelo con ejemplos de peticiones emparejadas con buenas respuestas, de modo que predecir el siguiente token de uno de esos pares signifique responder a la petición. Wei y sus colegas comprobaron que ajustar un modelo con muchas tareas formuladas como instrucciones lo hacía mejor en tareas que nunca había visto (Wei et al., 2022). El ajuste por preferencias entrena después un modelo para preferir la mejor de dos respuestas a la misma petición. Ouyang y sus colegas pidieron a personas que ordenaran las respuestas y entrenaron con aprendizaje por refuerzo a partir de un modelo de recompensa aprendido de esos órdenes (Ouyang et al., 2022); la Optimización Directa de Preferencias, DPO, hace ajuste por preferencias sin modelo de recompensa, con una función de pérdida sencilla sobre los propios pares de preferencia (Rafailov et al., 2023).
SmolLM2-360M-Instruct es el modelo base del capítulo 10 después de ambos pasos: ajuste fino supervisado con conjuntos de datos públicos y curados, y luego DPO sobre UltraFeedback (ficha del modelo). Los pares de preferencia de UltraFeedback fueron puntuados por un modelo de lenguaje grande, no por personas (Cui et al., 2023). Este capítulo llama SmolLM2-360M al modelo base y SmolLM2-360M-Instruct al modelo ajustado. El script recordings/instruction_tuning.py ejecutó ambos una vez, en revisiones fijadas, decodificando de forma voraz, de modo que cada respuesta es la más probable del modelo y la ejecución puede repetirse exactamente, y guardó lo que escribieron y la probabilidad que asignó cada modelo a cada token que escribió. Todas las medidas de los dos modelos proceden de esos archivos.
Calcula las dos pérdidas de entrenamiento a mano
Ambos pasos del ajuste son entrenamiento, con el bucle del capítulo 8; lo que cambia es la pérdida. El ajuste por instrucciones usa la pérdida ordinaria de siguiente token con una diferencia: solo cuentan los tokens de la respuesta. La solicitud se lee como contexto, pero el modelo no se entrena para predecirla, porque el objetivo es responder solicitudes, no escribirlas.
Dispón un producto como una solicitud y una respuesta, su nombre como solicitud y su descripción como respuesta, tal como el modelo de la tienda ya lo lee. Luego calcula la pérdida de ese modelo sobre todos los tokens, y solo sobre los tokens de la respuesta:
1"""Computes the store's model's loss on one product laid out as a request and a response, over every token and over2the response's tokens only. The prose's point rests on the last printed line, the average loss over the response only.3"""4import numpy as np56from lib import transformer7from lib.store import load_products89_, vocabulary, manifest = transformer.load()10index = {token: i for i, token in enumerate(vocabulary)}11# the name is unique in the validation split, so its one row is the product12product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]13# the text is cut at the model's longest length, so a long description may end early14ids = transformer.product_ids(product["name"], product["description"], index, manifest["settings"]["longest"])15sep = ids.index(index[transformer.SEP]) # the name plays the request; the description, the response1617# the last position predicts nothing, since no token follows it, so its row is dropped18probabilities = transformer.softmax(transformer.forward(ids)[:-1])19# position i predicts the token at i + 1, so ids[1:] holds each position's target20# each token's loss, given the tokens before it21loss = -np.log(probabilities[np.arange(len(ids) - 1), ids[1:]])22response = np.arange(1, len(ids)) > sep # the description's tokens and its end23print("tokens predicted in the text:", len(loss))24print("tokens the instruction loss counts, the response's:", int(response.sum()))25print("average loss over every token:", f"{loss.mean():.3f}")26print("average loss over the response only:", f"{loss[response].mean():.3f}")
python instruction-loss-by-hand.pytokens predicted in the text: 96
tokens the instruction loss counts, the response's: 90
average loss over every token: 2.267
average loss over the response only: 2.132
Entrenar con la pérdida solo sobre la respuesta, a lo largo de muchas solicitudes y respuestas, enseña a un modelo a producir respuestas. Para este producto, esa pérdida es 2.132, frente a 2.267 sobre todos los tokens. La pérdida por instrucciones cuenta 90 de los 96 tokens que predice el modelo: los tokens de la descripción y su token de fin.
La pérdida de DPO trabaja con un par de respuestas a una misma solicitud, una preferida y otra rechazada. DPO compara cuánto más probable hace el modelo que se ajusta cada respuesta frente al modelo de referencia del que partió, es decir, el modelo tras el ajuste por instrucciones, y premia que suba más la preferida. Con log-probabilidades log π de cada respuesta según el modelo ajustado y log π_ref según la referencia, y un factor β que fija cuánto puede moverse el modelo:
margen = β × [(log π(preferida) − log π_ref(preferida)) − (log π(rechazada) − log π_ref(rechazada))]
pérdida = −log σ(margen)
con σ la función logística del capítulo 4 (Rafailov et al., 2023, ecuación 7). Unas log-probabilidades inventadas mantienen a la vista la aritmética, así que este ejemplo las usa, con β = 0.1:
1"""Computes the DPO margin and loss by hand for two made-up cases, with a fixed beta. The prose's point rests on the2two loss lines, one for each case.3"""4import numpy as np56beta = 0.1 # how far the tuned model may move from the reference7print("beta:", beta)8# Each case: (preferred, rejected) under the tuned model, then (preferred, rejected) under the reference model it9# started from. Made-up numbers, to follow the arithmetic.10cases = {"tuned model favours the preferred answer more than the reference does": (-12.0, -20.0, -14.0, -18.0),11 "tuned model favours it less": (-15.0, -15.0, -14.0, -18.0)}12for label, (preferred, rejected, preferred_reference, rejected_reference) in cases.items():13 margin = beta * ((preferred - preferred_reference) - (rejected - rejected_reference))14 loss = np.log1p(np.exp(-margin)) # -log σ(margin), written so it can't overflow15 print(f"{label}, margin:", f"{margin:.2f}")16 print(f"{label}, loss:", f"{loss:.3f}")
python dpo-loss-by-hand.pybeta: 0.1
tuned model favours the preferred answer more than the reference does, margin: 0.40
tuned model favours the preferred answer more than the reference does, loss: 0.513
tuned model favours it less, margin: -0.40
tuned model favours it less, loss: 0.913
Bajar la pérdida empuja hacia arriba la probabilidad de la respuesta preferida y hacia abajo la de la rechazada, medido frente al punto de partida del modelo. Cuando el modelo ajustado favorece la respuesta preferida más que la referencia, el margen es 0.40 y la pérdida 0.513; cuando la favorece menos, el margen es -0.40 y la pérdida sube a 0.913.
Regla práctica: Enmascara la solicitud fuera de la pérdida cuando ajustes un modelo con solicitudes y respuestas, y conserva las log-probabilidades del modelo de referencia junto a las del modelo ajustado cuando entrenes con preferencias. Ambos son cambios pequeños en un bucle que ya tienes.
Pregunta al modelo base y al modelo ajustado
La tienda necesita descripciones para los productos que no tienen ninguna, el trabajo que el capítulo 9 le asignó a su propio modelo pequeño. El modelo base, SmolLM2-360M, no puede recibir instrucciones, solo continuar un texto, así que recibe el inicio de una ficha de producto: Product:, el nombre y Description:. El modelo ajustado, SmolLM2-360M-Instruct, recibe una petición: Write a short product description for: y el nombre.
Ambos modelos parten del producto del capítulo 9, front porch welcome sign wall décor. Lee lo que escribió cada uno y luego mide los 8 productos que el registro describió, cada uno sin una descripción en la que apoyarse:
1"""Prints what the base and the tuned model wrote for one product with no description, then measures every such product's2text for materials its name doesn't give and for repeated four-word phrases. The prose's points rest on the last four3printed lines, the two models' invented-material counts and repeat shares.4"""5from collections import Counter67from lib import claims, recorded89# the recording's saved texts for every product, read back rather than generated again10described = recorded.read("instruction-tuning", "descriptions")11product = next(row for row in described if row["name"] == "front porch welcome sign wall décor")12print("product:", product["name"])13print("base model:", " ".join(product["base"]["text"].split()))14print("tuned model:", " ".join(product["tuned"]["text"].split()))151617def repeats(text):18 """The share of four-word phrases that repeat an earlier one in the text."""19 words = text.lower().split()20 # every window of four consecutive words, so a text of n words has n - 3 of them21 phrases = [tuple(words[i:i + 4]) for i in range(len(words) - 3)]22 # a phrase counts as repeated each time after its first appearance; max keeps a text of fewer than four words from dividing by zero23 return sum(count - 1 for count in Counter(phrases).values()) / max(len(phrases), 1)242526print("products described, none of which has a description to draw on:", len(described))27for role in ["base", "tuned"]:28 texts = [row[role]["text"] for row in described]29 # materials the text names that the product's name doesn't give: a set difference, not the text's whole list30 invented = sum(bool(claims.materials(row[role]["text"]) - claims.materials(row["name"])) for row in described)31 print(f"{role} model, descriptions that name a material the name doesn't:", f"{invented} of {len(described)}")32 print(f"{role} model, repeated four-word phrases:", f"{sum(map(repeats, texts)) / len(texts):.0%}")
python base-and-tuned.pyproduct: front porch welcome sign wall décor
base model: Front porch welcome sign wall décor The front porch is a common feature of many homes. It is a place where people can relax and enjoy the outdoors. It is also a place where people can socialize and meet new friends. The front porch is a great place to hang out with your family
tuned model: "Welcome to our front porch welcome sign wall décor, a space that brings warmth and comfort to your home. This wall is a statement piece that showcases your personality and style. With a mix of rustic and modern elements, you can create a unique and inviting atmosphere that reflects your individuality.
products described, none of which has a description to draw on: 8
base model, descriptions that name a material the name doesn't: 2 of 8
base model, repeated four-word phrases: 14%
tuned model, descriptions that name a material the name doesn't: 1 of 8
tuned model, repeated four-word phrases: 0%
El modelo base escribe sobre porches delanteros, The front porch is a common feature of many homes, y después sobre relajarse y reunirse con amigos. Continúa el texto en una dirección plausible, pero no es la que necesita la tienda. El modelo ajustado escribe algo con forma de descripción de producto, a statement piece that showcases your personality and style, pero llama al letrero a space y This wall: con fluidez habla de un producto que no entiende. En el conjunto de productos, los textos del modelo base repiten 14% de sus frases de cuatro palabras, y los del modelo ajustado, 0%. El registro no puede decir qué etapa del ajuste detuvo los bucles.
Ningún modelo sabe nada de los productos más allá de sus nombres. El modelo base nombró un material que el nombre no indica en 2 of 8 descripciones, y el modelo ajustado en 1 of 8, y cada uno de esos datos vino del modelo, no de los datos de la tienda, como ocurrió con lo del capítulo 9.
Regla práctica: Usa un modelo ajustado cuando necesites que se siga una petición, y un modelo base cuando necesites que un texto continúe en el estilo de lo que venía antes. No tomes la fluidez por conocimiento: un modelo ajustado escribe una descripción mejor estructurada a partir de la misma falta de datos.
Formatea la request como se ajustó el modelo
El modelo ajustado respondió en la sección anterior porque su request llegó con el formato en el que fue ajustado. La plantilla de chat de un modelo ajustado es el formato que aprendió: tokens especiales que marcan dónde empiezan y terminan un mensaje de sistema, las instrucciones colocadas antes de la solicitud del usuario, la solicitud misma y la respuesta del modelo. El modelo aprendió a responder solicitudes solo en ese formato, así que una solicitud en cualquier otra forma es solo texto que continuar. Las bibliotecas que cargan el modelo aplican la plantilla desde los archivos del tokenizador del modelo (configuración del tokenizador).
El prompt completo del modelo ajustado, y su respuesta junto a la que da a la misma solicitud como texto plano, muestran lo que realmente leyó:
1"""Prints the full prompt the tuned model read, with its chat template, and its reply with and without the template. The2prose's point rests on the last two printed lines: the same words, with and without the template.3"""4from lib import recorded56template = recorded.read("instruction-tuning", "template")7# the request is the text between the user marker and its end marker8print("request:", template["with"]["prompt"].split("<|im_start|>user\n")[1].split("<|im_end|>")[0])9print("what the tuned model reads, with its chat template:")10print(template["with"]["prompt"])11print("tuned model, with the template:", " ".join(template["with"]["text"].split()))12print("tuned model, without it:", " ".join(template["without"]["text"].split()))
python chat-template.pyrequest: Write a short product description for: front porch welcome sign wall décor
what the tuned model reads, with its chat template:
<|im_start|>system
You are a helpful AI assistant named SmolLM, trained by Hugging Face<|im_end|>
<|im_start|>user
Write a short product description for: front porch welcome sign wall décor<|im_end|>
<|im_start|>assistant
tuned model, with the template: "Welcome to our front porch welcome sign wall décor, a space that brings warmth and comfort to your home. This wall is a statement piece that showcases your personality and style. With a mix of rustic and modern elements, you can create a unique and inviting atmosphere that reflects your individuality.
tuned model, without it: .
El ajuste enseñó al modelo a seguir solicitudes en un formato, no solicitudes en general. Con la plantilla, la solicitud queda entre <|im_start|>user y <|im_end|>, después de un mensaje de sistema que la plantilla añade por defecto, You are a helpful AI assistant named SmolLM, trained by Hugging Face, y antes de <|im_start|>assistant, donde empieza la respuesta del modelo. El modelo responde con la descripción de la sección anterior. Sin la plantilla, con las mismas palabras como texto plano, el modelo ajustado escribe . y se detiene.
El mensaje de sistema también importa: forma parte de cada solicitud que lee el modelo, así que uno distinto, como una descripción de la tienda y su tono, puede cambiar cualquier respuesta. Por eso es un parámetro que conviene elegir y registrar, como un parámetro de decodificación en el capítulo 9.
Regla práctica: Formatea siempre las solicitudes a un modelo ajustado con su propia plantilla de chat, aplicada por la biblioteca desde los archivos del tokenizador del modelo, nunca armada a mano. Revisa el mensaje de sistema por defecto de la plantilla, ya que el modelo lo lee en cada solicitud, y registra el prompt completo formateado junto con cada respuesta que conserves.
Medir detalles inventados de productos
Un modelo que escribe sobre un producto sin datos concretos tiene que inventar los detalles. La prueba más justa le da los datos. Ambos modelos SmolLM2 reciben el nombre de un producto y su descripción real, y se les pregunta: What material is this product made of? Answer in a few words, using only the description. El modelo ajustado recibe la pregunta como una petición en su plantilla; el modelo base la recibe como un listado que debe continuar, que termina en Question:, la pregunta, y Answer:. Si los datos del producto nombran un material, una buena respuesta lo nombra; si no, una buena respuesta indica que la descripción no lo dice.
Para revisar las respuestas se usa una lista de palabras que designan materiales, desde wood y metal hasta polyester y leather, en el módulo compartido del libro lib.claims. Una respuesta es respaldada si todos los materiales que nombra aparecen en el nombre o la descripción del producto. Una respuesta es inventada si nombra un material que no aparece en el nombre ni en la descripción del producto. Una respuesta es declinada si indica que los datos del producto no lo dicen, y ninguna si no nombra ningún material y tampoco rechaza. La prueba tiene límites y exige juicios: cuenta la madera de ingeniería, como mdf y rubberwood, como madera; cuenta brushed nickel finish como una mención del níquel; y no detecta un material que la lista no incluya. Cada respuesta que clasifica queda registrada para que cualquiera pueda leerla. Inventar un detalle que la entrada no respalda es un tipo de lo que se llama alucinación (Ji et al., 2023), y esta prueba mide exactamente ese tipo.
Clasifica las respuestas de cada modelo para 40 productos elegidos al azar, separados según si los datos del producto nombran un material. Cuando los datos no nombran ninguno, ¿el modelo ajustado inventará menos materiales que el modelo base? Decídelo antes de mirar.
1"""Classes both models' answers to the material question, split by whether the product's name or description names a2material. The prose's point rests on the rows for products whose data names none: made up and declined.3"""4from collections import Counter56from lib import claims, recorded78asked = recorded.read("instruction-tuning", "answers")9print("products asked, each with its description given:", len(asked))10# a product's data names a material if its description or its name does: the union of the two sets11given = [bool(claims.materials(row["description"]) | claims.materials(row["name"])) for row in asked]12print("products whose name or description names a material:", sum(given))13print("products whose name and description name none:", len(given) - sum(given))14for role in ["base", "tuned"]:15 for label, keep in [("data names a material", True), ("data names none", False)]:16 rows = [row for row, named in zip(asked, given) if named == keep]17 # each answer is classed against the product's data, by the rules in lib.claims18 counts = Counter(claims.classify(row[role]["text"], row["description"], row["name"]) for row in rows)19 for kind in ["supported", "made up", "none", "declined"]:20 print(f"{role} model, {label}, {kind}:", counts[kind])
python made-up-materials.pyproducts asked, each with its description given: 40
products whose name or description names a material: 28
products whose name and description name none: 12
base model, data names a material, supported: 24
base model, data names a material, made up: 2
base model, data names a material, none: 2
base model, data names a material, declined: 0
base model, data names none, supported: 0
base model, data names none, made up: 7
base model, data names none, none: 5
base model, data names none, declined: 0
tuned model, data names a material, supported: 23
tuned model, data names a material, made up: 3
tuned model, data names a material, none: 2
tuned model, data names a material, declined: 0
tuned model, data names none, supported: 0
tuned model, data names none, made up: 8
tuned model, data names none, none: 4
tuned model, data names none, declined: 0
| Respuesta | Base, los datos nombran un material | Ajustado, los datos nombran un material | Base, los datos no nombran ninguno | Ajustado, los datos no nombran ninguno |
|---|---|---|---|---|
| Respaldada | 24 | 23 | 0 | 0 |
| Inventada | 2 | 3 | 7 | 8 |
| Ninguna | 2 | 2 | 5 | 4 |
| Rechazada | 0 | 0 | 0 | 0 |
En los 12 productos cuyo nombre y descripción no nombran ninguno, la respuesta correcta es que la descripción no lo dice, y ninguno de los dos modelos la dio ni una sola vez. Ambos inventaron mayormente un material, y el resto de sus respuestas no nombró ninguno y tampoco explicó por qué. De los productos, 28 tienen datos que nombran un material, y en esos casos ambos modelos responden mayormente a partir de ellos.
El ajuste por instrucciones no corrigió esto, y en estos productos el modelo base, al recibir un listado que continuar, no lo hizo peor. La petición pedía usar solo la descripción; cuando la descripción no tenía respuesta, los modelos respondían igualmente, con un material que productos como este suelen tener. Seguir la forma de una instrucción no equivale a saber cuándo no se sabe algo.
Regla práctica: Prueba un modelo con preguntas que su entrada no puede responder, no solo con las que sí puede, y cuenta por separado las respuestas inventadas. Verifica cada afirmación factual que un modelo haga sobre un producto frente a los datos del producto, de forma automática cuando sea posible, como hace lib.claims con los materiales.
Comprueba si la confianza te advierte
La sección anterior clasificó las respuestas del modelo ajustado a la pregunta sobre el material como respaldadas o inventadas. Si sus respuestas inventadas llegaban con baja confianza, la baja confianza podría señalarlas. Un modelo cuya confianza coincide con la frecuencia con que acierta se llama calibrado, y Guo y colaboradores encontraron que las redes neuronales profundas que estudiaron a menudo no lo están: se mostraban más seguras de lo que su precisión justificaba (Guo et al., 2017). La grabación guardó la probabilidad que el modelo ajustado asignó a cada token que escribió, incluido su token de fin, así que se puede calcular una confianza por token para cada respuesta, como media geométrica:
confianza por token = exp((log p₁ + … + log pₙ) / n)
es decir, la exponencial del promedio de los logaritmos de probabilidad, el mismo promedio que la perplejidad invierte, de modo que una respuesta corta y una larga se miden en la misma escala.
¿La confianza distingue los dos tipos? Compara la confianza del modelo ajustado en sus respuestas respaldadas y en sus respuestas inventadas, y cuenta cuántas de cada tipo conservaría un umbral de 0.5 por token:
1"""Compares the tuned model's confidence in its supported and made-up answers to the material question, and counts what a2threshold of 0.5 per token keeps. The prose's point rests on the two average confidences and the two threshold counts.3"""4import numpy as np56from lib import claims, recorded78asked = recorded.read("instruction-tuning", "answers")9# only supported and made-up answers are compared; declined and none answers are left out10by_kind = {"supported": [], "made up": []}11for row in asked:12 kind = claims.classify(row["tuned"]["text"], row["description"], row["name"])13 if kind in by_kind:14 # the geometric mean of the token probabilities: exp of their average log-probability15 by_kind[kind].append(np.exp(np.mean(np.log(row["tuned"]["token_probabilities"]))))16for kind, confidence in by_kind.items():17 print(f"tuned model, {kind} answers:", len(confidence))18 print(f"tuned model, {kind} answers, average probability per token:", f"{np.mean(confidence):.2f}")19# a fixed cut for the comparison, not one fitted to these answers20threshold = 0.521for kind, confidence in by_kind.items():22 print(f"tuned model, {kind} answers above {threshold} per token:", f"{sum(c > threshold for c in confidence)} of {len(confidence)}")
python answer-confidence.pytuned model, supported answers: 23
tuned model, supported answers, average probability per token: 0.65
tuned model, made up answers: 11
tuned model, made up answers, average probability per token: 0.45
tuned model, supported answers above 0.5 per token: 21 of 23
tuned model, made up answers above 0.5 per token: 3 of 11
La confianza es una señal, no un filtro: desplaza las probabilidades, y deja pasar errores cometidos con seguridad. Las respuestas inventadas tienen en promedio menor confianza, 0.45 por token frente a 0.65 en las respaldadas. Pero un umbral de 0.5 por token conservaría 21 of 23 respuestas respaldadas y aun así dejaría pasar 3 of 11 inventadas. Con tan pocas respuestas, estas son tendencias, no tasas en las que debas confiar.
Regla práctica: No uses la confianza de un modelo por sí sola para decidir si confías en una respuesta. Mide cómo se relaciona su confianza con acertar en tus propias preguntas, y si usas un umbral, elígelo a partir de esas mediciones y cuenta lo que deja pasar.
Encuentra lo que pierde un contexto más largo
La pregunta sobre materiales le dio al modelo un producto a la vez. El asistente de una tienda suele tener delante los datos de varios productos a la vez, como resultados de búsqueda, una página de categoría o una comparación, y debe encontrar los detalles del producto correcto entre los demás. Liu y sus colegas descubrieron que los modelos usan mejor la información al principio y al final de un contexto largo que la que está en medio (Liu et al., 2024).
Coloca el producto consultado entre 10 fichas de producto: primero, en medio o al final. Luego pregunta al modelo ajustado, SmolLM2-360M-Instruct, de qué materiales está hecho ese producto. Cuenta las respuestas que nombran solo sus propios materiales, tal como las verifica lib.claims, para los 14 productos cuyos datos nombran alguno:
1"""Counts the tuned model's answers that name only the asked product's own materials, with the product first, in the middle2or last of a context of listings. The prose's point rests on the three placement lines.3"""4from collections import defaultdict56from lib import claims, recorded78context = recorded.read("instruction-tuning", "context")9# the other listings in each context; the asked product is one more, as the first printed line shows10others = recorded.read("instruction-tuning", "manifest")["settings"]["context_others"]11print("product listings in each context:", others + 1)12results = defaultdict(list)13for row in context:14 # only products whose data names a material: a product with none gives an answer nothing to name15 if claims.materials(row["description"]) | claims.materials(row["name"]):16 # supported: every material the answer names is in the asked product's own data17 results[row["place"]].append(claims.classify(row["tuned"]["text"], row["description"], row["name"]) == "supported")18print("products asked about at each place:", len(results["first"]))19for place in ["first", "middle", "last"]:20 print(f"product placed {place}, answers that name only its own materials:", f"{sum(results[place])} of {len(results[place])}")
python answer-position.pyproduct listings in each context: 10
products asked about at each place: 14
product placed first, answers that name only its own materials: 12 of 14
product placed middle, answers that name only its own materials: 6 of 14
product placed last, answers that name only its own materials: 12 of 14
El producto que está en medio es el que se encuentra con menos frecuencia, el mismo patrón que Liu y sus colegas encontraron en modelos mucho más grandes. Con el producto al principio, 12 of 14 respuestas nombran solo sus materiales; al final, 12 of 14; en medio, 6 of 14. Los recuentos son pequeños, pero la diferencia es amplia. El contexto aquí es corto, de unos pocos miles de caracteres, muy por debajo del límite del modelo: la parte media pierde detalles mucho antes de que el contexto esté lleno.
Regla práctica: Coloca los detalles que más necesita un modelo al principio o al final de su contexto, no en medio, y dale tan poco texto no relacionado como permita la tarea. Prueba la recuperación desde un contexto más largo en cada posición antes de confiar en que un modelo encuentre detalles entre muchos.
Adapta un modelo a tu texto
El capítulo 10 encontró que el modelo general era mucho peor que el modelo pequeño de la tienda con los nombres de la tienda, por palabra. El ajuste por instrucciones cambia cómo responde un modelo, no lo que sabe sobre una sola tienda. La forma de enseñarle a un modelo general el texto de la tienda es el ajuste fino (fine-tuning): seguir entrenándolo con ese texto, con el mismo ciclo de entrenamiento del capítulo 8, partiendo de los pesos del modelo general en lugar de pesos aleatorios.
El ajuste fino completo actualiza todos los pesos, lo que para un modelo de cientos de millones de parámetros requiere tiempo y memoria. LoRA, la adaptación de bajo rango, congela los pesos del modelo y entrena una pequeña corrección junto a algunos de ellos. Para una matriz de pesos que transforma k números en d números, entrena una matriz B de d por r y una matriz A de r por k, y suma su producto a los pesos: W + BA (Hu et al., 2022). Con un rango r pequeño, hay mucho menos que entrenar y almacenar, y Hu y sus colegas encontraron que igualaba al ajuste fino completo en las tareas que probaron.
Una corrección LoRA entrena muchos menos pesos; cuéntalos en SmolLM2-360M, adaptando los pesos de consulta y de valor de cada capa, con dos rangos, frente al ajuste fino completo. Los pesos de consulta transforman 960 números en 960; los pesos de valor, porque las claves y los valores están agrupados, transforman 960 en 320:
1"""Counts what LoRA would train on SmolLM2-360M, adapting the query and value weights of every layer at two ranks, and2what full fine-tuning trains. The prose's point rests on the rank 8 lines and the full fine-tuning count.3"""4from lib import open_model56config = open_model.config("SmolLM2-360M")7width, layers = config["hidden_size"], config["num_hidden_layers"]8# keys and values share heads, so their width is the query width scaled by the ratio of key-value heads to heads9key_value_width = config["num_key_value_heads"] * width // config["num_attention_heads"]10# every parameter of the model: the full fine-tuning count, and the denominator of each share11total = open_model.parameters(config)["total"]12for rank in [8, 64]:13 # LoRA adds two small matrices beside each adapted weight: width x rank, then rank x output width.14 added = layers * (rank * (width + width) + rank * (width + key_value_width)) # on the query and value weights15 print(f"rank {rank}, parameters trained:", f"{added:,}")16 print(f"rank {rank}, share of the model's parameters:", f"{added / total:.2%}")17print("parameters trained by full fine-tuning:", f"{total:,}")
python lora-parameters.pyrank 8, parameters trained: 819,200
rank 8, share of the model's parameters: 0.23%
rank 64, parameters trained: 6,553,600
rank 64, share of the model's parameters: 1.81%
parameters trained by full fine-tuning: 361,821,120
Con rango 8, LoRA entrena 819,200 parámetros, 0.23% del modelo, mientras que el ajuste fino completo entrena los 361,821,120. Una corrección de rango 8 es más pequeña que el propio modelo pequeño de la tienda, y puede guardarse y cambiarse por tarea mientras los pesos base se comparten.
Este libro no ejecuta el ajuste fino: nuestro criterio es que incluso LoRA, sobre el texto de la tienda, tardaría mucho más en un procesador de portátil que cualquier grabación de este libro. Es el siguiente paso para una tienda que quiera que un modelo general escriba con su propia voz: ajustarlo con el catálogo y luego medir el resultado frente al modelo pequeño de la tienda, por palabra, como hizo el capítulo 10. El ajuste fino tiene riesgos propios. Un modelo entrenado con el catálogo aprende sus lagunas junto con su texto, como el modelo pequeño de la tienda aprendió a dejar vacía la descripción de una bombilla en el capítulo 9. Y entrenar con un solo texto acotado puede debilitar lo que el modelo sabía antes; Biderman y sus colegas encontraron que LoRA olvida menos de ello que el ajuste fino completo (Biderman et al., 2024). Ambos se miden del mismo modo que todo lo demás en este libro: con texto reservado, antes y después.
Regla práctica: Para enseñarle a un modelo general tu texto, ajústalo con ese texto, con LoRA cuando la memoria o el almacenamiento sean limitados, y mide el resultado con texto reservado del mismo tipo. No esperes que el ajuste por instrucciones ni una indicación más ingeniosa aporten un conocimiento que el modelo nunca aprendió.
Repasa la vara de medir
Este libro ha puntuado todos los modelos de la misma forma con los nombres, desde el capítulo 3 en adelante: perplejidad por token del tokenizador de la tienda, sobre los nombres de validación de la tienda. Los nombres de prueba se reservaron aparte para que las decisiones tomadas mirando los nombres de validación, como las épocas conservadas y las proporciones de mezcla, no favorecieran los resultados. Esta comparación final puntúa los cinco modelos entre los que se eligió sobre los 4,281 nombres de prueba, con las proporciones de mezcla elegidas en validación:
1"""Scores the five models the book chose between on the test names, each name's tokens and its end, and prints each2model's test perplexity. The prose's point rests on the five test perplexity lines.3"""4import numpy as np56from lib import neural, transformer7from lib.names import name_tokens8from lib.ngrams import KneserNey, ngrams, padded910# The test names, untouched until now: every model scores each name's tokens and its end. The mixing shares are the11# ones chosen on the validation names, in chapters 5 and 8.12test = name_tokens("test")13counted = KneserNey(name_tokens("train"), 4)14# padded adds the start marker three times and the end marker, so each name's first tokens have a context and its end is scored15from_counts = np.array([counted.probability(c, t) for text in test for c, t in ngrams(padded(text, 4), 4)])16from_window = neural.token_probabilities(test)17_, vocabulary, _ = transformer.load()18index = {token: i for i, token in enumerate(vocabulary)}19from_transformer = []20for name in test:21 # the transformer reads the start marker, the name, then <sep>, which ends a name where the counts end with </s>22 ids = [index[transformer.START]] + [index[t] for t in name] + [index[transformer.SEP]]23 probabilities = transformer.softmax(transformer.forward(ids)[:-1])24 # position i predicts token i + 1, so ids[1:] is each token's target, the end of the name included25 from_transformer += list(probabilities[np.arange(len(ids) - 1), ids[1:]])26from_transformer = np.array(from_transformer)2728# pooled over every token of every name, not averaged per name29perplexity = lambda p: f"{np.exp(-np.log(p).mean()):.1f}"30print("test names:", f"{len(test):,}")31print("test perplexity, the 4-gram baseline:", perplexity(from_counts))32print("test perplexity, the window model:", perplexity(from_window))33# the mix averages the probabilities, not their logs: a share of 0.2 is 20% of the window model34print("test perplexity, the window model mixed with the counts, share 0.2:", perplexity(0.2 * from_window + 0.8 * from_counts))35print("test perplexity, the store's transformer:", perplexity(from_transformer))36print("test perplexity, the store's transformer mixed with the counts, share 0.5:", perplexity((from_transformer + from_counts) / 2))
python test-names.pytest names: 4,281
test perplexity, the 4-gram baseline: 22.9
test perplexity, the window model: 35.4
test perplexity, the window model mixed with the counts, share 0.2: 21.6
test perplexity, the store's transformer: 23.7
test perplexity, the store's transformer mixed with the counts, share 0.5: 18.3
Las decisiones tomadas en validación favorecieron muy poco los resultados: la columna de prueba se mantiene cerca de la de validación. Puestas una al lado de otra, las puntuaciones cuentan la historia del libro en una sola tabla.
| Modelo | Capítulo | Nombres de validación | Nombres de prueba |
|---|---|---|---|
| Recuentos de tokens sueltos, un 1-grama | 3 | 687.2 | |
| Recuentos de pares, un 2-grama | 3 | 46.9 | |
| Recuentos de cuatro tokens, el 4-grama de referencia | 3 | 23.1 | 22.9 |
| El modelo de ventana, una pequeña red neuronal | 5 | 36.4 | 35.4 |
| El modelo de ventana mezclado con los recuentos | 5 | 21.9 | 21.6 |
| El transformador de la tienda | 8 | 24.0 | 23.7 |
| El transformador de la tienda mezclado con los recuentos | 8 | 18.4 | 18.3 |
Tres lecciones recorren la tabla. Contar llega lejos en textos cortos y formulaicos: ningún modelo aprendido de este libro superó al 4-grama de referencia solo con nombres, y ambas mezclas lo superaron. Un modelo aprendido se gana su lugar por equivocarse en lugares distintos a los recuentos, por eso cada mezcla superó a sus dos partes. Y en textos más largos, donde importa el contexto lejano, el transformador se adelantó por sí solo, como midió el capítulo 8 con las descripciones. El tamaño por sí solo no decidió nada: el modelo general del capítulo 10, cientos de veces más grande, obtuvo 54,352.8 por palabra con los nombres de la tienda, frente a los 199.3 del transformador de la tienda.
Ninguno de estos números dice si un modelo es útil. La perplejidad mide qué tan bien un modelo predice texto parecido a su texto de entrenamiento, que es lo que necesita el autocompletado. No mide si una descripción es verdadera, si una respuesta sigue a una petición ni si una persona que compra encuentra lo que buscaba. Las pruebas de este capítulo, con materiales inventados, la confianza y el lugar de un dato dentro de un contexto, son un primer paso más allá de la perplejidad, hacia la medición de la tarea en sí.
Regla práctica: Mantén una única vara de medir fija para comparar modelos, el mismo texto, tokenizador y medida en cada ocasión, como hizo este libro. Después mide la tarea en sí, con pruebas diseñadas para ella, antes de elegir un modelo que la sirva: una perplejidad más baja es una razón para probar un modelo, no una razón para desplegarlo.
Qué sale mal en producción
Un modelo ajustado es del tipo que la gente puede usar sin ayuda, y sus fallos suenan tan fluidos como sus aciertos:
- Responde cuando debería decir que no lo sabe. Los modelos SmolLM2 base y ajustado inventaron un material para la mayoría de los productos cuyos datos no mencionaban ninguno, y ninguno de los dos indicó nunca que los datos no lo decían. Comprueba cada afirmación fáctica contra los datos del producto antes de que llegue a un cliente.
- Su confianza deja pasar errores. Las respuestas inventadas tenían en promedio menos confianza, pero un umbral que conservaba la mayoría de las respuestas correctas aun así dejaba pasar 3 of 11 de las inventadas.
- Su formato forma parte de su entrenamiento. Sin su plantilla de chat, el modelo ajustado escribía un punto final. Aplica la plantilla de los archivos del modelo y registra el prompt completo con cada respuesta.
- Se pierde el centro de un contexto. Coloca los detalles importantes al principio o al final, y prueba la recuperación en cada posición.
- No conoce su texto. El ajuste por instrucciones enseña la forma de las respuestas, no el catálogo de una tienda. Ajusta el modelo con el catálogo y mide el resultado.
- La fluidez oculta lagunas. Las descripciones del modelo ajustado se leen mejor que las del modelo base y no contienen más datos. Juzga el texto generado mediante comprobaciones de sus afirmaciones, no por cómo se lee.
- Su comportamiento depende de su revisión y de los mensajes predeterminados de su plantilla. Fija la revisión del modelo, como hace la grabación, y repite estas mediciones después de cualquier actualización.
Lo que decidió este capítulo
- El libro compara modelos base y modelos ajustados con las mismas requests, registradas una vez en revisiones fijadas y decodificadas de manera voraz (greedy), y mide sus respuestas con comprobaciones que cualquiera puede volver a ejecutar, como
lib.claimspara los materiales. - Los detalles inventados se miden tanto en preguntas que la entrada no puede responder como en las que sí puede. En los productos de la tienda, ambos modelos SmolLM2 inventaron un material para la mayoría de los productos cuyos datos no mencionaban ninguno, y ninguno se negó ni una sola vez, así que los datos de producto generados siempre se contrastan con los datos de ese producto.
- La confianza de un modelo es una señal, no un filtro. Solo se usa con un umbral medido en las preguntas propias de la tienda, y se cuentan los errores que deja pasar.
- Los detalles que necesita un modelo van al principio o al final de su contexto, nunca enterrados entre otros productos.
- La perplejidad sigue siendo la referencia del libro para comparar modelos, sobre el mismo texto, tokenizador y eventos en cada ocasión, y la tarea para la que se elige cada modelo se mide con pruebas diseñadas para esa tarea.
- Enseñar a un modelo general el texto de la tienda implica un ajuste fino, medido por palabra frente al modelo propio de la tienda; el ajuste por instrucciones cambia cómo responde un modelo, no lo que sabe. Medir un modelo dentro de una aplicación, más allá de las pruebas de siguiente token de este libro, es un tema aparte.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 9 de 9 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.