Indica a un modelo pequeño y restringe sus respuestas a los equipos

Unos 21 minutos de lectura, con 5 ejemplos en 7 secciones.

Edición 2026.11.9 Ejemplos verificados el 20 de nov de 2026 36 de 36 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.9. Lee el original

Al terminar este capítulo, podrás escribir un prompt de enrutamiento para un modelo abierto pequeño, restringir su respuesta para que solo pueda ser el nombre de un equipo y medir cuántas de esas respuestas son correctas. También verás por qué una respuesta válida no es necesariamente una respuesta correcta, y por eso el siguiente capítulo entrena un modelo en lugar de hacerle mejores preguntas.

Un enrutador necesita que cada respuesta sea el nombre de un equipo. Cuando en el capítulo 1 dejamos que un modelo pequeño respondiera en texto libre, el modelo no devolvió equipos. Este capítulo primero hace que la respuesta sea un equipo por construcción. Después ejecuta los dos modelos abiertos del capítulo 3, SmolLM2-135M-Instruct y SmolLM2-360M-Instruct, con un mismo prompt y una misma restricción, y mide lo que devuelven. El modelo de 135M es el que el capítulo 5 entrena, así que los recuentos de aquí son los que ese entrenamiento tiene que superar.

Aparecen dos tipos de números, y el capítulo los mantiene separados. Los ejemplos en vivo se ejecutan sobre los primeros seis mensajes de test_40, los primeros 40 mensajes de la muestra fija y los mismos seis para ambos modelos. Muestran el mecanismo. Seis mensajes no bastan para separar dos modelos, así que la comparación usa una grabación: cada modelo y prompt respondió una vez a los 200 mensajes de test_200, los primeros 200 de esa muestra, que incluyen esos seis, y las respuestas se guardaron. Leer la grabación no carga ningún modelo, y sus recuentos provienen solo de las respuestas guardadas y de nada más.

El prompt, fijado antes de cualquier registro

Último cambio en la edición 2026.11.9

Cada ejemplo de este capítulo usa un mismo prompt de enrutamiento. Le indica al modelo que el mensaje proviene de un banco en línea, pide un equipo de soporte y solo el nombre del equipo, enumera los 77 equipos y termina con Team:, de modo que las siguientes palabras del modelo sean la respuesta. Un modelo base que no ha sido entrenado para la tarea no recibe nada más, así que la redacción importa. Este capítulo no ajusta el prompt. El prompt se fijó antes de cualquier registro, y el manifiesto del registro guarda el hash del prompt. Un prompt modificado es un registro distinto, y sus conteos no pueden compararse con los de aquí.

La lista de equipos del prompt es la misma lista que usa la restricción. El trie de la siguiente sección se construye a partir de los mismos nombres de etiqueta, en el mismo orden, de modo que el prompt y la restricción no pueden discrepar sobre qué equipos existen. La dependencia también funciona en sentido contrario. Si añades o renombras un equipo, cambias el prompt y, por tanto, el hash del registro. Los conteos de este capítulo dejan entonces de describir ese prompt, y debes volver a registrar antes de comparar.

La forma cruda pasa el texto del prompt de enrutamiento al modelo tal como está. La forma de chat envuelve el texto del prompt de enrutamiento en la plantilla de chat del modelo, que añade un prompt de sistema predeterminado. Para ver qué cambia la plantilla, ejecuta la forma de chat con los mismos seis mensajes:

constrained-decode-135m-chat.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""Route the first 6 messages of test_40 with the 135M model through its chat template, decoding only team names.The template adds the model's default system prompt. The prose quotes this run's accuracy line next to the raw form's, and the messages are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)results = []for i in sample:    # the chat template wraps the message in the model's chat format, with its default system prompt    text = router_lib.chat_prompt(tokenizer, rows[i][0])    # the template has already written the special tokens, so the tokenizer adds none    results.append(router_lib.constrained_team_text(tokenizer, model, trie, text, add_special_tokens=False))valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Salidapython constrained-decode-135m-chat.py
messages: 6
answers that are a team: 6/6
accuracy: 0/6 (0.0%)
distinct teams given: 3
most given team: cancel_transfer, 3/6

El libro usa la forma sin formato como opción predeterminada. Esta elección se tomó antes de leer ningún registro: ambos modelos de la comparación se miden con ella, de modo que la comparación es entre modelos, no entre prompts. La forma de chat se registró después, como observación. En los 200 mensajes acertó 11/200 (5.5%), y la forma sin formato acertó 9/200 (4.5%). Una diferencia de dos mensajes en 200 no es una diferencia que esta muestra pueda mostrar en ningún sentido, así que no se muestra que la forma de chat ayude, ni que la forma sin formato perjudique, y la opción predeterminada no se cambia por este conteo. Los nombres del trie empiezan con un espacio, que sigue a Team: en la forma sin formato, pero no al salto de línea que abre la respuesta en la plantilla de chat. Por tanto, el conteo de chat corresponde a este trie además de a la plantilla. El resultado no es evidencia de que los prompts sin formato superen a las plantillas de chat en modelos pequeños en general, y una muestra de 200 mensajes no lo resuelve.

Regla práctica: Usa un mismo prompt para cada modelo que compares, en la forma que la comparación requiera. Antes de adoptar una plantilla de chat, mídela con la misma muestra que la forma sin formato, e informa una diferencia pequeña como una diferencia pequeña.

Por qué falla el texto libre

El capítulo 1 pidió al modelo base un equipo sin ninguna restricción, y el modelo decodificó libremente: voraz, tomando en cada paso el token de mayor puntuación, como en este capítulo, pero sin máscara sobre los tokens que podía elegir. Su ejemplo contó las respuestas. 0/20 eran nombres de equipo, así que el enrutador no tenía adónde enviar nada.

Nada en la propia decodificación del modelo impide que una respuesta sea una frase, un equipo que no está en la lista o una variante con ortografía casi correcta de uno de ellos. En cada paso el decodificador puede elegir cualquier token del vocabulario, de modo que la respuesta puede ir a cualquier parte. El sustituto del capítulo 1 no mostraba este fallo, porque sus respuestas registradas provenían de una gramática que solo permitía los nombres de equipo. Un modelo que se ejecuta en el enrutador necesita la misma garantía desde el propio decodificador.

La reparación tentadora consiste en tomar lo que escribió el modelo y emparejarlo con el nombre de equipo más parecido. Esa reparación es una suposición. Una ortografía casi correcta puede coincidir con el equipo correcto, o con un equipo equivocado que se parece en las letras, y entonces el enrutador enviaría el mensaje a un equipo que el modelo no nombró. El capítulo 1 indicó qué hacer en su lugar: una respuesta que no es un equipo cuenta como error, se contabiliza en la muestra y el mensaje se envía a una persona. Una restricción elimina la mayoría de esas respuestas antes de que se escriban. Aun así, el recuento se conserva, para que una restricción que no se cumple aparezca como un número y no como un cambio silencioso en el enrutamiento.

Regla práctica: Trata una respuesta que no es un equipo como una ruta fallida. Cuenta esas respuestas en una muestra fija antes de que un modelo enrute nada, y no emparejes una variante casi correcta con el equipo más cercano. Restringe la respuesta en el momento de la decodificación y conserva el recuento, de modo que una restricción rota aparezca como un número.

Un trie de tokens solo permite nombres de equipo

Último cambio en la edición 2026.11.9

Un modelo escribe tokens, no palabras, y el nombre de un equipo es una secuencia corta de ellos. build_trie en router_lib, el módulo compartido del libro, guarda los 77 nombres como un trie: un árbol cuyos caminos deletrean los tokens de cada equipo, con el índice del equipo en el nodo donde termina su camino. La función afirma que no hay dos equipos que terminen en el mismo nodo, de modo que cada camino nombra a un solo equipo.

El decodificador recorre este árbol mientras escribe. Al principio, los tokens permitidos son el primer token de cada nombre de equipo. Después de cada token, el conjunto permitido se reduce a los hijos del nodo al que ha llegado el decodificador. Cuando un camino ha terminado en un equipo, el token de fin de respuesta se une al conjunto permitido, de modo que la respuesta pueda detenerse ahí. Ninguno de los 77 nombres es el comienzo de otro, así que cada camino termina en una hoja. El código seguiría manejando un nombre que sí lo fuera: en ese nodo el decodificador podría detenerse o continuar por el nombre más largo. Un recorrido de este tipo no puede salirse de la lista, porque cada token que puede elegir conduce hacia un equipo.

La decodificación voraz toma entonces, en cada paso, el token de mayor puntuación entre los permitidos. Transformers aplica la regla mediante una función de devolución de llamada, prefix_allowed_tokens_fn, que devuelve los tokens permitidos para cada posición. El procesador parte de una máscara de menos infinito para cada token, pone en cero las entradas de los tokens permitidos y suma la máscara a las puntuaciones con scores_processed = scores + mask. Cada token no permitido conserva menos infinito, así que la decodificación voraz no puede elegirlo (transformers 5.23.0, src/transformers/generation/logits_process.py).

El sustituto del capítulo 1 obtenía la misma garantía de su biblioteca. recordings/common.py construye una gramática, root ::= "card_arrival" | ..., que enumera los 77 nombres como cadenas literales, y las grabaciones la aplicaban a través de la plantilla de chat. llama-cpp-python añade una gramática a su muestreador antes del paso voraz. En llama_cpp/llama.py la línea sampler.add_grammar(self._model, grammar) se ejecuta bajo if grammar is not None:, y sampler.add_greedy() se ejecuta después, bajo elif temp == 0.0: (llama-cpp-python v0.3.36, llama_cpp/llama.py). Así, las respuestas del sustituto estaban limitadas a los nombres por la biblioteca, mientras que la función de devolución de llamada de este capítulo hace el mismo trabajo dentro del decodificador.

Dos detalles de ese código dan forma a la devolución de llamada. El procesador la llama como self._prefix_allowed_tokens_fn(batch_id, sent), así que el índice del lote va primero. Y una lista vacía es un error: el procesador lanza ValueError cuando la función no devuelve tokens. Por eso la devolución de llamada del libro nunca devuelve una lista vacía. Cuando ningún camino puede continuar, devuelve el token de fin de respuesta, y la respuesta se detiene ahí. El token de fin de respuesta es el <|im_end|> del modelo, que también es su token de relleno (id 2). El decodificador se detiene después de 32 tokens nuevos (max_new_tokens=32). Cada una de las 600 respuestas grabadas terminó en un equipo. Un nodo sin hijos siempre contiene un equipo, así que el caso de lista vacía es una protección y no un caso que produzcan los 77 nombres.

Primero, el modelo de 135M con el trie, sobre esos seis mensajes.

constrained-decode-135m.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""Route the first 6 messages of test_40 with the 135M model, decoding only team names, and count how many right answers that gives.The point rests on the count of answers that are team names, which the trie guarantees, and on the accuracy line, which the measurement section reads. The messages are read from the test split and are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)# (label index, team text); the index comes from the trie walk, not from parsing the textresults = [router_lib.constrained_team(tokenizer, model, trie, rows[i][0]) for i in sample]valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Salidapython constrained-decode-135m.py
messages: 6
answers that are a team: 6/6
accuracy: 1/6 (16.7%)
distinct teams given: 3
most given team: card_arrival, 4/6

Ejecutado sobre 6 mensajes, las respuestas del modelo son nombres de equipo en todos los casos, 6/6, que es la garantía que da el trie. La precisión sobre los mismos mensajes es 1/6 (16.7%). La sección de medición desglosa ese segundo número.

El enrutador no lee el equipo del texto. constrained_team devuelve el índice guardado en el nodo donde terminó el recorrido, y el texto se decodifica solo para que el lector lo vea. El índice lo fija el trie y no un analizador que se ejecuta después del modelo. Esa es la razón por la que la restricción merece el código: un analizador que relaciona texto con equipos puede fallar de maneras que el trie no puede. Estos ejemplos devuelven el equipo solo para poder contarlo. Nada en este capítulo enruta un mensaje. Una ruta devuelve un equipo solo a través de handoff, que envía una respuesta incierta a una persona, y los ejemplos aquí no la llaman.

Regla práctica: Restringe la respuesta a las etiquetas con un trie de tokens construido a partir de los nombres de las etiquetas, y cuenta las respuestas que son etiquetas sobre una muestra fija. La restricción hace que cada respuesta sea un equipo. No hace que ninguna respuesta sea correcta, así que cuenta las respuestas correctas como una medida aparte.

Decodificar de forma voraz para que cada conteo se repita

Último cambio en la edición 2026.11.2

Todos los ejemplos de aquí usan decodificación voraz: gana la puntuación más alta y nada se muestrea. Eso importa para los conteos. Una respuesta muestreada variaría de una ejecución a otra, y entonces ningún conteo impreso podría comprobarse contra una salida registrada. Los ejemplos fijan sus semillas y float32 mediante router_lib.setup_runtime y usan dos hilos, así que en una misma máquina una ejecución repite sus respuestas. Cada ejemplo llama a torch.set_num_threads(2) por sí mismo, al inicio, para no depender de cómo se haya iniciado su ejecutor. La salida impresa de cada ejemplo se compara con su salida registrada en cada ejecución, y una línea cambiada hace fallar la comprobación.

Repetible en una misma máquina no es lo mismo que repetible en cualquier parte. Las notas de PyTorch 2.15.0+cpu sobre aleatoriedad indican que no se garantizan resultados totalmente reproducibles entre versiones, commits individuales o plataformas. Por eso el libro afirma repetibilidad solo para las versiones fijadas en examples/requirements.txt, en el tipo de máquina en que se ejecutó el libro. Si usas otra plataforma, debes esperar tener que volver a comprobar las líneas registradas. Si una línea registrada falla allí, lee la línea cambiada antes de tocar el ejemplo. Un conteo distinto de respuestas correctas puede venir de otra máquina, otra versión de la biblioteca o un prompt modificado, y cada uno de esos casos requiere una solución diferente.

Los empates también necesitan una regla fija. La puntuación de etiquetas en la última sección resuelve un empate en la puntuación por el índice de equipo más bajo, mediante su clave de ordenación (score, -index), y el conteo del equipo más repetido entre las respuestas resuelve un empate en el conteo por el nombre del equipo. La decodificación con restricciones no tiene puntuaciones por equipo. Su paso voraz toma el primer máximo entre los tokens permitidos, así que en ese caso un empate se resuelve a favor del id de token más bajo.

Regla práctica: Usa decodificación voraz, fija las semillas y el número de hilos, y compara cada línea impresa con una copia registrada en cada ejecución. No describas un resultado como reproducible más allá de las versiones y del tipo de máquina en que se ejecutó.

Mide las respuestas restringidas

Último cambio en la edición 2026.11.2

Los ejemplos en vivo cubren seis mensajes. El modelo de 135M con el prompt sin formato acertó 1/6 (16.7%), y el modelo de 360M acertó 0/6 (0.0%). Seis mensajes no bastan para ordenar estos modelos: una sola respuesta correcta es toda la diferencia entre esos dos recuentos. La respuesta más frecuente del modelo de 135M fue card_arrival, 4/6, y la forma de chat sobre los mismos seis mensajes dio 0/6 (0.0%).

La ejecución de 360M es el mismo programa con el modelo más grande.

constrained-decode-360m.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""Decode team names for the first 6 messages of test_40 with the 360M model, and count how many of them are right.The prose sets its accuracy line against the 135M model's, on the same six messages. The messages are read from the test split and are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()MEDIUM = "HuggingFaceTB/SmolLM2-360M-Instruct"tokenizer, model = router_lib.load_model(MEDIUM)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)# (label index, team text); the index comes from the trie walk, not from parsing the textresults = [router_lib.constrained_team(tokenizer, model, trie, rows[i][0]) for i in sample]valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Salidapython constrained-decode-360m.py
messages: 6
answers that are a team: 6/6
accuracy: 0/6 (0.0%)
distinct teams given: 4
most given team: card_payment_wrong_exchange_rate, 3/6

Para la comparación, cada variante respondió 200 mensajes. Los recuentos de la grabación están en la tabla, con los mismos mensajes en cada fila:

Variante sobre test_200 Respuestas fuera de la lista de equipos Correctas Equipos distintos asignados
135M, prompt sin formato 0/200 9/200 (4.5%) 18
135M, plantilla de chat 0/200 11/200 (5.5%) 17
360M, prompt sin formato 0/200 12/200 (6.0%) 8

Este ejemplo lee los recuentos de la tabla a partir de la grabación:

prompting-on-test-200.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Superado
"""Compare the three prompting variants on test_200, from the recording only. No model is loaded.The chapter's table takes its three columns from the first three lines printed for each variant, and the point rests on the correct count.recordings/prompting_eval.py wrote one answer per variant and message to examples/data/recorded/prompting-eval/answers.jsonl."""import collectionsimport jsonfrom pathlib import Pathimport torch# two threads, as in the other examplestorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, as in the other examplesrouter_lib.setup_runtime()ANSWERS = Path(__file__).resolve().parent / "data" / "recorded" / "prompting-eval" / "answers.jsonl"teams = set(router_lib.LABELS)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# the 200 messages of the fixed sample; every variant answers all of themtotal = len(router_lib.read_sample("test_200"))by_variant = collections.defaultdict(list)with open(ANSWERS) as f:    for line in f:        answer = json.loads(line)        by_variant[answer["variant"]].append(answer)for variant in sorted(by_variant):    answers = by_variant[variant]    outside = sum(answer["team"] not in teams for answer in answers)    # answer["label"] is the team index the variant chose; rows[...][1] is the message's gold index    right = sum(answer["label"] == rows[answer["index"]][1] for answer in answers)    given = collections.Counter(answer["team"] for answer in answers)    # most given team; a tie in count goes to the team name that sorts first, not to the index    top = min(given, key=lambda team: (-given[team], team))    # the gold index becomes a team name, to compare with the most given team    gold_top = sum(router_lib.LABELS[rows[answer["index"]][1]] == top for answer in answers)    print(f"{variant} answers outside the team list: {outside}/{total}")    print(f"{variant} correct: {right}/{total} ({100 * right / total:.1f}%)")    print(f"{variant} distinct teams given: {len(given)}")    print(f"{variant} most given team: {top}, {given[top]}/{total}")    print(f"{variant} gold for most given team: {gold_top}/{total}")
Salidapython prompting-on-test-200.py
135m-chat answers outside the team list: 0/200
135m-chat correct: 11/200 (5.5%)
135m-chat distinct teams given: 17
135m-chat most given team: topping_up_by_card, 55/200
135m-chat gold for most given team: 1/200
135m-raw answers outside the team list: 0/200
135m-raw correct: 9/200 (4.5%)
135m-raw distinct teams given: 18
135m-raw most given team: card_arrival, 165/200
135m-raw gold for most given team: 0/200
360m-raw answers outside the team list: 0/200
360m-raw correct: 12/200 (6.0%)
360m-raw distinct teams given: 8
360m-raw most given team: card_payment_wrong_exchange_rate, 94/200
360m-raw gold for most given team: 4/200

Ninguna fila se acerca a un enrutador, aunque la restricción se cumple en todas: ninguna respuesta de ninguna fila está fuera de la lista de equipos. La fila de 360M sin formato tiene más respuestas correctas, con 12/200 (6.0%), y ninguna fila supera a otra por más de unos pocos mensajes.

Los equipos distintos por sí solos engañan. La fila de 135M sin formato asigna 18 equipos distintos, frente a 8 de la fila de 360M sin formato, pero la mayoría de las respuestas de la fila de 135M van a un solo equipo, card_arrival, 165/200, mientras que el equipo más asignado en la fila de 360M sin formato recibe solo card_payment_wrong_exchange_rate, 94/200.

Para leer una fila, empieza por la primera columna. Si no es cero, la restricción no se ha cumplido, y las otras dos columnas no significan nada hasta que eso se corrija. La segunda columna es la que importa para el enrutamiento: cuenta los mensajes cuyo equipo es la etiqueta correcta, sobre el total de la muestra, contando las respuestas erróneas como erróneas. La tercera columna indica cuántos equipos usa en total cada variante. Una variante que da solo unos pocos equipos o bien adivina unos cuantos equipos populares o bien ha aprendido algo estrecho, y el recuento no dice cuál de las dos cosas es. Un recuento alto tampoco descarta la concentración, como muestra la fila de 135M sin formato. Quien ejecute los mismos tres recuentos sobre una muestra de sus propios mensajes obtiene una comparación con sus propios datos, con el mismo significado en cada columna.

El modelo de 360M es el más grande de los dos, y el capítulo 3 calculó cuánto más grande es. La tabla muestra lo que ese tamaño aporta con este prompt y esta restricción: 12/200 (6.0%) aciertos, frente a 9/200 (4.5%) del modelo de 135M en la misma forma sin formato. Son unos pocos mensajes más por un modelo más grande, y el libro no lo considera una razón para pagar el tamaño extra.

El libro no calcula ningún intervalo para estos recuentos, y una diferencia de unos pocos mensajes de cada 200 podría deberse a la muestra, así que la tabla respalda una sola afirmación: las tres variantes están cerca, y ninguna es un enrutador. Quien quiera elegir entre dos prompts debe ejecutar ambos sobre una muestra de sus propios mensajes y contar las mismas tres cosas.

El trie solo comprueba la forma de la respuesta y nada más. No lee el mensaje más allá del prompt, y no sabe qué equipo es el correcto. Cualquier equipo de la lista está permitido en cada paso en que su nombre aún puede escribirse, así que la elección del decodificador entre ellos es la elección del modelo, y la máscara solo decide qué equipos pueden escribirse en absoluto.

Aquí tienes una respuesta válida pero errónea, descrita solo por sus equipos, ya que este libro nunca cita mensajes. Un mensaje de prueba cuyo equipo correcto es card_not_working recibió card_arrival de la fila de 135M sin formato, un equipo de la lista, así que la restricción lo dejó pasar y el recuento de respuestas fuera de la lista se mantiene en cero.

La lección que respaldan los resultados es que la decodificación restringida hace que cada respuesta sea un equipo, pero una respuesta válida no es una respuesta correcta. La restricción solo elimina las respuestas que no son equipos. No elige un equipo mejor, y el cambio de prompt tampoco lo hizo. El capítulo 5 es el siguiente paso: entrena un cabezal sobre los mensajes etiquetados y mide si el modelo entrenado enruta mejor sobre la misma muestra.

En producción el fallo no aparece como un error. El recuento de respuestas que no son equipos se mantiene en cero, así que una comprobación que vigile solo ese recuento sigue en verde. Solo un recuento de respuestas correctas sobre una muestra fija y etiquetada muestra el problema.

El coste recae sobre las personas que reciben el mensaje. Un equipo válido pero erróneo envía el mensaje al destino equivocado, donde el personal de soporte ve una solicitud que no es suya, y debe encontrar el equipo correcto y trasladarla, el mismo trabajo que genera un traspaso, sin ninguna señal en el mensaje de que fue mal enrutado. Un enrutador que no puede indicar cuándo no está seguro no les da nada en que apoyarse. La decodificación restringida tampoco devuelve una puntuación para los otros 76 equipos, así que una regla de traspaso construida sobre ella no tendría puntuaciones por equipo que comparar.

Regla práctica: Informa del recuento de respuestas correctas junto al recuento de respuestas válidas, sobre una misma muestra fija, para cada variante que compares. Un enrutador cuyas respuestas son todas válidas puede equivocarse en la mayoría de los mensajes, y solo el segundo recuento lo muestra.

Esta parte aún no está traducida, así que está en inglés.

Why a prior is not a router

Último cambio en la edición 2026.11.9

Constrained decoding returns one answer and no scores. Label scoring gives every team a score. For each team, label scoring sums the log-probability of the team's tokens after the prompt, where a log-probability is the logarithm of the probability the model gives a token. The team with the highest sum is the model's top team for the message.

Run it on three messages and read the top team of each:

label-scoring-prior.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Superado
"""Score every team for the first 3 messages of test_40 with the 135M model, by the summed log-probability of its tokens.This shows the model's prior, the team it favours before any fine-tuning. The point rests on the most frequent top team and how many messages it tops. The messages are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)rows = router_lib.read_rows("test")# row numbers of the first three messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 3)# each team's token ids, padded to the longest name, built once for all messagestable = router_lib.label_token_table(tokenizer)tops = []for i in sample:    scores = router_lib.label_scores(tokenizer, model, table, rows[i][0])    # index of the highest-scoring team; a tie goes to the lower index    tops.append(max(range(len(scores)), key=lambda k: (scores[k], -k)))counts = collections.Counter(tops)# most frequent top team; a tie in count goes to the lower indexbest = min(counts, key=lambda k: (-counts[k], k))print(f"messages: {len(sample)}")print(f"distinct top teams: {len(counts)}")print(f"most frequent top team name: {router_lib.LABELS[best]}")print(f"most frequent top team: {counts[best]} of {len(sample)}")
Salidapython label-scoring-prior.py
messages: 3
distinct top teams: 1
most frequent top team name: card_arrival
most frequent top team: 3 of 3

Before any training, the model puts one team first for every message: card_arrival tops 3 of 3 messages. That team is the model's prior, and three messages are too few to say more about it.

If the top team is the same for every message, the score is the model's prior and says little about any one message. The 200-message recording shows the same prior in constrained decoding: card_arrival, 165/200, the 135M raw row's favourite, is the gold team of 0/200 messages in the sample.

The sum favours short names. Each token of a team's name adds a log-probability, which is never above zero, so a team with more tokens has more terms to pull its total down. The example adds the terms without dividing by length, and the chapter does not claim to correct for it. A reader who uses label scoring should check the top teams against a sample with gold labels before trusting them.

Label scoring does give a score for each team, which is what a hand-off rule needs. Each message is scored against all 77 team names, which the code scores in one batch after the prompt runs once. Chapter 5 gets a score for each team from a single forward pass through a head that is trained on labelled messages. Label scoring is the bridge from this chapter to that one: it shows that the model already has per-team scores, and that before training they say little about the message.

Working rule: Use label scoring to see which team a model favours before training, and do not route with it. Do not route messages with a prompted model of this size on this task; the 200-message recording is the evidence. Train a head on the labelled messages instead, as chapter 5 does.

Lo que decidió este capítulo

Último cambio en la edición 2026.11.2

Las reglas de este capítulo se limitan a estos dos modelos, a este prompt y a esta restricción, sobre los 200 mensajes de la grabación. Un modelo más grande, otro prompt o una muestra más larga podrían cambiar los recuentos, y el libro no ha probado ninguno de ellos en esa muestra. Lo que sí establece el capítulo es más acotado: con el prompt en bruto y el trie, un modelo de este tamaño devuelve equipos válidos y pocas respuestas correctas, y el recuento de respuestas correctas es la cifra que conviene vigilar.

Cada decisión se prueba en su propia sección: el prompt en la primera, el trie en su sección y la decodificación voraz en su sección, y los dos recuentos en la sección de medición. Si cambias cualquiera de ellos, debes volver a grabar antes de comparar, como indica la primera sección. Una restricción hace que todas las respuestas sean válidas, y solo el entrenamiento puede hacerlas correctas.

Este capítulo tomó estas decisiones:

  • El prompt del enrutador es la forma en bruto, y ambos modelos de la comparación lo usan.
  • La decodificación restringida usa un trie de tokens sobre los 77 nombres de equipo, con decodificación voraz y semillas fijas.
  • Cada variante se informa con su recuento de respuestas válidas y su recuento de respuestas correctas, sobre una misma muestra fija.
  • Los ejemplos en vivo muestran cómo funciona cada pieza, y solo la grabación de 200 mensajes compara modelos.

Este capítulo, en esta edición

Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 5 de 5 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.9.

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 4 de 10: Indica a un modelo pequeño y restringe sus respuestas a los equipos

  1. El prompt, fijado antes de cualquier registro
  2. Por qué falla el texto libre
  3. Un trie de tokens solo permite nombres de equipo
  4. Decodificar de forma voraz para que cada conteo se repita
  5. Mide las respuestas restringidas
  6. Why a prior is not a router
  7. Lo que decidió este capítulo

Volver arribaTodos los capítulos