Rechaza cuando la documentación no lo dice y mide los dos tipos de error
Unos 23 minutos de lectura, con 3 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.3. Lee el original
Al terminar este capítulo podrás contar las dos maneras en que un asistente no logra responder a partir de su documentación, leer las dos tasas sobre sus propios denominadores y decir cuándo una regla que rechaza con más frecuencia vale lo que cuesta.
El asistente de este libro responde preguntas sobre sablefile, una herramienta de línea de comandos que mantiene los archivos generados de un proyecto sincronizados con las plantillas de las que proceden, y responde a partir de la documentación de la herramienta. Cuando la documentación no cubre una pregunta, el asistente debe responder con una frase fija, "The docs don't say.", y nada más. Esa frase parece la respuesta segura. Un equipo que ve una respuesta incorrecta en sus registros se siente tentado a hacer que el asistente rechace con más frecuencia, porque una negativa parece prudente. Pero una negativa también puede ser incorrecta. Si la documentación sí respondía la pregunta, al usuario que recibió la frase se le falló, y ese error no aparece en ningún lugar. Si la documentación no respondía y el asistente contestó de todos modos, el usuario recibe una respuesta sin nada que la sustente. Rechazar con más frecuencia cambia un tipo de error por el otro. Un equipo que cuenta solo uno de ellos ajustará el sistema hacia una cifra que se ve bien y oculta el costo del otro.
Este capítulo cuenta los dos errores en las propias respuestas del libro. Después prueba la solución obvia, una salvaguarda que rechaza cuando la puntuación de búsqueda de la sección mejor clasificada es baja, en la variante sin filtrar. En esa variante la salvaguarda no ayuda. Ese es el resultado del capítulo, y gran parte de lo que sigue trata de cómo se midió el resultado y de cuánto se puede confiar en él.
Dos errores, ambos contados
Cada pregunta del conjunto de prueba tiene un tipo. Una pregunta respondible es aquella que la documentación de la versión consultada responde. Una pregunta no respondible es aquella que la documentación no responde. Una respuesta que rechaza una pregunta respondible comete un rechazo falso, y una respuesta que contesta una pregunta no respondible comete una respuesta falsa. El primer capítulo definió ambos en su comprobación de rechazo, y este capítulo usa las mismas definiciones en más elementos.
Las dos tasas tienen denominadores distintos, y los denominadores llevan el peso del argumento. La tasa de rechazos falsos es el número de elementos respondibles rechazados, dividido entre el número de elementos respondibles. La tasa de respuestas falsas es el número de elementos no respondibles respondidos, dividido entre el número de elementos no respondibles. Si sumas ambos errores sobre un total único, un conjunto con muchos elementos respondibles hace que el recuento de rechazos parezca pequeño, y las respuestas que deberían haber sido rechazos se pierden en la suma. Cada tasa necesita su propio recuento, y cada recuento necesita su propio denominador.
Dos tipos de elementos quedan fuera de ambas tasas. Un elemento dependiente de la versión pregunta por algo que difiere entre versiones, así que su respuesta se juzga frente a la referencia de la versión consultada, y su propia tasa, la corrección por versión, se trata en el capítulo 9. Un elemento ambiguo tiene dos lecturas y se juzga por la tasa de aciertos, no por ninguna de las dos tasas de rechazo. Un rechazo en cualquiera de estos tipos no es un error aquí. El código sigue contando esos rechazos y los imprime, para que un rechazo en uno de ellos no pase inadvertido.
El código cuenta una respuesta como rechazo solo cuando la respuesta es exactamente la frase de rechazo y nada más. Una respuesta que da la frase y a continuación una contestación no es un rechazo, así que cuenta como respuesta en ambas tasas. Lo mismo ocurre con un rechazo formulado con otras palabras: el código compara la frase exactamente, de modo que un rechazo redactado de forma distinta cuenta como respuesta. En un elemento respondible eso no cuenta aquí como error, y en un elemento no respondible es una respuesta falsa, por eso la frase está fijada en el prompt.
Regla práctica: Informa las dos tasas de rechazo por separado, cada una sobre su propio denominador, y deja fuera de ambas los elementos dependientes de la versión y los ambiguos. Lee los elementos detrás de cada tasa, no solo la tasa, porque una tasa puede ocultar los pocos elementos que importan.
Lo que hace la línea base
La línea base es el asistente tal como lo construyó el primer capítulo. Ejecuta el prompt P1, que pide una cita para cada afirmación y la oración de rechazo cuando las secciones no lo dicen. Recupera las tres secciones principales con BM25, desde el índice solo de la versión consultada. Sus respuestas se registraron una vez por elemento, y el ejemplo lee esa única respuesta registrada.
Tres variantes cambian una sola cosa cada una. prompt-b ejecuta el prompt P2, que cita la oración en la que se apoya la respuesta antes de dar la respuesta. k5 entrega al modelo las cinco secciones principales en lugar de tres. unfiltered recupera desde los índices de todas las versiones juntas, con la versión de cada sección en su encabezado, para que el modelo pueda ver cuándo una sección proviene de otra versión. Cada variante tiene su propio registro de respuestas a los mismos elementos, de modo que cada comparación se hace entre respuestas a las mismas preguntas.
Contar ambos errores para cada registro requiere un solo ejemplo, decline-rates. Lee los cuatro registros en el conjunto de desarrollo y en el conjunto de prueba reservado, imprime cada tasa con sus recuentos y nombra los elementos detrás de cada error. Su salida muestra qué elementos respondibles rechazó cada registro y qué elementos no respondibles respondió.
1"""Counts the two decline errors for each recording, on dev and on held-out: answerable items declined (false refusals)2and unanswerable items answered (false answers). Each rate line rests on its own count and denominator.34Version-dependent and ambiguous items are left out of both rates; the last line per split counts the declines among5them, which are not errors here."""6import lib # first: fixes the thread counts and seeds before anything else loads78from lib.contract import parse_reply9from lib.prompts import P1_SHA256, P2_SHA25610from lib.replay import ReplayModel11from lib.stats import pct12from lib.testset import load_items1314VARIANTS = ( # label, recording, the sha256 of the prompt it was made from15 ("baseline", "assistant-baseline", P1_SHA256), # P1, k=3, filtered to the asked version16 ("unfiltered", "assistant-unfiltered", P1_SHA256), # P1, k=3, sections from every version17 ("prompt-b", "assistant-prompt-b", P2_SHA256), # P2, k=3, filtered18 ("k5", "assistant-k5", P1_SHA256), # P1, k=5, filtered19)2021for label, recording, prompt_sha256 in VARIANTS:22 model = ReplayModel(recording, prompt_sha256) # refuses a recording made from another prompt23 for split in ("dev", "held-out"):24 items = load_items(split=split)25 declined = {item.id: parse_reply(model.reply(item.id, 0)).declined for item in items} # sample 0 only26 answerable = [item for item in items if item.kind == "answerable"]27 unanswerable = [item for item in items if item.kind == "unanswerable"]28 refused = sorted(item.id for item in answerable if declined[item.id])29 answered = sorted(item.id for item in unanswerable if not declined[item.id])30 other_kinds = ("version-dependent", "ambiguous")31 other = [item.id for item in items if item.kind in other_kinds and declined[item.id]]32 print(f"{label} {split} false refusal rate (answerable declined): {pct(len(refused), len(answerable))}")33 print(f"{label} {split} false refusals: {', '.join(refused) or 'none'}")34 print(f"{label} {split} false answer rate (unanswerable answered): {pct(len(answered), len(unanswerable))}")35 print(f"{label} {split} false answers: {', '.join(answered) or 'none'}")36 for item_id in answered: # what each false answer cites, and its text, so the chapter's claims can be checked37 reply = parse_reply(model.reply(item_id, 0))38 print(f"{label} {split} reply to {item_id} cites: {', '.join(reply.citations) or 'none'}")39 print(f"{label} {split} reply to {item_id} text: {reply.text}")40 print(f"{label} {split} declined, not counted (version-dependent and ambiguous): {len(other)}")
python decline-rates.pybaseline dev false refusal rate (answerable declined): 10.0% (4 of 40)
baseline dev false refusals: q-0052, q-0060, q-0063, q-0079
baseline dev false answer rate (unanswerable answered): 0.0% (0 of 13)
baseline dev false answers: none
baseline dev declined, not counted (version-dependent and ambiguous): 6
baseline held-out false refusal rate (answerable declined): 30.0% (6 of 20)
baseline held-out false refusals: q-0101, q-0102, q-0103, q-0105, q-0111, q-0118
baseline held-out false answer rate (unanswerable answered): 0.0% (0 of 7)
baseline held-out false answers: none
baseline held-out declined, not counted (version-dependent and ambiguous): 2
unfiltered dev false refusal rate (answerable declined): 12.5% (5 of 40)
unfiltered dev false refusals: q-0005, q-0052, q-0058, q-0060, q-0079
unfiltered dev false answer rate (unanswerable answered): 15.4% (2 of 13)
unfiltered dev false answers: q-0018, q-0039
unfiltered dev reply to q-0018 cites: remote-retries
unfiltered dev reply to q-0018 text: Yes, sablefile 1.1 can fetch a remote template from a private URL that needs a login token, as long as the token is included in the request. The retry behavior for such fetches is up to 5 times before giving up, and this applies to `sync` and `diff` operations [sec:remote-retries]. The `check` command does not fetch anything and thus does not apply to such scenarios.
unfiltered dev reply to q-0039 cites: check-exit-status
unfiltered dev reply to q-0039 text: When check finds a drifted file, it prints `DRIFT` and the path, and exits with status 1. [sec:check-exit-status]
unfiltered dev declined, not counted (version-dependent and ambiguous): 9
unfiltered held-out false refusal rate (answerable declined): 45.0% (9 of 20)
unfiltered held-out false refusals: q-0101, q-0102, q-0103, q-0105, q-0106, q-0111, q-0115, q-0116, q-0117
unfiltered held-out false answer rate (unanswerable answered): 0.0% (0 of 7)
unfiltered held-out false answers: none
unfiltered held-out declined, not counted (version-dependent and ambiguous): 3
prompt-b dev false refusal rate (answerable declined): 7.5% (3 of 40)
prompt-b dev false refusals: q-0052, q-0063, q-0079
prompt-b dev false answer rate (unanswerable answered): 0.0% (0 of 13)
prompt-b dev false answers: none
prompt-b dev declined, not counted (version-dependent and ambiguous): 4
prompt-b held-out false refusal rate (answerable declined): 25.0% (5 of 20)
prompt-b held-out false refusals: q-0101, q-0102, q-0103, q-0105, q-0111
prompt-b held-out false answer rate (unanswerable answered): 0.0% (0 of 7)
prompt-b held-out false answers: none
prompt-b held-out declined, not counted (version-dependent and ambiguous): 0
k5 dev false refusal rate (answerable declined): 7.5% (3 of 40)
k5 dev false refusals: q-0052, q-0062, q-0079
k5 dev false answer rate (unanswerable answered): 0.0% (0 of 13)
k5 dev false answers: none
k5 dev declined, not counted (version-dependent and ambiguous): 5
k5 held-out false refusal rate (answerable declined): 30.0% (6 of 20)
k5 held-out false refusals: q-0102, q-0103, q-0105, q-0106, q-0111, q-0116
k5 held-out false answer rate (unanswerable answered): 0.0% (0 of 7)
k5 held-out false answers: none
k5 held-out declined, not counted (version-dependent and ambiguous): 2
La tasa de falsos rechazos de la línea base en desarrollo es 10.0% (4 of 40). Sus falsos rechazos son q-0052, q-0060, q-0063 y q-0079, y cada uno es un elemento respondible que la documentación cubre. Su tasa de falsas respuestas en desarrollo es 0.0% (0 of 13), así que no responde ninguno de los elementos no respondibles de desarrollo. El capítulo 1 tampoco encontró ninguna falsa respuesta, en solo cuatro elementos no respondibles, lo cual es muy poco para decir algo sobre una tasa. La línea base también rechazó 6 elementos de desarrollo que pertenecen a los dos tipos excluidos de ambas tasas.
Capítulo 2 cuenta 10 rechazos excesivos para esta línea base. Ese recuento abarca cada elemento que la documentación responde, incluidos los que dependen de la versión, así que incluye los falsos rechazos anteriores y los rechazos en elementos que dependen de la versión o son ambiguos, que esta tasa deja fuera.
La tabla pone los cuatro registros uno al lado del otro, en ambos conjuntos. Cada celda contiene una tasa con sus recuentos.
| Registro | Falsos rechazos en desarrollo | Falsas respuestas en desarrollo | Falsos rechazos en prueba reservada | Falsas respuestas en prueba reservada |
|---|---|---|---|---|
| baseline | 10.0% (4 of 40) | 0.0% (0 of 13) | 30.0% (6 of 20) | 0.0% (0 of 7) |
| unfiltered | 12.5% (5 of 40) | 15.4% (2 of 13) | 45.0% (9 of 20) | 0.0% (0 of 7) |
| prompt-b | 7.5% (3 of 40) | 0.0% (0 of 13) | 25.0% (5 of 20) | 0.0% (0 of 7) |
| k5 | 7.5% (3 of 40) | 0.0% (0 of 13) | 30.0% (6 of 20) | 0.0% (0 of 7) |
Lee primero la fila de unfiltered, porque es la única fila con falsas respuestas en desarrollo. Su tasa de falsos rechazos es 12.5% (5 of 40). La de la línea base es 10.0% (4 of 40). Unfiltered rechaza dos elementos respondibles que la línea base sí responde, q-0005 y q-0058, y responde q-0063, que la línea base rechaza. El saldo neto es un elemento rechazado más sobre cuarenta. Cada diferencia de rechazos respecto a la línea base en desarrollo equivale a un elemento de cuarenta. Con estos elementos, un solo elemento no basta para concluir cuál registro es mejor, y intervalos y tamaño de la muestra explica lo que una muestra de este tamaño puede mostrar.
La variante unfiltered también responde a dos elementos no respondibles de desarrollo, donde la línea base no responde ninguno. Su tasa de falsas respuestas es 15.4% (2 of 13). Se trata de un recuento de dos elementos sin intervalo, así que este capítulo lo informa como recuento y no como un aumento medido. Las dos falsas respuestas son q-0018 y q-0039.
Ambas preguntas son sobre sablefile 1.1, y la documentación de la versión 1.1 omite ambas respuestas: si una plantilla remota puede descargarse desde una dirección privada con un token de inicio de sesión, y qué estado de salida devuelve diff cuando encuentra diferencias. La línea base rechaza ambas. Las respuestas de unfiltered responden a las dos, y cada una cita una sección vecina. La respuesta a q-0018 cita remote-retries, la regla de reintentos para descargas remotas. La respuesta a q-0039 cita check-exit-status y da el estado de salida de check, un comando distinto del diff por el que pregunta la pregunta. El ejemplo imprime cada cita y el texto de cada respuesta, así que estas afirmaciones pueden comprobarse sin abrir el registro. La variante unfiltered cambia la recuperación, no el prompt, así que las citas son el primer lugar donde mirar.
Las variantes que mueven los rechazos de desarrollo en sentido contrario son prompt-b y k5. Cada una tiene un falso rechazo menos en desarrollo que la línea base, y ninguna responde un elemento no respondible de desarrollo. La tasa de falsos rechazos de prompt-b es 7.5% (3 of 40). Para k5 es 7.5% (3 of 40). Con estos elementos, cada una es uno menos que la línea base, y un solo elemento no basta para concluir nada.
Las cifras de prueba reservada se informan para completar. La tasa de falsos rechazos de prompt-b es 25.0% (5 of 20). Para k5 es 30.0% (6 of 20). Para la línea base es 30.0% (6 of 20). La diferencia entre prompt-b y la línea base es de un elemento de veinte, y con estos elementos no basta para concluir nada. Ninguna variante se elige en este capítulo, porque las diferencias en desarrollo son de un solo elemento cada una.
Regla práctica: Lee a mano cada falso rechazo del conjunto de desarrollo antes de cambiar un prompt, ya que uno de ellos puede señalar un vacío real en la documentación. Compara las variantes sobre los mismos elementos, e informa un intervalo pareado solo cuando un ejemplo lo imprima. Cuando no se imprima ninguno, informa los recuentos sobre estos elementos y no saques conclusiones sobre cuál variante es mejor. Ejecuta el conjunto de prueba reservada una sola vez, para confirmar una elección hecha en desarrollo. La variante unfiltered es aquí una advertencia: en desarrollo responde elementos no respondibles que la línea base rechaza. Este capítulo lo informa sin intervalo, así que es un motivo para comprobar, no un aumento medido.
Un guardia sobre respuestas registradas
El guardia descansa en una idea sencilla. BM25 puntúa cada sección según las palabras que comparte con la pregunta. Cuando los documentos no tienen nada sobre una pregunta, la sección que mejor coincide debería compartir pocas palabras con ella, así que su puntuación debería ser baja. Un guardia lee la puntuación de la sección que mejor coincide y se niega a responder cuando esa puntuación cae por debajo de un umbral. La idea es una hipótesis, y puede fallar. Una pregunta puede compartir muchas palabras con una sección que no la responde, y el barrido de abajo es la prueba.
El guardia se puede medir sin volver a ejecutar el modelo. La recuperación es determinista: la misma pregunta da las mismas secciones principales y las mismas puntuaciones cada vez. Así que la puntuación principal de cada elemento se puede calcular a partir del índice, y el guardia se convierte en una regla aplicada a respuestas que ya fueron registradas. Su cuadrícula y su regla son constantes en lib/guard.py. El guardia solo convierte respuestas en negativas, nunca deshace una negativa, así que puede reducir las respuestas falsas y solo puede aumentar las negativas falsas.
La puntuación del guardia debe provenir del índice que generó las respuestas que juzga, y las respuestas sin filtrar se generaron a partir de secciones de todas las versiones. Por eso el guardia lee la grabación de unfiltered y toma la puntuación BM25 principal sobre el índice de todas las versiones. Una puntuación del índice de la versión consultada se mediría sobre secciones que el modelo sin filtrar nunca vio. El guardia se prueba en la variante sin filtrar porque la línea base no responde ningún elemento de desarrollo sin respuesta, así que allí un guardia no tendría nada que eliminar, mientras que la variante sin filtrar responde dos. Este capítulo no afirma nada sobre un guardia en la línea base.
La cuadrícula va de 0.00 a 10.00 en pasos de un cuarto, por encima de todas las puntuaciones de desarrollo. Para cada umbral, la regla suma las dos tasas, cada una sobre su propio denominador, y elige el umbral con la suma más pequeña. Esa ponderación igual es una decisión, y la sección sobre demasiados y demasiado pocos vuelve sobre ella. En caso de empate gana el umbral más bajo, porque cambia menos respuestas. La regla se enuncia en lib/guard.py y elige con el conjunto de desarrollo. La división de evaluación no está intacta, pues la primera tabla de qué hace la línea base ya muestra sus tasas sin guardia. La ejecución del guardia sobre la evaluación se hizo una sola vez, con el umbral congelado.
El barrido se ejecuta en tune-guard-dev, que imprime ambas tasas en cada paso de la cuadrícula y luego la elección de la regla. Comienza con la comprobación más importante: las secciones registradas de cada elemento deben coincidir con lo que devuelve el índice, o las puntuaciones describirían una recuperación que nunca generó las respuestas.
1"""Sweeps the decline guard's threshold over dev replies of the unfiltered recording, printing both rates at each2threshold, and the threshold the dev rule picks. The line for 0.00 is the recorded replies with no guard, since no top3score is below zero; the rule's pick rests on the rate lines below it. Only dev is read here."""4import lib # first: fixes the thread counts and seeds before anything else loads56from lib.guard import GRID, GUARD_RECORDING, RULE, contexts_match, denominators, errors, pick_threshold, rows7from lib.stats import pct89dev = rows("dev")10answerable, unanswerable = denominators(dev)11print(f"recording: {GUARD_RECORDING} (all versions, dev items)")12print(f"answerable dev items: {answerable}")13print(f"unanswerable dev items: {unanswerable}")1415mismatches = contexts_match("dev")16print(f"dev items whose recorded sections differ from the retrieval: {mismatches}")17assert mismatches == 0, "the scores come from a retrieval that did not make the recorded replies"18highest = max(row.score for row in dev)19print(f"highest top score on dev: {highest:.3f}")20assert highest < GRID[-1], "the grid must reach above every dev score"2122print(f"rule: {RULE}")23for threshold in GRID:24 refusals, answers = errors(dev, threshold)25 print(f"threshold {threshold:.2f}, false refusal rate: {pct(len(refusals), answerable)}")26 print(f"threshold {threshold:.2f}, false answer rate: {pct(len(answers), unanswerable)}")2728refusals, answers = errors(dev, 0.0)29print(f"recorded false refusals (no guard): {', '.join(refusals) or 'none'}")30print(f"recorded false answers (no guard): {', '.join(answers) or 'none'}")31scores = {row.item_id: row.score for row in dev}32for item_id in answers: # the top score of each recorded false answer, so a reader can see where it falls on the grid33 print(f"top score of recorded false answer {item_id}: {scores[item_id]:.3f}")3435chosen = pick_threshold(dev)36assert chosen == 0.0, f"the dev rule now picks {chosen:.2f}, not 0.00"37refusals, answers = errors(dev, chosen)38print(f"threshold chosen by the dev rule: {chosen:.2f}")39print(f"at the chosen threshold, false refusal rate: {pct(len(refusals), answerable)}")40print(f"at the chosen threshold, false answer rate: {pct(len(answers), unanswerable)}")
python tune-guard-dev.pyrecording: assistant-unfiltered (all versions, dev items)
answerable dev items: 40
unanswerable dev items: 13
dev items whose recorded sections differ from the retrieval: 0
highest top score on dev: 9.949
rule: pick the threshold in GRID whose false refusal rate plus false answer rate is smallest, each rate over its own denominator; when two thresholds tie, take the lower one
threshold 0.00, false refusal rate: 12.5% (5 of 40)
threshold 0.00, false answer rate: 15.4% (2 of 13)
threshold 0.25, false refusal rate: 12.5% (5 of 40)
threshold 0.25, false answer rate: 15.4% (2 of 13)
threshold 0.50, false refusal rate: 12.5% (5 of 40)
threshold 0.50, false answer rate: 15.4% (2 of 13)
threshold 0.75, false refusal rate: 12.5% (5 of 40)
threshold 0.75, false answer rate: 15.4% (2 of 13)
threshold 1.00, false refusal rate: 12.5% (5 of 40)
threshold 1.00, false answer rate: 15.4% (2 of 13)
threshold 1.25, false refusal rate: 12.5% (5 of 40)
threshold 1.25, false answer rate: 15.4% (2 of 13)
threshold 1.50, false refusal rate: 12.5% (5 of 40)
threshold 1.50, false answer rate: 15.4% (2 of 13)
threshold 1.75, false refusal rate: 12.5% (5 of 40)
threshold 1.75, false answer rate: 15.4% (2 of 13)
threshold 2.00, false refusal rate: 12.5% (5 of 40)
threshold 2.00, false answer rate: 15.4% (2 of 13)
threshold 2.25, false refusal rate: 15.0% (6 of 40)
threshold 2.25, false answer rate: 15.4% (2 of 13)
threshold 2.50, false refusal rate: 17.5% (7 of 40)
threshold 2.50, false answer rate: 15.4% (2 of 13)
threshold 2.75, false refusal rate: 17.5% (7 of 40)
threshold 2.75, false answer rate: 15.4% (2 of 13)
threshold 3.00, false refusal rate: 20.0% (8 of 40)
threshold 3.00, false answer rate: 15.4% (2 of 13)
threshold 3.25, false refusal rate: 30.0% (12 of 40)
threshold 3.25, false answer rate: 15.4% (2 of 13)
threshold 3.50, false refusal rate: 32.5% (13 of 40)
threshold 3.50, false answer rate: 15.4% (2 of 13)
threshold 3.75, false refusal rate: 37.5% (15 of 40)
threshold 3.75, false answer rate: 15.4% (2 of 13)
threshold 4.00, false refusal rate: 40.0% (16 of 40)
threshold 4.00, false answer rate: 7.7% (1 of 13)
threshold 4.25, false refusal rate: 45.0% (18 of 40)
threshold 4.25, false answer rate: 7.7% (1 of 13)
threshold 4.50, false refusal rate: 55.0% (22 of 40)
threshold 4.50, false answer rate: 7.7% (1 of 13)
threshold 4.75, false refusal rate: 60.0% (24 of 40)
threshold 4.75, false answer rate: 0.0% (0 of 13)
threshold 5.00, false refusal rate: 62.5% (25 of 40)
threshold 5.00, false answer rate: 0.0% (0 of 13)
threshold 5.25, false refusal rate: 70.0% (28 of 40)
threshold 5.25, false answer rate: 0.0% (0 of 13)
threshold 5.50, false refusal rate: 77.5% (31 of 40)
threshold 5.50, false answer rate: 0.0% (0 of 13)
threshold 5.75, false refusal rate: 77.5% (31 of 40)
threshold 5.75, false answer rate: 0.0% (0 of 13)
threshold 6.00, false refusal rate: 80.0% (32 of 40)
threshold 6.00, false answer rate: 0.0% (0 of 13)
threshold 6.25, false refusal rate: 82.5% (33 of 40)
threshold 6.25, false answer rate: 0.0% (0 of 13)
threshold 6.50, false refusal rate: 87.5% (35 of 40)
threshold 6.50, false answer rate: 0.0% (0 of 13)
threshold 6.75, false refusal rate: 87.5% (35 of 40)
threshold 6.75, false answer rate: 0.0% (0 of 13)
threshold 7.00, false refusal rate: 92.5% (37 of 40)
threshold 7.00, false answer rate: 0.0% (0 of 13)
threshold 7.25, false refusal rate: 92.5% (37 of 40)
threshold 7.25, false answer rate: 0.0% (0 of 13)
threshold 7.50, false refusal rate: 92.5% (37 of 40)
threshold 7.50, false answer rate: 0.0% (0 of 13)
threshold 7.75, false refusal rate: 92.5% (37 of 40)
threshold 7.75, false answer rate: 0.0% (0 of 13)
threshold 8.00, false refusal rate: 92.5% (37 of 40)
threshold 8.00, false answer rate: 0.0% (0 of 13)
threshold 8.25, false refusal rate: 95.0% (38 of 40)
threshold 8.25, false answer rate: 0.0% (0 of 13)
threshold 8.50, false refusal rate: 95.0% (38 of 40)
threshold 8.50, false answer rate: 0.0% (0 of 13)
threshold 8.75, false refusal rate: 95.0% (38 of 40)
threshold 8.75, false answer rate: 0.0% (0 of 13)
threshold 9.00, false refusal rate: 97.5% (39 of 40)
threshold 9.00, false answer rate: 0.0% (0 of 13)
threshold 9.25, false refusal rate: 97.5% (39 of 40)
threshold 9.25, false answer rate: 0.0% (0 of 13)
threshold 9.50, false refusal rate: 97.5% (39 of 40)
threshold 9.50, false answer rate: 0.0% (0 of 13)
threshold 9.75, false refusal rate: 97.5% (39 of 40)
threshold 9.75, false answer rate: 0.0% (0 of 13)
threshold 10.00, false refusal rate: 100.0% (40 of 40)
threshold 10.00, false answer rate: 0.0% (0 of 13)
recorded false refusals (no guard): q-0005, q-0052, q-0058, q-0060, q-0079
recorded false answers (no guard): q-0018, q-0039
top score of recorded false answer q-0018: 3.762
top score of recorded false answer q-0039: 4.592
threshold chosen by the dev rule: 0.00
at the chosen threshold, false refusal rate: 12.5% (5 of 40)
at the chosen threshold, false answer rate: 15.4% (2 of 13)
La comprobación pasa: cero elementos de desarrollo difieren, y el ejemplo afirma que ese recuento es cero. La puntuación principal más alta en desarrollo es 9.949, que queda por debajo del tope de la cuadrícula.
Empieza por la parte inferior del barrido. En 0.00 ninguna puntuación cae por debajo del umbral, así que la línea muestra las respuestas registradas sin guardia. La tasa de negativas falsas ahí es 12.5% (5 of 40). La tasa de respuestas falsas es 15.4% (2 of 13). Cada línea hasta 2.00 es igual. En 2.25 las negativas falsas empiezan a subir, hasta 15.0% (6 of 40).
Las respuestas falsas no bajan hasta 4.00, donde la tasa de respuestas falsas es 7.7% (1 of 13). En 4.75 la tasa de respuestas falsas es 0.0% (0 of 13), así que ningún elemento de desarrollo sin respuesta se responde. La tasa de negativas falsas en 4.75 es 60.0% (24 of 40).
Ningún renglón del barrido reduce ambas tasas por debajo de la línea sin guardia. Cada umbral que reduce las respuestas falsas aumenta las negativas falsas, y cada umbral que deja las negativas como están deja las respuestas como están. En desarrollo, el guardia implica un intercambio y no una mejora.
El barrido también muestra el límite de la puntuación. La puntuación principal de q-0018 es 3.762, y la puntuación principal de q-0039 es 4.592. Un umbral atrapa q-0018 solo desde 4.00 en adelante, donde la tasa de negativas falsas ya es 40.0% (16 of 40). Atrapa q-0039 solo desde 4.75 en adelante. Ningún corte atrapa ambos elementos respondidos sin que se rechace a la mitad o más de los elementos respondibles. La causa probable es la puntuación misma: cuenta palabras compartidas, y una sección sobre el mismo comando puede compartir muchas palabras con una pregunta que esa sección no responde. Esta es una lectura del barrido, no un hecho medido. Comprobarlo exigiría puntuar los elementos a mano, lo que este capítulo no hace.
La elección de la regla es 0.00. En ese umbral la tasa de negativas falsas es 12.5% (5 of 40). La tasa de respuestas falsas es 15.4% (2 of 13). Ambas son iguales a las respuestas registradas sin guardia. La elección es un desempate, no un hallazgo. Las líneas de 0.00 a 2.00 tienen la misma suma, y la regla toma la más baja de ellas, así que el guardia que elige la regla es ningún guardia.
Regla práctica: Construye las puntuaciones de un guardia a partir del mismo índice que generó las respuestas, y comprueba esa coincidencia antes de leer cualquier tasa. Luego lea el barrido completo con ambas tasas en cada línea. Una elección que empata con no hacer nada indica que la regla no encontró motivo para cambiar una respuesta, y eso es una respuesta que vale la pena conservar.
Demasiadas negativas y muy pocas respuestas
El barrido muestra la disyuntiva a la que se enfrentaría un equipo si añadiera el guardián, y muestra qué informaría cada elección de medida. Supongamos que un equipo contara solo las respuestas falsas. El umbral más bajo que detiene todas las respuestas falsas en dev es 4.75, así que ese equipo elegiría 4.75 e informaría de que el asistente ya no responde preguntas que no puede respaldar. La línea de 4.75 de el barrido muestra el precio que ese informe oculta. Con 4.75, la tasa de negativas falsas es 60.0% (24 of 40). Nada en el informe lo diría, porque el equipo nunca contó el otro error.
En producción, este es el fallo que hay que vigilar. Un usuario que hace una pregunta que la documentación sí responde recibe la frase de negativa, y la respuesta no da ninguna señal de que esa frase fuera errónea. El único lugar donde aparece el coste es el recuento de negativas falsas. Un equipo que no lo cuenta lee el cero en respuestas falsas y lanza el producto.
La regla pondera ambos errores por igual, y esa es una decisión que corresponde al equipo. Un equipo podría juzgar que una respuesta falsa es mucho más costosa que una negativa falsa, por ejemplo cuando una respuesta errónea pero dada con seguridad envía al usuario a la solución equivocada. Ese equipo obtendría una elección distinta en dev una vez que su peso fuera lo bastante grande como para mover la suma, y el barrido muestra la dirección: un peso mayor en las respuestas falsas empuja la elección hacia umbrales que niegan más. Un equipo así debería anotar sus pesos antes de que nadie lea el barrido, y luego entregárselos a la regla. Este capítulo no vuelve a ejecutar la regla con otros pesos, y no reabre la partición reservada (held-out) para hacerlo. Elegir un peso después de ver las cifras de la partición reservada sería una segunda ronda de ajuste sobre esa partición.
El umbral también pertenece al asistente que produjo las respuestas. Las puntuaciones dependen del índice, que depende de cómo se dividen las secciones y de qué versiones contiene. Si cambia cualquiera de estos elementos, las puntuaciones se mueven, así que el umbral hay que volver a elegirlo en dev, y la primera comprobación del ejemplo tiene que volver a superarse antes de que nadie lea una tasa.
Regla práctica: Antes de ajustar un umbral, escribe el coste de cada error en los términos propios del equipo, y entrega a la regla esos pesos antes de que nadie lea el barrido.
Qué debe aceptar el lector
La división held-out se ejecutó una sola vez, con el umbral fijado en 0.00. La ejecución es guard-held-out, y primero afirma que la regla de dev (descrita en el guard) sigue eligiendo ese valor. Un cambio en los datos de dev o en la regla, por tanto, detiene la ejecución antes de que se imprima ningún número held-out.
1"""Applies the decline guard, with its threshold frozen from dev, to the held-out items of the unfiltered recording, and2prints both rates with 95% bootstrap intervals over items. The threshold is a constant chosen by tune-guard-dev's rule3on dev; the assert checks that the rule still picks it, so a change to the dev data or the rule fails here."""4import lib # first: fixes the thread counts and seeds before anything else loads56from lib.guard import denominators, errors, guarded, pick_threshold, rows7from lib.stats import bootstrap_mean, interval_pct, pct89# Picked on dev by tune-guard-dev (the rule in lib/guard.py), then frozen. Held-out is not used to change it.10FROZEN_THRESHOLD = 0.01112dev_pick = pick_threshold(rows("dev")) # reads dev only13assert dev_pick == FROZEN_THRESHOLD, f"the dev rule now picks {dev_pick:.2f}, not the frozen {FROZEN_THRESHOLD:.2f}"1415held = rows("held-out")16answerable, unanswerable = denominators(held)17refusals, answers = errors(held, FROZEN_THRESHOLD)18print(f"threshold (frozen from dev): {FROZEN_THRESHOLD:.2f}")19print(f"held-out answerable items: {answerable}")20print(f"held-out unanswerable items: {unanswerable}")21changed = [row.item_id for row in held if guarded(row, FROZEN_THRESHOLD) != row.declined]22print(f"held-out replies the guard changed to declines: {len(changed)} of {len(held)}")2324# One 0/1 flag per item: the bootstrap over these flags is the bootstrap of the rate, over items.25refused_flags = [float(guarded(row, FROZEN_THRESHOLD)) for row in held if row.kind == "answerable"]26answered_flags = [float(not guarded(row, FROZEN_THRESHOLD)) for row in held if row.kind == "unanswerable"]27assert len(refused_flags) == answerable and len(answered_flags) == unanswerable2829refusal_lo, refusal_hi = bootstrap_mean(refused_flags, level=0.95) # 2,000 resamples, seeded (lib/stats.py)30answer_lo, answer_hi = bootstrap_mean(answered_flags, level=0.95)31print(f"false refusal rate: {pct(len(refusals), answerable)} interval {interval_pct(refusal_lo, refusal_hi)}")32print(f"false refusals: {', '.join(refusals) or 'none'}")33print(f"false answer rate: {pct(len(answers), unanswerable)} interval {interval_pct(answer_lo, answer_hi)}")34print(f"false answers: {', '.join(answers) or 'none'}")
python guard-held-out.pythreshold (frozen from dev): 0.00
held-out answerable items: 20
held-out unanswerable items: 7
held-out replies the guard changed to declines: 0 of 27
false refusal rate: 45.0% (9 of 20) interval [25.0%, 70.0%]
false refusals: q-0101, q-0102, q-0103, q-0105, q-0106, q-0111, q-0115, q-0116, q-0117
false answer rate: 0.0% (0 of 7) interval [0.0%, 0.0%]
false answers: none
El filtro fijado cambia 0 of 27 respuestas held-out, así que la salida held-out es la salida registrada sin filtro. En la división held-out, la tasa de rechazos falsos es 45.0% (9 of 20) interval [25.0%, 70.0%]. La tasa de respuestas falsas es 0.0% (0 of 7) interval [0.0%, 0.0%].
La tasa de rechazos falsos es la misma que la de la variante sin filtrar de la primera tabla, y la ejecución held-out coincide con dev en el punto principal: el filtro no hace nada con el umbral que eligió la regla. Un equipo que mirara solo la tasa de respuestas falsas en held-out vería cero y concluiría que el asistente no responde lo que no puede respaldar. El error está en los rechazos, y ningún umbral puede eliminarlos, porque el filtro solo añade rechazos.
La tasa de respuestas falsas held-out es 0.0% (0 of 7) interval [0.0%, 0.0%].
Su intervalo impreso no tiene amplitud. El intervalo remuestrea los siete ítems held-out sin respuesta posible. Ninguno recibe una respuesta incorrecta, así que ningún remuestreo tiene errores, y el bootstrap no puede variar. Fidelidad ofrece el razonamiento para este caso de cero eventos, y este ejemplo no imprime ninguna cota exacta, por lo que el intervalo no se lee como una cota. No puede distinguir una tasa de respuestas falsas de cero de una tasa pequeña que estos siete ítems simplemente no captaron. Siete ítems solo muestran que ninguno de ellos recibió una respuesta incorrecta.
Dev tampoco es mejor. En dev, las respuestas sin filtrar dan 15.4% (2 of 13). Con 4.00 dan 7.7% (1 of 13), un ítem menos.
El intervalo de rechazos falsos es amplio por otra razón: veinte ítems dejan una banda de tasas que los datos no pueden distinguir. La cifra held-out es 45.0% (9 of 20) interval [25.0%, 70.0%]. Intervalos y tamaño de la muestra explica el bootstrap sobre ítems que construye estos intervalos, y cuántos ítems necesita una diferencia pareada. Kohavi y colaboradores hacen el mismo señalamiento para experimentos controlados en la web. En su guía, Experimentos controlados en la web: encuesta y guía práctica, una prueba con poca potencia aparece como un error frecuente. Una división held-out de siete ítems tiene poca potencia para una tasa tan pequeña, y el capítulo lo dice en lugar de dejar que el cero pase por certeza.
En conjunto, los resultados dicen algo concreto. En la variante sin filtrar, con el umbral que elige la regla de dev, el filtro no cambia ninguna respuesta, así que este capítulo no lo añade. Ambos errores permanecen en las respuestas sin filtrar en dev. En held-out, los rechazos falsos son el costo, y nada en este capítulo los reduce. El resultado es una decisión, y es la que sostiene la medición.
Las decisiones del capítulo son estas:
- Ambas tasas de rechazo entran en cada comparación, cada una sobre su propio denominador.
- Los ítems dependientes de la versión y los ambiguos quedan fuera de ambas tasas, y sus rechazos se cuentan por separado.
- Una regla de rechazo se elige en dev, con sus pesos anotados primero, todo el barrido leído y la elección fijada antes de ejecutar held-out.
- Held-out se ejecuta una vez por regla. Un intervalo sobre cero eventos se informa con esa advertencia, no como un hallazgo de cero.
- El filtro de puntuación de recuperación no se añade a la variante sin filtrar. Su elección en dev no cambia ninguna respuesta, y su ejecución held-out tampoco cambia ninguna.
Regla práctica: Un filtro se gana su lugar solo cuando su ejecución held-out cambia respuestas en la dirección que prometió su barrido en dev. Cuando no lo hace, conserva el resultado, porque muestra qué errores tiene el asistente y que un umbral sobre la puntuación de recuperación no los corrige.
Fuera de este libro
Este capítulo no trata de ataques. Un usuario que intenta hacer que el asistente diga lo que no debe decir plantea una cuestión de seguridad, con sus propias amenazas y defensas, y para ella se prevé un libro aparte, Securing LLM Applications and Agents. Las tasas de rechazo aquí miden preguntas honestas sobre la documentación, y nada en ellas te indica cómo se comporta un asistente bajo la presión de un usuario que intenta romperlo.
Otros investigadores han medido el mismo compromiso en otros modelos, y conviene conocer sus afirmaciones sin tomar prestados sus números. XSTest es un conjunto de pruebas de instrucciones seguras que parecen inseguras. Sus autores lo construyeron porque los modelos rechazan instrucciones seguras que usan una redacción parecida a la de las inseguras, o que tocan un tema sensible (Röttger y colaboradores, 2024). OR-Bench, publicado en ICML 2025, midió muchos modelos y señala que la seguridad adicional de los modelos ajustados para seguridad a menudo vino acompañada de más rechazos excesivos (Cui y colaboradores, 2024). Un estudio sobre la abstención en modelos de lenguaje da el nombre general para el rechazo de un modelo a responder, y la organiza según la consulta, el modelo y los valores humanos (Wen y colaboradores, 2024). Un banco de pruebas de 2026 en el ámbito sanitario informa de rechazos excesivos de instrucciones benignas en ese dominio, sobre su propio conjunto de instrucciones (Zhang y colaboradores, 2026).
Estos trabajos prueban otros modelos con otros conjuntos, así que sus tasas no se trasladan a este asistente. Lo que sí se traslada es su forma, que es la afirmación que este capítulo pone a prueba en su propio caso. En este conjunto, la protección solo puede reducir las respuestas falsas al rechazar más elementos respondibles, lo que supone un intercambio de respuestas falsas por rechazos falsos. Los cambios en el prompt y en la recuperación pueden mover ambos errores, y la variante sin filtro lo hizo. Los únicos resultados que presenta este capítulo son las ejecuciones propias del libro.
Regla práctica: Antes de adoptar una regla de rechazo porque un artículo señala que los modelos rechazan en exceso, mide la regla en tu propio asistente y con tus propios elementos, contando ambos tipos de error. Deja los números del artículo fuera de tus resultados, y cita el artículo por la idea que motivó la medición.
Este capítulo, en esta edición
Edición 2026.11.3Ejemplos verificados el 21 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.3.