Ajusta una cabeza de clasificación con LoRA
Unos 18 minutos de lectura, con 5 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 terminar este capítulo, podrás entrenar una cabeza de clasificación con los mensajes etiquetados usando LoRA, contar los parámetros que cambia el entrenamiento, elegir un umbral de traspaso en el conjunto de desarrollo mediante una regla explícita y registrar ese umbral junto a los resultados que produjo.
Hasta ahora, el enrutador usa el sustituto, que escribe su respuesta como texto en lugar de un modelo alojado, con un umbral provisional, 0.5, que nadie eligió y que cada salida etiqueta como tal. La respuesta tiene que ser un equipo, y el umbral tiene que elegirse, así que este capítulo reemplaza esa respuesta por una cabeza que devuelve un equipo y una confianza en un solo paso hacia adelante, y elige el umbral en desarrollo antes de reportar cualquier resultado de prueba. El entrenamiento necesita mensajes etiquetados para los equipos del enrutador, y estos provienen de BANKING77, un conjunto de datos público. El capítulo 3 eligió SmolLM2-135M-Instruct como modelo base, y este capítulo ajusta ese modelo y ningún otro: el de 360M sigue siendo una comparación, como dijo el capítulo 3. El enrutador se mide en las muestras que fijó el capítulo 2.
Este capítulo no compara el adaptador con el de 360M, y tampoco destila ni cuantiza nada. Los capítulos 6, 7 y 9 destilan, cuantizan y versionan el adaptador.
Esta parte aún no está traducida, así que está en inglés.
A head that scores the teams
The stand-in writes its answer as text, and a grammar limits that text to the 77 team names while it decodes (chapter 4). A classification head works differently from the stand-in: it keeps the language model's layers and adds one output layer with 77 outputs, one for each team. For each message, the model produces 77 scores. Softmax turns the scores into 77 probabilities that sum to one. The router returns the team with the highest probability, and the confidence is that probability.
The answer is an index into the 77 teams, so it is always one of them. Chapter 4 reaches the same guarantee for a prompted model by constraining its text. This head never writes text, so it has nothing to constrain.
A message costs one forward pass: one run of the network from input to scores, with no loop that writes tokens one at a time. The team and the confidence come from that same pass. This matters for the hand-off. The flag that sends a message to a person is computed from the same probabilities as the team it protects, so the two cannot drift apart between two calls. A separate scoring call would need its own check that the two agree.
The confidence here has a narrower meaning than the stand-in's. In chapter 1, a confidence was the probability the stand-in's recorded answer had, which is not a softmax over teams. In this chapter, the confidence is the softmax probability of the chosen team. The two numbers are both called confidence, and both are compared with a threshold, but they are not the same quantity, so a threshold chosen for one is not a threshold for the other.
When two teams tie, router_lib's classify function takes the lower label index. That follows from torch's argmax, whose documentation says: "If there are multiple maximal values then the indices of the first maximal value are returned." (torch 2.15.0+cpu documentation). A fixed rule for ties keeps the output reproducible.
Working rule: Read the team and the confidence from one forward pass, and take the team as the output with the highest probability. Keep both in one function, so that a hand-off decision and the team it protects come from the same answer. Do not set a head's confidence beside a stand-in's as though they measured the same thing.
Los adaptadores entrenan una parte pequeña del modelo
El ajuste fino completo cambia cada peso del modelo base. LoRA sigue otro camino. El artículo que presentó LoRA, Hu et al. (2021), dice que congela los pesos preentrenados e inyecta matrices de bajo rango entrenables en las capas del Transformer, y las matrices LoRA entrenadas son el adaptador. El modelo base se mantiene como estaba, y el adaptador es la parte que este libro almacena, carga y versiona.
El rango, r, es el tamaño interno de cada matriz añadida, y se mantiene pequeño. Peft escala la actualización añadida por lora_alpha dividido entre r (peft 0.21.3, src/peft/tuners/lora/layer.py, línea 281: self.scaling[adapter_name] = lora_alpha / r), así que lora_alpha determina cuánto pesa la actualización. Este libro usa un rango de 8, con lora_alpha fijado en 16. Las matrices añadidas van en las capas de proyección llamadas q_proj y v_proj de cada bloque de atención. El resumen no nombra esas capas, así que esta elección es del libro, no algo que prescriba el artículo. La recomendamos como punto de partida, y el adaptador registrado más abajo es la prueba de esa recomendación en esta tarea. Otros objetivos son una elección que hay que medir, no un hecho sobre el método.
La cabeza también se entrena. Peft lo hace para la configuración de este libro: un modelo construido como clasificador de secuencias lista sus capas classifier y score en modules_to_save (peft 0.21.3, src/peft/peft_model.py, línea 1830: classifier_module_names = ["classifier", "score"]), así que el entrenamiento mueve juntas la capa de 77 salidas y el adaptador. Si cuentas solo las matrices del adaptador obtienes un número menor que el que entrena el código, y la diferencia es la cabeza. La ejecución de la siguiente sección cuenta la división a partir del modelo cargado: 460800 en el adaptador y 44352 en la cabeza, que juntos suman 505152.
El manifiesto del adaptador registra la revisión del modelo base, así que puedes comparar esa revisión con models.toml antes de puntuar.
Regla práctica: Fija el rango, el escalado y las capas objetivo en una sola configuración, y cuenta los parámetros entrenables a partir del modelo cargado antes de empezar el entrenamiento. Imprime el total con la cabeza incluida. Un recuento que deja fuera la cabeza informa solo de una parte de lo que cambia el entrenamiento, y no coincidirá con lo que actualiza el optimizador.
Treinta pasos no bastan
Antes de que el libro use una grabación, muestra qué hace una ejecución corta con la misma receta. La ejecución siguiente toma 30 pasos, con un tamaño de lote de 8 y una semilla de 0, sobre las filas de entrenamiento fuera de dev, y luego evalúa test_200, las primeras 200 entradas de la muestra fija que tomó el capítulo 2. Es un fracaso, y el libro lo muestra como tal. La ejecución corta comprueba que el proceso funciona de principio a fin, y ese es su único cometido aquí.
1"""Train for 30 steps on the recorded recipe, then score test_200 at the placeholder threshold of 0.5.2Read the three step losses against the uniform-guess loss, then the hand-off line at that threshold. The recording runs 1,125 steps."""34import math56import torch78torch.set_num_threads(2)910import router_lib # noqa: E4021112router_lib.setup_runtime()13REPO = "HuggingFaceTB/SmolLM2-135M-Instruct"14STEPS, BATCH, SEED = 30, 8, 01516train, order = router_lib.training_rows(SEED) # the seed sets the shuffled order of the training rows, the one the recording used17tok, model = router_lib.new_classifier(REPO) # SmolLM2 with a 77-way head, LoRA rank 8, lora_alpha 16, on q_proj and v_proj18lora, head = router_lib.parameter_split(model) # LoRA tensors have "lora_" in their names; every other trainable tensor is the head19print(f"trainable parameters: {lora + head}")20print(f"LoRA parameters: {lora}")21print(f"head parameters: {head}")2223losses = router_lib.train_steps(model, tok, train, order, STEPS, BATCH) # AdamW at learning rate 1e-3, router_lib's default24print(f"training steps: {STEPS}")25print(f"batch size: {BATCH}")26print(f"seed: {SEED}")27for step in (10, 20, 30):28 print(f"loss at step {step}: {losses[step - 1]:.2f}") # train_steps returns one loss per step, from step 1 at index 0, so step 10 is index 929print(f"loss of a uniform guess over 77 teams: {math.log(77):.2f}")3031result = router_lib.score_test_sample(model, tok, "test_200", 0.5) # 0.5 is chapter 1's placeholder; this run chooses no threshold32n = result["n"]33print(f"messages on test_200: {n}")34print(f"accuracy on test_200: {result['correct']}/{n} ({result['accuracy']:.1%})")35print(f"handed off at placeholder 0.50: {result['handed_off']}/{n} ({result['handoff_rate']:.1%})")36if result["accuracy_not_handed_off"] is None: # None when no message is kept, so there is no accuracy to print37 print("accuracy on messages not handed off: not defined (0 messages not handed off)")38else:39 m = result["not_handed_off"]40 print(f"accuracy on messages not handed off: {result['correct_not_handed_off']}/{m} ({result['accuracy_not_handed_off']:.1%})")
python lora-thirty-steps.pytrainable parameters: 505152
LoRA parameters: 460800
head parameters: 44352
training steps: 30
batch size: 8
seed: 0
loss at step 10: 4.13
loss at step 20: 6.12
loss at step 30: 4.38
loss of a uniform guess over 77 teams: 4.34
messages on test_200: 200
accuracy on test_200: 5/200 (2.5%)
handed off at placeholder 0.50: 200/200 (100.0%)
accuracy on messages not handed off: not defined (0 messages not handed off)
Treinta pasos no son suficientes para enrutar con ellos. El cabezal que entrena esta ejecución acierta 5/200 (2.5%) sobre test_200, y con el umbral de marcador de posición deriva todos los mensajes a una persona: 200/200 (100.0%). Un enrutador que deriva todos los mensajes no entrega ningún mensaje a un equipo, así que las etiquetas que predice nunca llegan a quien llama. Como no se conserva ningún mensaje, la exactitud sobre los mensajes no derivados no está definida, tal como indica la salida.
La pérdida no baja de forma constante a lo largo de los tres pasos impresos: es 4.13 en el paso 10, 6.12 en el paso 20 y 4.38 en el paso 30. El paso 20 es más alto que el paso 10, y el paso 30 es más bajo que el paso 20 pero más alto que el paso 10. Tres puntos de 30 pasos no son una curva de aprendizaje. La pérdida en el paso 30 está cerca de la suposición uniforme de 4.34, así que en ese punto el cabezal sigue cerca del azar. Una suposición uniforme da a cada equipo la misma probabilidad, uno entre 77, de modo que su pérdida es el logaritmo natural de 77. La grabación usada en la sección sobre el adaptador registrado ejecuta la misma receta durante muchos más pasos, y su exactitud es la que este libro informa.
Evaluar test_200 aquí solo informa del fracaso, y no se elige nada a partir de él: la receta se fija antes de la ejecución, y el umbral se elige más tarde sobre dev. Para ver si el entrenamiento funciona, lee la pérdida y las medidas de dev, no la muestra de prueba, como establece la regla que fijó el capítulo 2 para cada muestra. Ajustar una receta contra la muestra de prueba no deja un número limpio que reportar, y la muestra deja de ser una prueba.
Regla práctica: Ejecuta un entrenamiento corto para comprobar que el proceso funciona de principio a fin, y no enrutes con su cabezal. Juzga un cabezal ajustado con fine-tuning en la partición dev, con las medidas fijadas en el capítulo 2, tras una ejecución lo bastante larga para alcanzarlas. No leas una curva de pérdida de unos pocos puntos como prueba de que el cabezal aprende.
Entrena solo con las filas de entrenamiento, nunca con las filas de prueba
El archivo de entrenamiento contiene mensajes etiquetados, y el capítulo 2 extrajo de él la división de desarrollo, equipo por equipo, con una semilla fija. El entrenamiento usa las filas de entrenamiento que no se reservan para desarrollo. El archivo de prueba nunca se lee durante el entrenamiento. El orden de entrenamiento de treinta pasos no bastan se construye con las filas que quedan después de quitar desarrollo, mezcladas con la semilla 0, de modo que es el mismo en cada ejecución.
La división de desarrollo sostiene las decisiones. Contiene 1003 mensajes de train.csv, el archivo de entrenamiento. Ningún paso de entrenamiento los lee, y solo se usan para elegir el umbral y para comprobar la calibración en la última sección.
La receta está escrita en el manifiesto del adaptador, de modo que puedas ver con qué se entrenó el adaptador: la revisión fijada del modelo base, la confirmación de los datos, el tamaño de lote, la semilla y el número de pasos. Repetir el entrenamiento requiere esos valores, y comprobar que un resultado proviene de una división limpia requiere la confirmación de los datos.
La regla importa sobre todo cuando un resultado parece bueno. Una ejecución de entrenamiento que lee la muestra de prueba ha visto los mensajes con los que después se evalúa, de modo que su precisión en prueba no mide nada sobre mensajes nuevos. Mantener desarrollo y prueba separados es lo que hace que la precisión en prueba de la siguiente sección sea un informe justo.
Regla práctica: Entrena solo con filas de entrenamiento que estén fuera de desarrollo. Registra la semilla, el tamaño de lote, el número de pasos y la confirmación de los datos en el manifiesto. Cuando desarrollo sea demasiado pequeño para decidir un umbral, extrae más mensajes del archivo de entrenamiento, nunca del archivo de prueba, como dice el capítulo 2.
Usa el adaptador grabado
El enrutador en funcionamiento usa banking77-lora-v1: el adaptador de la ejecución completa grabada, versión 1, escrito por recordings/lora_full.py. Ese script entrenó el adaptador una sola vez, con la receta de la sección sobre las filas de entrenamiento, y escribió sus archivos y un manifiesto. El manifiesto guarda la revisión del modelo base, el commit de los datos, el umbral, el hash de la receta y los hashes de los archivos de salida. Sin conexión, el adaptador se carga y evalúa test_200 con el umbral de su manifiesto, y no se entrena nada.
Toma el adaptador tal como quedó grabado. Una receta distinta es una nueva ejecución, llamada v2; el libro no edita el adaptador a mano. Mantener fija la grabación es lo que permite que un lector compruebe las cifras de este capítulo con los archivos que descargó.
1"""Load the recorded adapter banking77-lora-v1 and score test_200 at the threshold in its manifest; no training runs here.2Read the accuracy line with the two hand-off lines printed under it."""34import os56os.environ["HF_HUB_OFFLINE"] = "1"7os.environ["TRANSFORMERS_OFFLINE"] = "1"89import json # noqa: E4021011import torch # noqa: E4021213torch.set_num_threads(2)1415import router_lib # noqa: E4021617router_lib.setup_runtime()18RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"19manifest = json.loads((RECORDED / "manifest.json").read_text())20threshold = manifest["handoff_threshold"] # the threshold the recording chose on dev; this script chooses none2122tokenizer, model = router_lib.load_classifier(RECORDED / "adapter") # the base model comes from the adapter's config, at its revision in models.toml23test = router_lib.read_rows("test")24sample = router_lib.read_sample("test_200")25golds = [test[i][1] for i in sample]26preds, confs = router_lib.classify(model, tokenizer, [test[i][0] for i in sample]) # a tie goes to the lower label index2728result = router_lib.metrics(preds, golds, confs, threshold) # a message is handed off when its confidence is below the threshold29n = result["n"]30print(f"adapter: {manifest['adapter']}")31print(f"handoff threshold from manifest: {threshold:.2f}")32print(f"messages on test_200: {n}")33print(f"accuracy on test_200: {result['correct']}/{n} ({result['accuracy']:.1%})")34print(f"handed off: {result['handed_off']}/{n} ({result['handoff_rate']:.1%})")35if result["accuracy_not_handed_off"] is None: # None when no message is kept, so there is no accuracy to print36 print("accuracy on messages not handed off: not defined (0 messages not handed off)")37else:38 m = result["not_handed_off"]39 print(40 f"accuracy on messages not handed off: {result['correct_not_handed_off']}/{m} "41 f"({result['accuracy_not_handed_off']:.1%})"42 )
python lora-recorded-adapter.pyadapter: banking77-lora-v1
handoff threshold from manifest: 0.63
messages on test_200: 200
accuracy on test_200: 172/200 (86.0%)
handed off: 33/200 (16.5%)
accuracy on messages not handed off: 156/167 (93.4%)
El adaptador grabado acierta en 172/200 (86.0%) de los mensajes, frente a 9/200 (4.5%) del modelo de 135M con prompting que el capítulo 4 midió sobre los mismos 200. La ejecución de 30 pasos, con 5/200 (2.5%), queda por debajo del modelo con prompting. Un mensaje derivado cuenta como erróneo cuando su equipo es incorrecto. La salida junto a este párrafo da el número de mensajes derivados y la exactitud sobre los mensajes no derivados, cada uno con su recuento y su denominador, como exige el capítulo 2.
El umbral no se elige sobre esta muestra. Procede del manifiesto, que explica la sección sobre cómo elegir el umbral. Es el umbral que usan los recuentos de derivación del adaptador grabado sobre test_200: 0.63. Leerlo del manifiesto mantiene la elección en el conjunto de desarrollo, donde la regla la hizo.
El adaptador grabado es el modelo del enrutador, y el sustituto es la línea base. Los dos se midieron con umbrales distintos, así que sus recuentos de derivación no son el mismo tipo de resultado. Compáralos sobre los mismos mensajes, con cada umbral indicado junto a su recuento. La comparación siguiente lo hace para test_200, leyendo las respuestas grabadas del sustituto para los mismos mensajes.
1"""Set the stand-in's recorded answers beside the recorded adapter's live predictions on the same 200 test messages.2The last two lines count where the models disagree."""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()19STANDIN_THRESHOLD = 0.5 # chapter 1's placeholder; the stand-in's own threshold is never chosen on dev20ADAPTER = router_lib.HERE / "data" / "recorded" / "lora-full"2122with open(router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl") as f:23 answers = {row["index"]: row for row in map(json.loads, f)} # keyed by the test-row index that read_sample returns24threshold = json.loads((ADAPTER / "manifest.json").read_text())["handoff_threshold"]2526test = router_lib.read_rows("test")27sample = router_lib.read_sample("test_200")28golds = [test[i][1] for i in sample]29standin_preds = [answers[i]["label"] for i in sample]30standin_confs = [math.exp(answers[i]["logprob"]) for i in sample] # the recording stores log-probabilities; exp turns one back into the probability its answer had3132tokenizer, model = router_lib.load_classifier(ADAPTER / "adapter")33adapter_preds, adapter_confs = router_lib.classify(model, tokenizer, [test[i][0] for i in sample])3435standin = router_lib.metrics(standin_preds, golds, standin_confs, STANDIN_THRESHOLD)36adapter = router_lib.metrics(adapter_preds, golds, adapter_confs, threshold)37n = standin["n"]38s_right = [p == g for p, g in zip(standin_preds, golds)]39a_right = [p == g for p, g in zip(adapter_preds, golds)]4041print(f"messages on test_200: {n}")42print(f"stand-in correct: {standin['correct']}/{n} ({standin['accuracy']:.1%})")43print(f"adapter banking77-lora-v1 correct: {adapter['correct']}/{n} ({adapter['accuracy']:.1%})")44print(f"stand-in placeholder threshold: {STANDIN_THRESHOLD:.2f}")45print(f"stand-in handed off: {standin['handed_off']}/{n} ({standin['handoff_rate']:.1%})")46print(f"adapter threshold from manifest: {threshold:.2f}")47print(f"adapter handed off: {adapter['handed_off']}/{n} ({adapter['handoff_rate']:.1%})")48print(f"right for the adapter, wrong for the stand-in: {sum(a and not s for a, s in zip(a_right, s_right))}/{n}")49print(f"right for the stand-in, wrong for the adapter: {sum(s and not a for a, s in zip(a_right, s_right))}/{n}")
python compare-with-standin.pymessages on test_200: 200
stand-in correct: 109/200 (54.5%)
adapter banking77-lora-v1 correct: 172/200 (86.0%)
stand-in placeholder threshold: 0.50
stand-in handed off: 9/200 (4.5%)
adapter threshold from manifest: 0.63
adapter handed off: 33/200 (16.5%)
right for the adapter, wrong for the stand-in: 69/200
right for the stand-in, wrong for the adapter: 6/200
Emparejar los dos modelos mensaje a mensaje muestra qué mensajes falla cada uno. Las respuestas del sustituto provienen de su grabación, y el adaptador se ejecuta en vivo sobre los mismos 200 mensajes. La confianza del sustituto es la probabilidad que tenía su respuesta grabada, según el logaritmo de probabilidad de la grabación. El umbral del sustituto es el marcador de posición del capítulo 1, 0.50, y la salida lo etiqueta como tal. Su recuento de derivación, 9/200 (4.5%), indica lo que ese marcador hace al sustituto, y nada sobre el umbral propio del sustituto, que nunca se eligió en desarrollo. El adaptador deriva 33/200 (16.5%) con 0.63.
El adaptador acierta en 172/200 (86.0%) de estos mensajes, y el sustituto en 109/200 (54.5%). Donde los dos discrepan, solo el adaptador acierta en 69/200 y solo el sustituto en 6/200. Dos exactitudes pueden ser iguales mientras los dos modelos fallan en mensajes distintos, y los recuentos de discrepancia muestran dónde ocurre eso.
La comparación es una muestra de 200 mensajes. El capítulo 1 dijo que su muestra pequeña puede mostrar que un enrutador falla, pero no puede distinguir con confianza dos enrutadores. La muestra del capítulo 1 era más pequeña. Los recuentos discordantes de aquí, 69/200 frente a 6/200, son una evidencia más sólida de la que podía dar aquella muestra. Para una afirmación más firme, ejecuta la misma comparación sobre la muestra completa de test_1001, que también cubre la grabación del sustituto.
Regla práctica: Compara dos modelos solo sobre los mismos mensajes, y indica el umbral que usó cada uno junto a su recuento. Cuando un umbral es un marcador de posición, dilo junto a su recuento, y no leas su recuento de derivación como el resultado propio del modelo.
Elige el umbral en dev
El umbral es el corte que envía un mensaje a una persona. El capítulo 2 fijó sus medidas, y el capítulo 1 lo dejó como un marcador. La regla del libro lo elige solo sobre la partición dev: el umbral de confianza más bajo, en una cuadrícula de 0.01, en el que la precisión sobre los mensajes no derivados es al menos el objetivo de 0.90. La regla está escrita en el manifiesto con su valor, de modo que el lector puede ver la regla y también el número que produjo. La muestra de prueba no interviene, como exige el capítulo 2.
1"""Find the hand-off threshold on dev by the manifest's rule, then check it against the manifest's value.2Read the chosen threshold beside the three threshold lines. test_200 is not read here."""34import json56import torch78torch.set_num_threads(2)910import router_lib # noqa: E4021112router_lib.setup_runtime()13RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"14manifest_threshold = json.loads((RECORDED / "manifest.json").read_text())["handoff_threshold"]15TARGET = 0.90 # the book's target accuracy on messages not handed off: a choice the book makes, not one the data sets1617tokenizer, model = router_lib.load_classifier(RECORDED / "adapter")18rows = router_lib.read_rows("train")19dev = router_lib.read_sample("dev")20golds = [rows[i][1] for i in dev]21preds, confs = router_lib.classify_by_length(model, tokenizer, [rows[i][0] for i in dev]) # batches by length to pad less; results come back in dev order22n = len(dev)23chosen = router_lib.choose_threshold(preds, golds, confs, TARGET) # the rule lives in router_lib: the lowest 0.01 grid value that meets TARGET; None if no value meets it, and the prints below would then fail2425print(f"dev messages: {n}")26print(f"target accuracy on messages not handed off: {TARGET:.2f}")27print(f"chosen threshold: {chosen:.2f}")28print(f"threshold in manifest: {manifest_threshold:.2f}")29print(f"chosen threshold matches manifest: {'yes' if chosen == manifest_threshold else 'no'}") # both come from the same 0.01 grid, so equal means the same threshold30for t in sorted({0.50, chosen, 0.90}): # 0.50 is chapter 1's placeholder; a set drops the chosen value if it is one of the other two31 r = router_lib.metrics(preds, golds, confs, t)32 print(f"threshold {t:.2f} handed off: {r['handed_off']}/{n} ({r['handoff_rate']:.1%})")33 print(f"threshold {t:.2f} accuracy on messages not handed off: {r['correct_not_handed_off']}/{r['not_handed_off']} ({r['accuracy_not_handed_off']:.1%})")
python choose-threshold-on-dev.pydev messages: 1003
target accuracy on messages not handed off: 0.90
chosen threshold: 0.63
threshold in manifest: 0.63
chosen threshold matches manifest: yes
threshold 0.50 handed off: 80/1003 (8.0%)
threshold 0.50 accuracy on messages not handed off: 811/923 (87.9%)
threshold 0.63 handed off: 148/1003 (14.8%)
threshold 0.63 accuracy on messages not handed off: 770/855 (90.1%)
threshold 0.90 handed off: 352/1003 (35.1%)
threshold 0.90 accuracy on messages not handed off: 620/651 (95.2%)
Evaluar dev con el adaptador registrado y aplicar la regla da un umbral de 0.63. La comprobación contra el valor del manifiesto muestra yes, y una discrepancia significaría que el manifiesto y la regla no coinciden.
Tres umbrales muestran la compensación, y la tabla siguiente los pone uno al lado del otro, con cada recuento y cada tasa. Subir el umbral nunca deriva menos mensajes, y la regla elige el valor más bajo que cumple el objetivo. Cada fila corresponde al mismo adaptador sobre los mismos mensajes de dev, así que solo cambia el umbral.
| Umbral | Derivados, en dev | Precisión sobre los mensajes no derivados, en dev |
|---|---|---|
| 0.50 | 80/1003 (8.0%) | 811/923 (87.9%) |
| 0.63, elegido | 148/1003 (14.8%) | 770/855 (90.1%) |
| 0.90 | 352/1003 (35.1%) | 620/651 (95.2%) |
Con 0.50, el enrutador conserva más mensajes, pero sus mensajes conservados son menos precisos, y no se alcanza el objetivo. Con 0.90, los mensajes conservados son los más precisos de los tres, pero es el umbral con el que más mensajes de dev van a una persona. El valor elegido es el más bajo de los tres umbrales que cumple el objetivo, así que deriva más mensajes que 0.50 y menos que 0.90. La tabla muestra qué cuesta en derivaciones y qué aporta en precisión. Dónde fijar el objetivo es una decisión de negocio que la regla no puede tomar. El libro usa una precisión de 0.90 sobre los mensajes conservados, y un banco que ejecute su propio enrutador leería su objetivo a partir de esta compensación.
El adaptador sigue igual en producción, pero los mensajes que ve no. Supongamos que un problema de producto envía muchos mensajes sobre un mismo equipo en una semana. El umbral se eligió con la mezcla de mensajes de dev, así que la tasa de derivación puede cambiar por sí sola mientras el adaptador sigue exactamente igual. Un aumento de derivaciones sin cambio en el adaptador es la señal para revisar primero la mezcla de mensajes. Ajustar el umbral a ojo hasta que la tasa de derivación parezca correcta renuncia a la propiedad para la que se eligió la regla: al menos la precisión objetivo sobre los mensajes de dev que el enrutador conserva.
La confianza no es la probabilidad de que el equipo asignado sea el correcto. Guo et al. (2017) señalan que sus redes están "mal calibradas", lo que significa que su confianza no coincide con la frecuencia con la que aciertan. Este libro comprueba su propio adaptador en dev. Los mensajes de dev se reparten en cinco bandas de confianza, y cada banda recibe un recuento, una precisión y una confianza media, las dos cantidades que Guo et al. comparan al medir la calibración. Agrupar dev por confianza muestra si un 0.9 significa nueve de cada diez.
1"""Group the dev messages into five bands by the adapter's confidence, and print each band's count, accuracy and mean confidence.2Read the top band's mean confidence against its accuracy. Only dev is read."""34import os56os.environ["HF_HUB_OFFLINE"] = "1"7os.environ["TRANSFORMERS_OFFLINE"] = "1"89import torch # noqa: E4021011torch.set_num_threads(2)1213import router_lib # noqa: E4021415router_lib.setup_runtime()16RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"17BANDS = [(0.0, 0.2), (0.2, 0.4), (0.4, 0.6), (0.6, 0.8), (0.8, 1.0)]1819tokenizer, model = router_lib.load_classifier(RECORDED / "adapter")20rows = router_lib.read_rows("train")21dev = router_lib.read_sample("dev")22golds = [rows[i][1] for i in dev]23preds, confs = router_lib.classify_by_length(model, tokenizer, [rows[i][0] for i in dev]) # results come back in dev order, so index i matches golds[i]2425print(f"dev messages: {len(dev)}")26counted = 027for lo, hi in BANDS:28 last = hi == 1.029 members = [i for i, c in enumerate(confs) if lo <= c < hi or (last and c == 1.0)] # lower edges are in, upper edges out; the top band also takes 1.0, so each message is counted once30 counted += len(members)31 name = f"band {lo:.1f}-{hi:.1f}"32 print(f"{name} messages: {len(members)}")33 if members:34 correct = sum(preds[i] == golds[i] for i in members)35 print(f"{name} correct: {correct}/{len(members)} ({correct / len(members):.1%})")36 print(f"{name} mean confidence: {sum(confs[i] for i in members) / len(members):.1%}")37 else:38 print(f"{name} correct: not defined (0 messages)")39 print(f"{name} mean confidence: not defined (0 messages)")40print(f"messages in bands: {counted}")
python calibration-bands-on-dev.pydev messages: 1003
band 0.0-0.2 messages: 1
band 0.0-0.2 correct: 1/1 (100.0%)
band 0.0-0.2 mean confidence: 19.9%
band 0.2-0.4 messages: 41
band 0.2-0.4 correct: 10/41 (24.4%)
band 0.2-0.4 mean confidence: 32.9%
band 0.4-0.6 messages: 92
band 0.4-0.6 correct: 49/92 (53.3%)
band 0.4-0.6 mean confidence: 51.0%
band 0.6-0.8 messages: 123
band 0.6-0.8 correct: 84/123 (68.3%)
band 0.6-0.8 mean confidence: 70.6%
band 0.8-1.0 messages: 746
band 0.8-1.0 correct: 693/746 (92.9%)
band 0.8-1.0 mean confidence: 96.4%
messages in bands: 1003
La mayoría de los mensajes de dev caen en la banda superior, de 0.8 a 1.0, que contiene 746 de ellos. La banda inferior, de 0.0 a 0.2, contiene 1, muy pocos para que su precisión diga algo sobre la confianza baja.
En dev la confianza ordena los mensajes de forma útil, pero en la parte alta supera a la precisión: la confianza media de la banda superior es de 96.4%, frente a una precisión de 693/746 (92.9%). Cuatro de las cinco bandas tienen una precisión dentro de su rango, y la banda inferior es la excepción, con su único mensaje. Desde la segunda banda hacia arriba, la precisión sube. En las dos bandas intermedias, la precisión y la confianza media están cerca, mientras que en la banda de 0.2 a 0.4 la confianza media está muy por encima de la precisión.
Las bandas no pueden mostrar más: la banda de 0.2 a 0.4 contiene 41 mensajes. Todos los números de aquí provienen de la única muestra de dev que también eligió el umbral, así que ninguno muestra cuán calibrado estará el adaptador con mensajes nuevos.
El enrutador que elige la regla es un corte empírico sobre dev, registrado con su regla y sus datos. Es un corte, no un modelo de los mensajes, así que sus números describen la mezcla de dev. Un lector toma su tasa de derivación y su precisión sobre los mensajes conservados como el resultado del enrutador, y vuelve a comprobar la regla de dev cuando la mezcla de mensajes cambie.
Regla práctica: Elige el umbral en la partición dev según la regla establecida, y escribe su valor y la regla en el manifiesto del adaptador. Informa la tasa de derivación junto con la precisión de los mensajes conservados, cada una con su recuento, y muestra al menos un valor a cada lado del valor elegido. Comprueba la calibración en dev antes de confiar en la confianza como corte, y cuando cambie la mezcla de mensajes, vuelve a elegir el umbral sobre una nueva muestra dev extraída del archivo de entrenamiento.
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.