Construye un enrutador para la bandeja de entrada del banco que cede el caso cuando no está seguro
Unos 19 minutos de lectura, con 4 ejemplos en 6 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 final de este capítulo, podrás construir un enrutador que devuelva un equipo, una confianza y una marca de cesión para un mensaje, evaluarlo sobre una muestra fija con tres medidas, y ver por qué un modelo pequeño no entrenado, al que se le da un prompt tal como está, no puede ser la primera versión del enrutador.
Los mensajes de los clientes a un banco llegan a una sola cola de atención, que este libro llama la bandeja de entrada. Un enrutador envía cada mensaje de la bandeja de entrada a uno de 77 equipos. Un enrutador que elige un equipo para cada mensaje a veces elegirá el equipo equivocado. Un equipo equivocado le cuesta tiempo al cliente, y le cuesta al personal de atención un paso más para pasar el mensaje. Este capítulo construye un enrutador que indica cuándo no está seguro.
Un equipo es una etiqueta que el enrutador puede devolver, como card_arrival, y nunca es un grupo de personas. Las personas que leen los mensajes son el personal de atención del banco, y un mensaje que el enrutador no puede derivar a un equipo va a una de esas personas.
Los mensajes y sus equipos provienen de BANKING77, un conjunto de datos público de mensajes de clientes a un banco, publicado bajo CC BY 4.0. BANKING77 llama a cada etiqueta una intención. Este libro, a partir de aquí, la llama equipo, y las etiquetas se escriben tal como aparecen en el conjunto de datos.
El enrutador es el sistema completo: un modelo, un prompt, un umbral y el código que envía el mensaje a su destino. Este capítulo construye un enrutador básico. Un enrutador es básico cuando su umbral es provisional y su modelo es un sustituto, y este es un enrutador funcional porque devuelve una respuesta para cada mensaje y se puede evaluar cada una de sus salidas.
Necesitas Python y una llamada a la API de un modelo alojado, que quizá ya hayas escrito. Este capítulo no te pide conocer cómo funciona por dentro un transformador. Cuando un detalle interno importa, se explica en una sola frase.
Primero van dos piezas compartidas. La primera es una grabación de las respuestas de un modelo sustituto a los mensajes de prueba, que presenta la sección sobre cómo preguntarle a un modelo. La mayoría de los ejemplos leen esas respuestas sin conexión, y uno ejecuta un modelo pequeño en vivo, en la sección que muestra su fallo. La segunda es router_lib, un módulo compartido en la carpeta examples del libro. Contiene las etiquetas de equipo, el prompt del enrutador, la regla de cesión y las medidas. Cada ejemplo lo importa, de modo que una función significa lo mismo en todos los capítulos.
Qué devuelve el router
Para cada mensaje, el router devuelve tres cosas. El equipo es una de las etiquetas, escrita tal cual la etiqueta. La confianza es un número de cero a uno que indica qué tan seguro está el router de ese equipo. La marca de traspaso es verdadera cuando la confianza es demasiado baja para enviar el mensaje a su destino, y en ese caso una persona toma el mensaje en su lugar.
En este capítulo, la confianza tiene un significado acotado. Es la probabilidad que llama-cpp-python devuelve para la respuesta restringida, y la grabación la guarda como un logaritmo de probabilidad. En términos sencillos, es cuánta probabilidad le da el modelo al equipo que escribió. En forma de fórmula, confianza = exp(suma de log p(token)), el producto de las probabilidades de los tokens de la respuesta. Un token es un fragmento de texto que el modelo lee y escribe. Esto no es el softmax sobre los equipos que usa el capítulo 5. Es una puntuación, no una probabilidad calibrada, y nada en este capítulo muestra que una confianza de un tamaño dado coincida con la frecuencia con que el equipo acierta. El capítulo 5 verifica la calibración en el conjunto de desarrollo, los mensajes de entrenamiento reservados para elegir la configuración (capítulo 2): agrupa los mensajes en bandas de confianza e imprime el número y la exactitud de cada banda.
| Salida | Qué es | Qué la usa |
|---|---|---|
| Equipo | Una etiqueta del conjunto bancario | El destino al que se envía el mensaje, cuando la marca es falsa |
| Confianza | La probabilidad que llama-cpp-python devuelve para la respuesta restringida, como puntuación | La regla de traspaso |
| Marca de traspaso | Verdadera cuando la confianza está por debajo del umbral | La persona que toma el mensaje |
La marca es lo más importante, y la razón es operativa. Un router que siempre devuelve un equipo envía todos los mensajes a algún lugar, incluidos los mensajes para los que no tiene base para decidir. Un traspaso entrega el mensaje a una persona que puede enrutarlo, y un router que indica cuándo no está seguro hace visible el trabajo de esa persona. Recomendamos que cada router devuelva la marca en cada respuesta, verdadera o falsa, para que cada medida de las secciones siguientes pueda calcularse solo a partir de la salida.
Que un router indique cuándo no está seguro tiene un nombre en la literatura de investigación: clasificación selectiva, o la opción de rechazo. El preprint de Geifman y El-Yaniv de 2017 sobre redes profundas describe el compromiso. Un clasificador que rechaza algunas entradas cubre menos de ellas, y las técnicas pueden, potencial y significativamente, mejorar las predicciones de una red profunda sobre las entradas que conserva, a costa de cobertura. Su método también permite al usuario fijar un nivel objetivo de riesgo. La regla de traspaso de este libro no hace eso. Elige un umbral sobre datos reservados, y no ofrece ninguna garantía sobre el riesgo que queda.
Las mediciones de este capítulo devuelven equipos solo para puntuarlos. El ejemplo de un solo mensaje, en la sección de traspaso, devuelve un equipo solo cuando la marca es falsa.
Regla práctica: Devuelve la marca con cada equipo, y envía un mensaje a una persona siempre que la marca sea verdadera. Devuelve el equipo a quien llama solo cuando la marca sea falsa. Conserva la marca aunque quitarla haría que un router pareciera más completo, porque la medida de traspaso la cuenta.
Pedir a un modelo un equipo
El equipo del enrutador lo proporciona un modelo, y el modelo se guía mediante un prompt. El prompt es la parte del enrutador que el banco cambia con más frecuencia, así que lo fijamos en un solo lugar. router_prompt construye un prompt para un mensaje. El prompt pide un equipo y le da al modelo el nombre de todos los equipos, el mensaje y la palabra Team: al final, para que el modelo la complete. Contiene los nombres de los equipos y el único mensaje que se enruta, y nada más, de modo que ningún otro mensaje de la muestra llega al modelo junto con él.
Todas las ejecuciones en vivo y las grabadas usan el mismo texto del prompt, tomado de router_lib.router_prompt, así que las palabras son las mismas en todas las ejecuciones. Lo que lee el modelo no siempre es lo mismo. La grabación envuelve esas palabras en la plantilla de chat del sustituto, y la ejecución en vivo de la sección sobre un modelo pequeño le da al modelo pequeño el texto sin procesar, sin plantilla. Un prompt modificado es una grabación distinta, así que sus puntuaciones no pueden compararse con las anteriores. El prompt forma parte de la versión del enrutador, y un lector que lo cambie debe registrar el cambio, del mismo modo que el libro registra un cambio de modelo.
El banco es el único nombre que este libro usa para la organización. El enrutador propio del banco es un modelo alojado al que llama para cada mensaje. No tenemos acceso a él, y este libro nunca llama a un modelo alojado. En su lugar usamos el sustituto, Qwen3-4B-Instruct-2507, un modelo abierto mayor que el pequeño usado más adelante, y cada enrutador del libro se mide frente a las respuestas del sustituto. El modelo alojado de un lector responderá algunos mensajes de forma distinta, y puntuará de forma distinta por esa razón.
Elegimos el sustituto porque cualquiera puede reproducir sus respuestas. Su licencia es Apache-2.0, como declara la tarjeta del modelo del repositorio GGUF para el archivo en la revisión que fija este libro. El archivo es Qwen3-4B-Instruct-2507-Q4_K_M.gguf, una compilación cuantizada que la biblioteca llama-cpp-python ejecuta en una CPU. Su manifiesto de grabación indica el SHA-256 del archivo, así que un lector que descargue el archivo puede comprobarlo antes de ejecutar nada.
El sustituto respondió cada mensaje de test_1001, una muestra fija de 1,001 mensajes de prueba, una vez, y test_40 son sus primeros 40 mensajes. La grabación usó decodificación voraz, que toma el token más probable en cada paso, y una semilla fija. También usó una gramática que solo permitía los nombres de los equipos, de modo que cada respuesta grabada es una de las 77 etiquetas. Esa gramática es la razón por la que las respuestas grabadas son siempre nombres de equipos. El capítulo 4 la explica, ya que es la misma idea que corrige el fallo en la sección sobre un modelo pequeño.
Si tienes un modelo propio, puedes grabar sus respuestas de la misma manera. Escribes una función, call_model. Recibe un mensaje y devuelve el equipo y la log-probabilidad de la respuesta, que es la suma de las log-probabilidades de los tokens de la respuesta, tal como la guarda la grabación del sustituto. La función record_answers la llama para cada mensaje de la muestra, escribe una línea por mensaje en el formato del sustituto y lanza un error si la función devuelve un nombre que no es uno de los equipos. Todo lo demás es igual para cada modelo, así que dos grabaciones sobre la misma muestra pueden compararse línea por línea.
1"""Write a model's team answers in the stand-in's JSONL shape, then check record_answers against the stand-in's recording.2The line to read is the last one printed, which counts the lines that match the recording. The stand-in here replays3that recording, so no model runs."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import json # noqa: E40211import tempfile # noqa: E4021213import torch # noqa: E4021415torch.set_num_threads(2)1617import router_lib # noqa: E4021819router_lib.setup_runtime()202122def record_answers(call_model, messages, path):23 """Write one JSONL line per (index, text); call_model(text) returns (team, logprob)."""24 with open(path, "w") as out:25 for index, text in messages:26 team, logprob = call_model(text)27 if team not in router_lib.LABELS:28 raise ValueError("the model returned a name that is not a team")29 label = router_lib.LABELS.index(team) # stored as the label, the same encoding as the gold labels30 row = {"index": index, "label": label, "team": team, "logprob": logprob}31 out.write(json.dumps(row) + "\n")323334RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"35rows = router_lib.read_rows("test") # each row is (text, gold label)36sample = router_lib.read_sample("test_40")37messages = [(i, rows[i][0]) for i in sample] # element 0 of a row is its text, which the model reads38with open(RECORDING) as f:39 recording_lines = f.read().splitlines()40recorded = {json.loads(line)["index"]: json.loads(line) for line in recording_lines} # keyed by message index41by_text = {rows[i][0]: (recorded[i]["team"], recorded[i]["logprob"]) for i in sample} # keyed by text, not index424344def standin(text):45 """Stand in for a model: return the recorded team and logprob for this message."""46 return by_text[text]474849with tempfile.TemporaryDirectory() as folder:50 path = os.path.join(folder, "answers.jsonl")51 record_answers(standin, messages, path)52 with open(path) as f:53 written = f.read().splitlines()5455matching = sum(line in recording_lines for line in written) # a line matches when it equals a recorded line exactly56print(f"messages written: {len(written)}")57print(f"lines matching the recording: {matching}/{len(written)}")
python record-your-own-answers.pymessages written: 40
lines matching the recording: 40/40
Antes de confiar en tu propia grabación, comprueba record_answers sobre las respuestas del sustituto. Aquí la función del sustituto reproduce la grabación, así que la comprobación prueba record_answers y no un modelo. Cada línea que escribe coincide con la grabación, las 40 sin excepción. Cuando sustituyas esa función por una llamada a tu propio modelo, la misma comprobación mostrará si tu grabación tiene la misma forma que la del sustituto.
Regla práctica: Puntúa todos los modelos sobre la misma muestra fija, y registra sus respuestas con record_answers antes de compararlos con el sustituto. Indica sobre qué muestra está cada puntuación, y compara dos puntuaciones lado a lado solo cuando sus muestras coincidan.
Deriva los mensajes dudosos a una persona
Las respuestas del sustituto asignan a cada mensaje una confianza, y esta sección convierte esa confianza en la marca de derivación.
La regla de derivación es una sola comparación. handoff(confidence, threshold) devuelve verdadero cuando la confianza está por debajo del umbral, y falso cuando es igual al umbral o superior. Un mensaje que se deriva va a una persona. Un mensaje que no se deriva va al equipo que indicó el enrutador. Toda ruta de este libro que devuelve un equipo a quien la llama usa esta función, de modo que ningún invocador puede recibir un equipo sin que la decisión se haya tomado.
La regla es sencilla de leer, y el trabajo está en elegir el número. Este capítulo usa un umbral provisional, 0.5, y cada salida que lo usa lo indica. Un umbral provisional no tiene una regla detrás: es un número que permite que la regla funcione.
El capítulo 5 elige el umbral sobre la división de desarrollo, siguiendo una regla que se explica allí. Registra el valor elegido en el manifiesto del adaptador, de modo que puedas ver qué umbral usó un resultado y sobre qué se eligió. La muestra de prueba nunca se usa para elegirlo. Hasta entonces, el umbral provisional es el único umbral que tiene este capítulo, y sus resultados sirven para enseñar las medidas, no para juzgar al enrutador.
La tasa de derivación es la proporción de mensajes que van a una persona, y cambia con el umbral. Si subes el umbral, más mensajes van a personas; si lo bajas, más van directamente a un equipo. Esta compensación es la razón por la que la elección es una decisión medida. El capítulo 5 muestra la compensación sobre la división de desarrollo, con más de un valor, antes de elegir uno.
1"""Route the first message of test_40 from the stand-in's recorded answer, at the placeholder threshold.2The prose reads the printed team and the hand-off line. No model runs here, and the message's text is never printed."""34import os56os.environ["HF_HUB_OFFLINE"] = "1"7os.environ["TRANSFORMERS_OFFLINE"] = "1"89import json # noqa: E40210import math # noqa: E4021112import torch # noqa: E4021314torch.set_num_threads(2)1516import router_lib # noqa: E4021718router_lib.setup_runtime()1920THRESHOLD = 0.5 # Placeholder. Chapter 5 chooses the threshold on the dev split.21RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"222324def route(row):25 """Return (team, confidence, handed off) for one recorded answer. The team is None when handed off."""26 confidence = math.exp(row["logprob"]) # the recording stores a log-probability; exp gives a probability27 flag = router_lib.handoff(confidence, THRESHOLD) # True below THRESHOLD, and for a NaN; equal to THRESHOLD is kept28 return (None if flag else row["team"]), confidence, flag293031with open(RECORDING) as f:32 recorded = {r["index"]: r for r in map(json.loads, f)} # keyed by message index, as the sample lists them3334first = router_lib.read_sample("test_40")[0] # the first of the sample's 40 message indexes35team, confidence, flag = route(recorded[first])36assert not flag # the prose states this message is kept; a change that hands it off fails the run37print(f"team: {team or 'none (handed off)'}")38print(f"confidence: {confidence:.2f}")39print(f"handed off: {'yes' if flag else 'no'}")
python route-one-message.pyteam: top_up_reverted
confidence: 1.00
handed off: no
Sigue un mensaje a lo largo de toda la ruta, desde la respuesta registrada hasta un equipo impreso. El ejemplo toma el primer mensaje de test_40, lee la respuesta registrada del sustituto para él y lo enruta a través de handoff con el umbral provisional. Imprime el equipo, la confianza redondeada a dos decimales y si el mensaje fue derivado, y nunca imprime el texto del mensaje. La confianza de este mensaje es 1.00, que supera el umbral provisional, así que el enrutador conserva el mensaje y devuelve su equipo, top_up_reverted. El script afirma que el mensaje no se deriva. Un solo mensaje muestra la forma de la salida. No puede mostrar con qué frecuencia el enrutador acierta.
Regla práctica: Elige el umbral sobre la división de desarrollo, nunca sobre la muestra de prueba, e informa la tasa de derivación junto a la exactitud en todo momento. Mientras el umbral sea provisional, indícalo en cada salida, y no incluyas su exactitud en ninguna afirmación sobre el resultado del enrutador.
Evalúa el enrutador sobre una muestra fija
Un enrutador se evalúa con mensajes cuyo equipo ya se conoce. Este capítulo usa test_40, una muestra fija de 40 mensajes de prueba, para que cada lector evalúe los mismos mensajes en el mismo orden. El capítulo 2 explica cómo se extrajeron las muestras, qué partición se usa para elegir la configuración y por qué la muestra de prueba se mantiene fuera de esa elección. Los números de abajo describen solo esta muestra.
El enrutador se mide con tres números, y cada uno tiene su recuento al lado.
- Exactitud son los mensajes cuyo equipo coincide con la etiqueta correcta, dividido entre todos los mensajes de la muestra. Un mensaje que se deriva cuenta en el denominador, y es incorrecto si su equipo es incorrecto.
- Tasa de derivación son los mensajes cuya confianza está por debajo del umbral, dividido entre todos los mensajes.
- Exactitud en los mensajes no derivados son los mensajes correctos entre los que el enrutador conserva, dividido entre los mensajes que conserva. Se informa como no definida cuando el enrutador no conserva ninguno.
Cada medida responde a una pregunta distinta. La exactitud pregunta con qué frecuencia el enrutador acierta en general. La tasa de derivación pregunta cuánto del trabajo pasa a las personas. La exactitud en los mensajes conservados pregunta si los mensajes que el enrutador retiene pueden pasar directamente a un equipo. La exactitud por sí sola no separa los dos tipos de error. Un equipo incorrecto que fue derivado cuenta en contra de la exactitud, y también cuenta en contra un equipo incorrecto que llegó a un equipo sin revisión. Solo la tercera medida aísla el segundo tipo de error, y es el que el personal de soporte siente directamente.
1"""Score the stand-in's recorded answers on test_40, with a placeholder hand-off threshold.2The last printed line, accuracy on messages not handed off, is the one the prose reads against the others: it is the3accuracy of the messages a team receives. No model runs here, and the answers come from the recording."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import json # noqa: E40211import math # noqa: E4021213import torch # noqa: E4021415torch.set_num_threads(2)1617import router_lib # noqa: E4021819router_lib.setup_runtime()2021THRESHOLD = 0.5 # Placeholder. Chapter 5 chooses the threshold on the dev split.22RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"2324answers = {}25with open(RECORDING) as f:26 for line in f:27 row = json.loads(line)28 answers[row["index"]] = row2930rows = router_lib.read_rows("test")31sample = router_lib.read_sample("test_40")3233golds = [rows[i][1] for i in sample] # element 1 of a test row is its gold label; element 0 is its text34preds = [answers[i]["label"] for i in sample] # the recorded label is the team's position in LABELS, as the gold is35confs = [math.exp(answers[i]["logprob"]) for i in sample] # exp turns each recorded log-probability into a confidence3637# metrics applies the hand-off rule at THRESHOLD; accuracy's denominator still includes handed-off messages38result = router_lib.metrics(preds, golds, confs, THRESHOLD)39n = result["n"]4041print(f"messages: {n}")42print(f"placeholder threshold: {THRESHOLD}")43print(f"accuracy: {result['correct']}/{n} ({result['accuracy']:.1%})")44print(f"handed off: {result['handed_off']}/{n} ({result['handoff_rate']:.1%})")45if result["accuracy_not_handed_off"] is None: # None when the router keeps no message, so the measure is undefined46 print("accuracy on messages not handed off: not defined (0 messages not handed off)")47else:48 m = result["not_handed_off"]49 print(50 f"accuracy on messages not handed off: {result['correct_not_handed_off']}/{m} "51 f"({result['accuracy_not_handed_off']:.1%})"52 )
python route-recorded-answers.pymessages: 40
placeholder threshold: 0.5
accuracy: 20/40 (50.0%)
handed off: 2/40 (5.0%)
accuracy on messages not handed off: 20/38 (52.6%)
Aquí están las tres medidas sobre la muestra, con el umbral provisional. El ejemplo lee las respuestas registradas, aplica el umbral a sus confianzas e imprime cada medida con su recuento. La línea que conviene vigilar es la exactitud en los mensajes no derivados, porque es la exactitud de los mensajes que un equipo recibe realmente.
Leídas en conjunto, las tres medidas indican que el umbral provisional no protege a los equipos. El enrutador acierta en 20/40 (50.0%) de la muestra, algo que ningún equipo debería aceptar por sí solo. El umbral deriva solo 2/40 (5.0%) de los mensajes, así que la mayor parte de la muestra llega a un equipo. Esos mensajes conservados se enrutan correctamente en 20/38 (52.6%), apenas por encima de la exactitud sobre toda la muestra. Un enrutador que devuelve un equipo para cada mensaje todavía no es uno que el banco pueda usar.
Una muestra tan pequeña puede mostrar que un enrutador falla, y puede mostrar cómo se mueven las medidas. No puede distinguir con seguridad entre dos enrutadores. El capítulo 2 expone las muestras más grandes, y el capítulo 5 mide el umbral elegido en el mismo tipo de muestra.
Regla práctica: Informa la exactitud, la tasa de derivación y la exactitud en los mensajes no derivados juntas, cada una con su recuento, sobre la misma muestra fija, y compara dos enrutadores solo cuando ambos se hayan medido sobre esa muestra.
Muestra primero qué hace un modelo pequeño
El atajo obvio es quitar el sustituto y preguntarle directamente a un modelo pequeño. SmolLM2-135M-Instruct es el modelo más pequeño de la familia que este libro conserva, y es el modelo central para el resto del libro. Se ejecuta en una CPU y se carga sin conexión desde su revisión fijada. Si respondiera con el nombre de un equipo, el enrutador no necesitaría ninguna grabación, así que vale la pena probar este atajo antes de construir nada más sobre él.
La prueba le hace al modelo la misma pregunta que le haría el enrutador. El modelo recibe el prompt del enrutador para los primeros 20 mensajes de la muestra, sin restricción en su respuesta y con un límite de unos pocos tokens. Antes de empezar, haz una estimación: ¿cuántas de esas respuestas serán nombres de equipo, si nada obliga al modelo a ceñirse a la lista? Luego cuéntalas.
1"""Ask the 135M model for a team with the raw router prompt and no constraint, on the first 20 messages of test_40.2Look at the last printed line, which counts the answers that are exactly a team name. The answers stay in this file3and are never returned to a caller."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import torch # noqa: E4021112torch.set_num_threads(2)1314import router_lib # noqa: E4021516router_lib.setup_runtime()1718SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"1920tokenizer, model = router_lib.load_model(SMALL)21rows = router_lib.read_rows("test")22sample = router_lib.read_sample("test_40", n=20) # the first 20, to keep the run short23teams = set(router_lib.LABELS)2425answers = []26with torch.no_grad():27 for i in sample:28 # the raw prompt: no chat template and no grammar, so the model may write anything29 inputs = tokenizer(router_lib.router_prompt(rows[i][0]), return_tensors="pt")30 # at most 10 new tokens, and greedy: the most likely token at each step31 out = model.generate(32 **inputs, max_new_tokens=10, do_sample=False, pad_token_id=tokenizer.eos_token_id33 )34 # the output starts with the prompt, so skip its tokens and keep only the answer35 new_tokens = out[0, inputs["input_ids"].shape[1] :]36 answers.append(tokenizer.decode(new_tokens, skip_special_tokens=True).strip())3738print(f"messages: {len(answers)}")39# an answer counts only when it is exactly a team name, with no extra words around it40print(f"answers that are a team name: {sum(a in teams for a in answers)}/{len(answers)}")
python unconstrained-first-try.pymessages: 20
answers that are a team name: 0/20
Ninguna de las respuestas del modelo es un nombre de equipo, así que el enrutador no tiene adónde enviar nada. La medición conserva sus respuestas y nunca las devuelve a quien llama.
Este fallo no demuestra que un modelo pequeño nunca pueda enrutar. Demuestra que este modelo, preguntado de esta manera, no devuelve un equipo. Hay dos soluciones distintas, y las tomamos en orden. El capítulo 4 restringe la respuesta, de modo que el modelo solo puede escribir un nombre de equipo. El capítulo 5 entrena un cabezal sobre el modelo, de modo que cada equipo recibe una puntuación con una sola pasada hacia delante. Este capítulo no hace ninguna de las dos cosas, y por eso su enrutador funciona con las respuestas registradas del sustituto.
Regla práctica: Antes de que un modelo enrute algo, cuenta cuántas de sus respuestas son nombres de equipo sobre una muestra fija, y compara el recuento con el tamaño de la muestra. Si el modelo no devuelve un equipo para cada mensaje, no enrutes con él tal como está. Restringe su respuesta a los equipos o entrénalo para la tarea. Una regla de traspaso aplicada a una respuesta que no es un equipo protege un equipo que no existe.
Dónde se rompe un enrutador tosco
Un enrutador tosco se rompe de cuatro maneras en producción, y cada una deja una señal que el personal de soporte puede ver.
La primera es un nombre de equipo que no existe. Un modelo de texto libre puede escribir un equipo que no está en la lista, o una oración, y un enrutador que envía ese texto hacia adelante ha enviado el mensaje a nadie. La grabación de el sustituto no puede hacer esto, porque su gramática solo permite las etiquetas, pero el modelo de un lector sí puede. La señal es una respuesta que no es un nombre de equipo, y la prueba sin restricciones cuenta las respuestas que sí son nombres de equipo. Un enrutador debe tratar una respuesta así como un error, contarla y enviar el mensaje a una persona. record_answers ya genera un error para ese caso, y el enrutador debe hacer lo mismo.
La segunda es la deriva. Las respuestas del sustituto solo valen para el archivo, el prompt y la muestra con los que se grabaron. El manifiesto de la grabación indica el SHA-256 del archivo, el hash del prompt, la decodificación y la muestra, así que un cambio en cualquiera de ellos es otra grabación. Si un lector ve que una puntuación cambia sin ningún cambio en el código, debe comparar primero el manifiesto y después el prompt.
La tercera es un umbral que deja de ajustarse. Un umbral elegido en un único conjunto de desarrollo puede dejar de ajustarse cuando cambia la mezcla de mensajes. La señal es un cambio en la tasa de traspaso, o en la precisión de los mensajes que se conservan, cuando el enrutador se mide con nuevos mensajes de desarrollo. El capítulo 5 registra el umbral junto con el conjunto de desarrollo con el que se eligió, para que el banco pueda ver a qué se ajustó ese número, y el capítulo 9 vigila el cambio.
La cuarta es el costo y la carga sobre las personas. Un modelo alojado cobra cada llamada. Un enrutador que el banco ejecuta cobra en cómputo en su propia máquina, y el capítulo 3 cuenta lo que cuesta un mensaje en tokens y pasadas hacia adelante, mientras que el capítulo 10 convierte una velocidad registrada en una factura. Cada traspaso es trabajo para una persona, y la tasa de traspaso es la proporción de ese trabajo. Recomendamos incluir la tasa de traspaso en cada informe sobre el enrutador, junto a la precisión, para que el costo de la marca nunca quede fuera.
Un enrutador que no puede indicar cuándo no está seguro oculta sus errores, y la marca los hace contables. Este capítulo tomó estas decisiones. Los capítulos siguientes las mantienen, o las cambian y explican por qué:
- El enrutador devuelve un equipo, una confianza y una marca de traspaso, y toda ruta que devuelva un equipo pasa por
handoff. - El umbral es un marcador de posición hasta que el capítulo 5 lo elija sobre el conjunto de desarrollo.
- Cada enrutador se evalúa con la precisión, la tasa de traspaso y la precisión en los mensajes no traspasados, sobre la misma muestra fija, con los conteos junto a cada cifra.
- El sustituto es la línea base, y sus respuestas están registradas. El modelo propio de un lector registra sus respuestas de la misma manera, con
record_answers. - Un modelo que no devuelve un equipo para cada mensaje todavía no es un enrutador.
Este capítulo, en esta edición
Edición 2026.11.9Ejemplos verificados el 20 de nov de 2026Superan la prueba 4 de 4 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.9.