Mide la tarea de enrutamiento antes de elegir un modelo
Unos 20 minutos de lectura, con 3 ejemplos en 5 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.9. Lee el original
Al terminar este capítulo, podrás decir para qué sirve cada una de las muestras del libro, calcular las tres medidas con las que se evalúa el enrutador junto con sus denominadores, y leer una línea base que se registró una sola vez y se reutiliza en cada comparación.
Hoy un modelo alojado enruta los mensajes que llegan a la bandeja de soporte del banco. El enrutador del libro es un modelo abierto pequeño que el banco podría ejecutar por sí mismo, y la pregunta es si puede igualar a ese modelo alojado en los mensajes que conserva, y si puede decirlo cuando no está seguro de un mensaje. Antes de comparar cualquier modelo, la comparación necesita datos fijos, muestras fijas y medidas fijas. De lo contrario, dos números que se parecen podrían venir de mensajes distintos, o dividirse entre cantidades distintas.
Este libro no llama a un modelo alojado, así que usa un sustituto, un modelo abierto más grande: Qwen3-4B-Instruct-2507. Sus respuestas provienen de la conversión GGUF Q4_K_M de 4 bits que publicó un tercero, en su revisión fijada, con sus respuestas limitadas a los 77 nombres de equipo. Responde a cada mensaje de prueba una sola vez, en una grabación, y los ejemplos leen esas respuestas sin conexión, de modo que cualquiera puede reproducirlos. Un lector que tenga un modelo propio puede registrar sus respuestas de la misma manera, como muestra el capítulo 1.
Los datos y su licencia
El enrutador se entrena y se mide con BANKING77, un conjunto de datos público de consultas de atención al cliente en el dominio bancario (Casanueva et al., 2020). Cada mensaje lleva una de 77 etiquetas. BANKING77 llama a sus etiquetas intents (intenciones); son los equipos de la bandeja de entrada (capítulo 1).
Casanueva et al. (2020) presentan el conjunto de datos en Efficient Intent Detection with Dual Sentence Encoders, en las actas del 2.º Workshop on Natural Language Processing for Conversational AI, páginas 38–45 (ID de Anthology 2020.nlp4convai-1.5; arXiv 2003.04807). Su resumen lo describe como un conjunto de datos difícil de un solo dominio, con 13,083 ejemplos etiquetados en 77 intenciones, y su sección 3 da el mismo recuento para el conjunto del dominio bancario, al que llaman BANKING 77. La ficha de datos indica el commit del que proceden los archivos. Los dos archivos juntos contienen los mismos 13,083 mensajes, que la siguiente sección cuenta.
La ficha de datos también recoge los hechos en los que se apoya el libro. Indica que los archivos son una copia de la división de entrenamiento y prueba del propio origen, que no se vuelve a dividir, y que cada equipo aparece en ambos archivos. Un enrutador entrenado con el archivo de entrenamiento y evaluado con el archivo de prueba se evalúa sobre los mensajes reservados del propio origen, no sobre una división que haya elegido el libro.
La licencia es CC BY 4.0. El archivo LICENSE que acompaña a los datos empieza con "Attribution 4.0 International". Con esa licencia los datos pueden compartirse y adaptarse, siempre que se acredite la fuente. El libro conserva el archivo de licencia junto a los datos y recoge la cita en la ficha de datos, de modo que quien reutilice los archivos tiene lo que la licencia exige.
Los mensajes se mantienen tal como se publicaron. Ningún ejemplo imprime el texto de los mensajes y ningún capítulo los cita, así que el contenido de los mensajes no llega a ninguna página. Todo lo que los ejemplos imprimen de los datos es un recuento o una tasa.
Regla práctica: Conserva el archivo de licencia junto a los datos, cita el artículo en la ficha de datos e imprime solo recuentos, nunca el texto de los mensajes. Si reutilizas un conjunto de datos de mensajes reales de clientes, lee su ficha antes de imprimir nada de él y cita la fuente donde se documentan los datos.
Conjuntos de desarrollo, de prueba y muestras fijas
Los dos archivos de la división original no bastan por sí solos. Un enrutador necesita mensajes para ajustarse, mensajes para informar de sus resultados y un conjunto pequeño que los ejemplos puedan ejecutar en segundos. Cada uno de ellos debe fijarse de antemano; de lo contrario, un resultado posterior podría explicarse por una muestra distinta y no por un modelo distinto.
El conjunto de desarrollo se extrae del archivo de entrenamiento, nunca del archivo de prueba. Para cada equipo, en el orden del archivo de categorías, el libro toma aproximadamente una décima parte de los mensajes de entrenamiento de ese equipo con una semilla fija, y registra los números de fila en examples/data/banking77/samples.json. Los mensajes de entrenamiento que no están en desarrollo son los que usan los modelos para entrenarse. Como la extracción se hace equipo por equipo, la proporción de cada equipo en desarrollo sigue su proporción en el archivo de entrenamiento, y un equipo con pocos mensajes de entrenamiento conserva una pequeña parte en desarrollo en lugar de ninguna.
El conjunto de prueba es el propio archivo reservado de la fuente. El libro extrae de él una muestra estratificada, 13 mensajes por equipo, lo que da 1001 mensajes en total. La muestra se mezcla una sola vez, con el mismo generador que la extracción de desarrollo, continuando después de ella, y el orden mezclado se registra. Se nombran tres prefijos de ese orden. Los primeros 40 mensajes de la muestra de prueba mezclada son test_40, los primeros 200 son test_200, y la muestra completa es test_1001. Un prefijo de una muestra mezclada es una extracción aleatoria, así que test_40 no recorre los equipos en orden.
Los recuentos proceden de las muestras registradas, y el libro cita solo esos. El primero de ellos, count-the-splits, comprueba además que cada número de fila de desarrollo sea único y esté dentro del archivo de entrenamiento, de modo que cada mensaje de desarrollo sea una fila de entrenamiento, y que test_40 y test_200 sean los primeros 40 y los primeros 200 de test_1001.
Lo primero que conviene ver es el tamaño de cada división y lo desigualmente que se reparten los equipos entre ellas. Contar no requiere ningún modelo, así que el lector puede ejecutarlo primero. Lee el archivo de entrenamiento, el archivo de prueba y la muestra de desarrollo, y cuenta cada división:
1"""Count each BANKING77 split and its messages per team, and check the committed samples; no model runs.23The prose's point rests on the four "per label" lines for the test and training files.4"""56import os78os.environ["HF_HUB_OFFLINE"] = "1"9os.environ["TRANSFORMERS_OFFLINE"] = "1"1011import torch # noqa: E4021213torch.set_num_threads(2)1415import router_lib # noqa: E40216from collections import Counter # noqa: E4021718router_lib.setup_runtime()1920train = router_lib.read_rows("train")21test = router_lib.read_rows("test")22dev = router_lib.read_sample("dev") # dev row numbers index train.csv, never test.csv2324assert len(set(dev)) == len(dev), "dev indices repeat"25assert max(dev) < len(train), "dev indices fall outside train.csv"2627train_per_label = Counter(label for _, label in train)28test_per_label = Counter(label for _, label in test)2930test_1001 = router_lib.read_sample("test_1001") # committed order: prefixes are the first n of it31test_40 = router_lib.read_sample("test_40")32test_200 = router_lib.read_sample("test_200")33# test_40 and test_200 are prefixes of the shuffled order, not new draws34assert test_1001[:40] == test_40, "test_40 is not the first 40 of test_1001"35assert test_1001[:200] == test_200, "test_200 is not the first 200 of test_1001"36sample_per_label = Counter(test[i][1] for i in test_1001) # rows are (text, label index); [1] is the label3738train_counts = [train_per_label[i] for i in range(len(router_lib.LABELS))] # one entry per team, so a team with no rows counts 039test_counts = [test_per_label[i] for i in range(len(router_lib.LABELS))]40sample_counts = [sample_per_label[i] for i in range(len(router_lib.LABELS))]4142print(f"train rows: {len(train)}")43print(f"dev rows: {len(dev)}")44print(f"test rows: {len(test)}")45print(f"labels: {len(router_lib.LABELS)}")46print(f"test per label min: {min(test_counts)}")47print(f"test per label max: {max(test_counts)}")48print(f"train per label min: {min(train_counts)}")49print(f"train per label max: {max(train_counts)}")50print(f"test_1001 per label min: {min(sample_counts)}")51print(f"test_1001 per label max: {max(sample_counts)}")
python count-the-splits.pytrain rows: 10003
dev rows: 1003
test rows: 3080
labels: 77
test per label min: 40
test per label max: 40
train per label min: 35
train per label max: 187
test_1001 per label min: 13
test_1001 per label max: 13
El archivo de prueba es uniforme, con el mismo recuento para cada equipo, mientras que el archivo de entrenamiento no lo es: sus equipos van de 35 mensajes a 187. Esa dispersión es la razón por la que la extracción de desarrollo se hace equipo por equipo y no como una décima parte aleatoria de todo el archivo. El mínimo y el máximo propios del archivo de prueba, 40 y 40, son iguales.
La muestra estratificada también es uniforme, con 13 a 13 mensajes por equipo.
Que el archivo de prueba sea uniforme es una propiedad de la fuente, y el libro se apoya en ella. Recuentos iguales por equipo significan que la división de prueba no premia a un enrutador por ser bueno con el equipo más grande. Un enrutador que obtiene buenos resultados en una muestra con recuentos desiguales puede parecer mejor de lo que es, porque la mayor parte de su puntuación procede de los equipos con más mensajes.
Capítulo 5 elige el umbral de traspaso en desarrollo y registra la elección en el manifiesto del adaptador. La regla que sustenta esa elección es ajustar sobre desarrollo, nunca sobre prueba. El prompt, el modelo y la receta se fijan antes de leer cualquier resultado de prueba, no se cambia ninguno a causa de uno, y los resultados de prueba se leen una sola vez, para informar de ellos, sobre las muestras fijas anteriores.
En producción rige la misma regla para la bandeja de entrada. Mantén un conjunto de desarrollo extraído de mensajes que la bandeja ya tenga, y un conjunto de prueba que nadie lea mientras se ajusta el enrutador. Un conjunto de prueba que se lee durante el ajuste sigue pareciendo un conjunto de prueba, pero deja de medir algo nuevo, y un enrutador que después se mide con él parecerá mejor de lo que será con el tráfico que llegue después.
Regla práctica: Extrae el desarrollo solo de filas de entrenamiento, equipo por equipo, con una semilla fija, y registra sus números de fila. Extrae cada muestra de prueba una sola vez, registra su orden y léela solo para informar. Elige cada umbral, prompt y ajuste sobre desarrollo. Cuando el desarrollo sea demasiado pequeño para decidir, extrae más mensajes de desarrollo del archivo de entrenamiento, nunca del archivo de prueba.
Tres medidas, cada una con su denominador
Las muestras indican qué mensajes puntuar. Las medidas indican qué contar. Un enrutador que devuelve un equipo, una confianza y una marca de traspaso puede puntuarse de tres maneras, y cada una responde a una pregunta distinta para el banco que lo ejecuta.
La exactitud pregunta con qué frecuencia el equipo que devuelve el enrutador es el correcto. La tasa de traspaso pregunta con qué frecuencia una persona tiene que leer un mensaje. La exactitud en los mensajes no traspasados pregunta con qué frecuencia el enrutador acierta en los mensajes que conserva. Cada pregunta tiene su propio denominador, y el libro mantiene los tres separados en cada línea de resultados. La confianza es la probabilidad que el enrutador asigna a su equipo, y el umbral es el valor por debajo del cual un mensaje se traspasa, tal como los define el capítulo 1.
| Medida | Cuenta | Se divide entre |
|---|---|---|
| Exactitud | Mensajes cuyo equipo coincide con el equipo correcto | Todos los mensajes de la muestra |
| Tasa de traspaso | Mensajes cuya confianza está por debajo del umbral | Todos los mensajes de la muestra |
| Exactitud en los mensajes no traspasados | Mensajes correctos entre los no traspasados | Mensajes no traspasados |
Como fórmulas, con N mensajes en la muestra: exactitud = correctos / N; tasa de traspaso = traspasados / N; exactitud en los mensajes no traspasados = correctos entre los conservados / conservados, donde conservados = N menos traspasados.
Dos reglas hacen comparables estas medidas entre candidatos. La primera es que un mensaje traspasado cuenta en el denominador de la exactitud, como incorrecto cuando su equipo es erróneo. La exactitud por sí sola no premia un traspaso, porque un mensaje traspasado solo cuenta como correcto cuando su equipo es el correcto. La exactitud en los mensajes no traspasados, tomada aisladamente, oculta el coste del traspaso, porque deja fuera justamente los mensajes que fueron a personas. La tasa de traspaso muestra ese coste. Los tres números deben leerse juntos, y un enrutador que es mejor solo en una de ellas todavía no ha demostrado que sea mejor.
La segunda regla se refiere a cómo se imprime. Cada tasa se redondea a un decimal como porcentaje, y se imprime junto a su recuento, de modo que el lector pueda comprobarla dividiendo a mano. Una tasa sin recuento al lado no puede comprobarse, y una tasa impresa sin su denominador puede citarse de forma que oculte su muestra.
Cuando el denominador de la tercera medida es cero, la medida no está definida. Eso ocurre cuando todos los mensajes se traspasan, de modo que no se conserva ninguno. El libro imprime "no definido" en ese caso, como muestra la sección de la línea base, y no imprime cero, porque el cero diría que cada mensaje conservado fue incorrecto cuando en realidad no hay ningún mensaje conservado.
Estas medidas puntúan etiquetas. Los scripts de este capítulo, y las mediciones del capítulo 1 y del capítulo 4, devuelven equipos solo para puntuarlos, y no devuelven nada a quien los llama. Un enrutador que devuelve un equipo a quien lo llama lo hace a través de la regla de traspaso que presenta el capítulo 1, de modo que un mensaje por debajo del umbral pasa a una persona en lugar de a un equipo.
En producción, la tasa de traspaso es la medida que cambia primero. La mezcla de mensajes cambia con las estaciones, con el lanzamiento de un producto o con una avería que inunda la bandeja con un mismo tipo de consulta. Un enrutador cuya exactitud se mantiene puede aun así traspasar muchos más mensajes de los que predijo la división de desarrollo, y la única forma de verlo es imprimir la tasa con su recuento sobre el tráfico que el enrutador recibe de verdad.
Regla práctica: Imprime cada una de las tres medidas con su recuento y su denominador, y redondea cada tasa a un decimal. Informa la exactitud en los mensajes no traspasados junto a la tasa de traspaso, nunca sola. Cuando no se conserva ningún mensaje, imprime "no definido" en lugar de cero.
La línea base a partir de respuestas grabadas
Una medida significa poco hasta que algo se ha evaluado con ella. La línea base es la puntuación del sustituto en test_1001, la muestra que usa la comparación final del capítulo 10. Los capítulos siguientes evalúan los candidatos sobre sus prefijos, test_40 y test_200, que son los primeros 40 y los primeros 200 mensajes de la misma muestra fija. Cada prefijo se puntúa a partir de la misma grabación, así que la línea base sobre él corresponde a las mismas respuestas para los mismos mensajes.
El sustituto respondió una vez a cada uno de los mensajes en test_1001. Las respuestas se guardan en una grabación, examples/data/recorded/standin-baseline/answers.jsonl, y cada respuesta indica un equipo y da su log-probabilidad. La grabación tiene un manifiesto junto a ella. El manifiesto indica el script que generó la grabación, el modelo y su revisión fijada, el hash del prompt, la configuración de decodificación y la semilla, y el hash del archivo de respuestas. El código comprueba el archivo de respuestas contra ese hash antes de leer una sola línea, de modo que un archivo modificado hace fallar la ejecución en lugar de cambiar una puntuación.
La grabación se lee, no se ejecuta. Cada ejemplo que usa la línea base lee las mismas respuestas, así que la línea base no puede cambiar de una ejecución a otra, aunque más adelante se actualice el entorno de ejecución que generó la grabación. La razón de grabar, en lugar de llamar a un modelo en cada ejemplo, es la misma razón por la que existen las versiones fijadas. Una grabación fija las respuestas de un modelo en una revisión concreta, así que quien ejecute el mismo ejemplo más tarde verá los mismos números. El libro nunca llama a una API alojada, porque las respuestas de un modelo alojado no quedan fijadas de la misma manera. El sustituto es un modelo abierto que cualquiera puede ejecutar, y su grabación es la única vía hacia sus respuestas que el libro sigue.
La línea base tampoco es un techo. Es la puntuación que un candidato debe superar sobre los mismos mensajes, y por sí sola no dice nada sobre el equilibrio de derivación. Un candidato que supera la línea base en precisión puede aun así derivar más mensajes de los que el personal de soporte puede leer, así que la línea base siempre se lee junto con las tres medidas y nunca como un único número.
¿Cuánto cuesta el umbral provisional? Evaluado con las tres medidas sobre test_1001, el sustituto muestra cuántos mensajes deriva un umbral de 0.5 y con qué frecuencia acierta en los demás. Su confianza es la probabilidad que llama-cpp-python devuelve para su respuesta restringida, que es exp de la log-probabilidad registrada. Ese umbral es el provisional del capítulo 1, así que su tasa de derivación no es la definitiva del libro, y el capítulo 5 elige el umbral real sobre el conjunto de desarrollo. El ejemplo también aplica un umbral superior a todas las confianzas, lo que deriva todos los mensajes.
1"""Score the stand-in's recorded answers on test_1001 with the three measures, at chapter 1's placeholder threshold and at one above every confidence; no model runs. The point rests on the accuracy and hand-off lines, and the answers' hash is checked first.2"""34import hashlib, json, math, os56os.environ.update(HF_HUB_OFFLINE="1", TRANSFORMERS_OFFLINE="1")78import torch # noqa: E402910torch.set_num_threads(2)1112import router_lib # noqa: E4021314router_lib.setup_runtime()1516PLACEHOLDER = 0.5 # Chapter 5 chooses the real threshold on the dev split.17ABOVE_ALL = 1.01 # Confidence is at most 1.0, so this hands off every message.18RECORDED = router_lib.HERE / "data" / "recorded" / "standin-baseline"19manifest = json.loads((RECORDED / "manifest.json").read_text())20raw = (RECORDED / "answers.jsonl").read_bytes()21assert hashlib.sha256(raw).hexdigest() == manifest["output_sha256"]["answers.jsonl"]2223answers = {row["index"]: row for row in map(json.loads, raw.decode().splitlines())} # keyed by test.csv row, not by sample position24rows = router_lib.read_rows("test")25sample = router_lib.read_sample("test_1001")26golds = [rows[i][1] for i in sample] # in the sample's committed order, so position k of each list is one message27preds = [answers[i]["label"] for i in sample]28# Confidence is the probability llama-cpp-python returns for the constrained answer: exp of its log-probability.29confs = [math.exp(answers[i]["logprob"]) for i in sample]3031n = len(sample)32first = router_lib.metrics(preds, golds, confs, PLACEHOLDER) # one call returns the counts and rates of all three measures33high = router_lib.metrics(preds, golds, confs, ABOVE_ALL)34print(f"messages: {n}")35print(f"placeholder threshold: {PLACEHOLDER}")36print(f"accuracy: {first['correct']}/{n} ({first['accuracy']:.1%})")37print(f"handed off: {first['handed_off']}/{n} ({first['handoff_rate']:.1%})")38m = first["not_handed_off"]39print(f"accuracy on messages not handed off: {first['correct_not_handed_off']}/{m} ({first['accuracy_not_handed_off']:.1%})")40print(f"threshold above every confidence: {ABOVE_ALL}")41print(f"handed off at that threshold: {high['handed_off']}/{n} ({high['handoff_rate']:.1%})")42if high["accuracy_not_handed_off"] is None: # None means no message is kept, so the measure has no denominator43 print("accuracy on messages not handed off at that threshold: not defined (0 messages not handed off)")44else:45 print(f"accuracy on messages not handed off at that threshold: {high['correct_not_handed_off']}/{high['not_handed_off']}")
python baseline-measures.pymessages: 1001
placeholder threshold: 0.5
accuracy: 560/1001 (55.9%)
handed off: 30/1001 (3.0%)
accuracy on messages not handed off: 554/971 (57.1%)
threshold above every confidence: 1.01
handed off at that threshold: 1001/1001 (100.0%)
accuracy on messages not handed off at that threshold: not defined (0 messages not handed off)
Con el umbral provisional, el sustituto acierta 560/1001 (55.9%) y deriva 30/1001 (3.0%). En los mensajes que conserva, su precisión es 554/971 (57.1%).
Con un umbral superior a todas las confianzas, la tasa de derivación es 1001/1001 (100.0%), así que la precisión en los mensajes no derivados es not defined (0 messages not handed off).
El modelo alojado propio de un lector es una línea base distinta. Puntuará de forma diferente los mismos mensajes, y el libro no afirma que los números del sustituto sean los de la bandeja de entrada. La línea base del lector son las respuestas grabadas de su modelo sobre test_1001, puntuadas con las tres medidas de este capítulo. La comparación que importa es entre el candidato del lector y esa línea base, sobre los mismos mensajes y con los mismos recuentos.
La sección siguiente cuenta las respuestas erróneas del sustituto y muestra entre qué equipos caen. El recuento de respuestas erróneas es el primer número de la línea base.
Regla práctica: Registra la línea base una vez, sobre test_1001, la muestra fija de la que salen los prefijos de todos los candidatos. Guarda la revisión fijada del modelo, el hash del prompt y la configuración de decodificación en un manifiesto, y comprueba el archivo de respuestas contra su hash antes de leer una sola línea. Compara cada candidato solo con la línea base puntuada sobre los mismos mensajes, ya sean test_40, test_200 o test_1001. Cuando tu propio modelo alojado sea la línea base, registra sus respuestas de la misma manera y di en el informe que sus puntuaciones difieren de las del sustituto.
Dónde chocan las etiquetas
Los recuentos del baseline indican con qué frecuencia el modelo de referencia se equivoca. No indican qué equipos confunde, y son justamente esas confusiones lo que el equipo de soporte puede corregir. Un par de equipos que el enrutador confunde podría necesitar una descripción más clara de cada equipo, una regla para ese par o más mensajes de uno de los dos equipos en el entrenamiento. Ninguna de esas medidas se deduce del recuento total, así que este capítulo lee los pares a partir de las respuestas registradas y no supone de antemano qué equipos están cerca entre sí.
Contar las respuestas incorrectas requiere el propio registro, así que el siguiente ejemplo lo lee, lo verifica contra el manifiesto, comprueba que contiene exactamente los mensajes de test_1001, y después cuenta las respuestas incorrectas y los tres pares de respuesta correcta y respuesta dada que más se repiten. Los empates se resuelven según la posición de cada equipo en el archivo de categorías, de modo que los mismos pares aparecen en el mismo orden en cada ejecución.
1"""Count the stand-in's wrong answers, its three most frequent gold-to-answer pairs and the teams it never answers, on test_1001; no model runs. The point rests on the "pair" and "never answered" lines.2"""34import hashlib, json, os56os.environ.update(HF_HUB_OFFLINE="1", TRANSFORMERS_OFFLINE="1")78import torch # noqa: E402910torch.set_num_threads(2)1112import router_lib # noqa: E40213from collections import Counter # noqa: E4021415router_lib.setup_runtime()1617RECORDED = router_lib.HERE / "data" / "recorded" / "standin-baseline"18manifest = json.loads((RECORDED / "manifest.json").read_text())19raw = (RECORDED / "answers.jsonl").read_bytes()20assert hashlib.sha256(raw).hexdigest() == manifest["output_sha256"]["answers.jsonl"]2122records = [json.loads(line) for line in raw.decode().splitlines()]23sample = router_lib.read_sample("test_1001")24assert sorted(r["index"] for r in records) == sorted(sample), "recorded rows differ from test_1001"25assert all(router_lib.LABELS[r["label"]] == r["team"] for r in records), "label and team disagree"26test, LABELS = router_lib.read_rows("test"), router_lib.LABELS2728gold_totals = Counter(test[i][1] for i in sample)29answered = Counter(r["label"] for r in records)30pairs = Counter((test[r["index"]][1], r["label"]) for r in records if r["label"] != test[r["index"]][1]) # (gold, answer); [1] is the gold label31wrong = sum(pairs.values())32# Ties break on the lower gold label index, then the lower answer index.33top = sorted(pairs.items(), key=lambda kv: (-kv[1], kv[0][0], kv[0][1]))[:3]34never = sorted(team for k, team in enumerate(LABELS) if answered[k] == 0) # sorted by name, so uppercase names print first3536print(f"messages: {len(sample)}")37print(f"wrong answers: {wrong}")38print(f"wrong rate: {100 * wrong / len(sample):.1f}% ({wrong} of {len(sample)})")39for rank, ((gold, answer), count) in enumerate(top, start=1):40 print(f"pair {rank} count: {count}")41 print(f"pair {rank} gold: {LABELS[gold]}")42 print(f"pair {rank} answer: {LABELS[answer]}")43 print(f"pair {rank} of gold team: {count}/{gold_totals[gold]}")44print(f"teams never answered: {len(never)}")45for rank, team in enumerate(never, start=1):46 gold = LABELS.index(team)47 count, answer = max(((c, a) for (g, a), c in pairs.items() if g == gold), key=lambda ca: (ca[0], -ca[1])) # most frequent wrong answer; ties go to the lower answer index48 print(f"never answered {rank} team: {team}")49 print(f"never answered {rank} messages: {gold_totals[gold]}")50 print(f"never answered {rank} most often as: {LABELS[answer]}")51 print(f"never answered {rank} most often count: {count}")
python confusions-in-the-baseline.pymessages: 1001
wrong answers: 441
wrong rate: 44.1% (441 of 1001)
pair 1 count: 13
pair 1 gold: Refund_not_showing_up
pair 1 answer: request_refund
pair 1 of gold team: 13/13
pair 2 count: 13
pair 2 gold: failed_transfer
pair 2 answer: transfer_not_received_by_recipient
pair 2 of gold team: 13/13
pair 3 count: 12
pair 3 gold: card_arrival
pair 3 answer: card_delivery_estimate
pair 3 of gold team: 12/13
teams never answered: 4
never answered 1 team: Refund_not_showing_up
never answered 1 messages: 13
never answered 1 most often as: request_refund
never answered 1 most often count: 13
never answered 2 team: card_arrival
never answered 2 messages: 13
never answered 2 most often as: card_delivery_estimate
never answered 2 most often count: 12
never answered 3 team: failed_transfer
never answered 3 messages: 13
never answered 3 most often as: transfer_not_received_by_recipient
never answered 3 most often count: 13
never answered 4 team: order_physical_card
never answered 4 messages: 13
never answered 4 most often as: get_physical_card
never answered 4 most often count: 10
El modelo de referencia se equivoca en 44.1% (441 of 1001). Sin aplicar ningún umbral, el error es uno menos la exactitud, de modo que esa tasa de error y la exactitud de la sección del baseline suman 100 %.
Cada uno de los tres pares más frecuentes concentra todos o casi todos los mensajes de muestra de su equipo correcto. El primer par concentra 13/13, el segundo 13/13 y el tercero 12/13, de modo que los dos primeros abarcan todos los mensajes de su equipo correcto y el tercero todos menos uno. Los nombres de los equipos sugieren una razón para cada par: el primero se refiere a un reembolso, el segundo a una transferencia y el tercero a la llegada de una tarjeta y a su estimación de entrega. Esto es una lectura de los nombres. El capítulo no lee los mensajes y ningún ejemplo los muestra, así que los pares son un motivo para revisar, no un hallazgo sobre lo que dicen los mensajes.
El modelo de referencia nunca nombra 4 de los 77 equipos, de modo que todo mensaje cuyo equipo correcto sea uno de ellos es incorrecto. Para card_arrival, uno de esos equipos, la respuesta incorrecta más común es card_delivery_estimate, que concentra 12 de sus mensajes.
Para order_physical_card, otro de ellos, la respuesta incorrecta más común es get_physical_card, que concentra 10 de sus mensajes. El registro no muestra por qué no se asigna nunca a estos equipos, así que la lista es un motivo para revisar.
Los pares describen el modelo de referencia sobre esta muestra, no los equipos ni la bandeja de entrada. El modelo propio de cada lector tendrá sus propios pares, y el lector debe contarlos a partir de sus propias respuestas registradas. Cuando la pregunta es cómo corregir un par, la corrección debe elegirse y comprobarse en dev, como exige la sección de dev y test. Un cambio que se elige leyendo los pares en test_1001 se ha ajustado sobre la partición de test, y su resultado en esa partición no puede presentarse como una medida del enrutador.
Cuando aumenten los traspasos o las quejas para un equipo en producción, repita primero este recuento. Cuente de nuevo los pares con las respuestas registradas de la propia bandeja de entrada, imprima cada par con su recuento y compare la lista con la del baseline. Un cambio en la lista indica dónde se ha desplazado el comportamiento del enrutador, incluso cuando la tasa global no ha cambiado.
Las decisiones del capítulo, en resumen:
- Dev se extrae equipo por equipo del archivo de entrenamiento, con una semilla fija, y sus números de fila quedan confirmados.
- Las muestras de test se fijan en orden y solo se leen para informar.
- Cada medida se imprime con su recuento y su denominador, y «no definido» reemplaza a un denominador cero.
- Las respuestas registradas del modelo de referencia en
test_1001constituyen el baseline, leído desde un archivo verificado con el manifiesto.
Los tres números del baseline, leídos en conjunto, son la puntuación que un candidato debe superar sobre los mismos mensajes. El capítulo 3 cuenta los tokens del prompt del enrutador sobre test_40 antes de elegir un modelo base. El capítulo 5 elige el umbral de traspaso en dev, con la regla expuesta allí. El capítulo 10 compara el enrutador con el baseline sobre la misma muestra de test_1001.
Regla práctica: Cuenta las respuestas incorrectas y los pares más frecuentes para cada candidato, sobre la misma muestra, e imprime cada par con su recuento. Lee los pares como una lista de dónde mirar. Imprime los tres pares más frecuentes y no solo el primero, porque un solo par invita a sobreinterpretar, y una lista muestra si los errores se agrupan o se dispersan. Comprueba cualquier corrección en la partición de dev antes de volver a leer la partición de test.
Este capítulo, en esta edición
Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 3 de 3 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.9.