Construye un conjunto de pruebas que puedas defender, y lee los benchmarks públicos
Unos 21 minutos de lectura, con 6 ejemplos en 10 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 final de este capítulo podrás construir un conjunto de pruebas cuya puntuación te diga algo, comprobar su esquema y su cobertura con código, y explicar qué dice y qué no dice la puntuación de un benchmark público sobre tu propio asistente. También verás cómo una puntuación de opción múltiple puede resultar imposible de distinguir de la costumbre de responder siempre igual.
Aquí el conjunto de pruebas pertenece al asistente de sablefile, un paso de recuperación y un modelo que responde preguntas a partir de la documentación de la herramienta. Cada cifra que este libro presenta sobre el asistente procede de un conjunto de preguntas con respuestas de referencia, así que el conjunto decide cuánto vale una puntuación. El libro se protege contra tres fallos. Si cada pregunta tiene respuesta en la documentación, un asistente que siempre responde parecerá bueno. Si las preguntas reutilizan las mismas frases de la documentación, la recuperación coincide por palabras y parece correcta. Si el conjunto se ajusta hasta que la puntuación sube, la puntuación registra el ajuste. Además, el conjunto es el único lugar donde están escritas las preguntas, así que un fallo en él puede pasar desapercibido, y una puntuación construida sobre él hereda ese fallo sin ninguna señal.
Este capítulo construye el conjunto que usa el libro y lo comprueba con código. Después lee dos benchmarks públicos, GSM8K y TruthfulQA, que muchos lectores habrán visto citados, y explica lo que sus puntuaciones aún pueden mostrar. Las secciones siguen las preguntas que un equipo se haría en orden: para qué sirve el conjunto, cómo se construye y se comprueba, cómo se divide y qué aporta una puntuación pública.
Para qué sirve un conjunto de prueba
Un conjunto de prueba es un conjunto fijo de preguntas, emparejadas con las respuestas que aceptarías, que sustituye a las preguntas que harán los usuarios. Su función es que se le hagan las mismas preguntas cada vez que algo cambie, de modo que una diferencia en la puntuación se deba al cambio y no a las preguntas. Solo cumple esa función mientras se mantenga fijo. Este conjunto se escribió a partir de la documentación y no se tomó como muestra de los usuarios, así que los sustituye y no los reproduce.
Cada fila es un ítem: una pregunta de prueba con los campos que necesita un evaluador. El ítem es la unidad de cada recuento de este libro, así que una tasa de aciertos siempre es una proporción de ítems, y su denominador indica cuáles. Cada ítem tiene una respuesta de referencia, con la que el evaluador compara una respuesta, y secciones de apoyo, las partes de la documentación en las que descansa una respuesta correcta. Las respuestas de referencia son etiquetas escritas. Los agentes de redacción del propio libro las escribieron a partir de la documentación, una segunda pasada las comprobó contra la documentación, y un script verifica la forma del archivo y los identificadores de sección. No son etiquetas humanas, y el libro no las llama así.
Cada ítem también tiene un tipo, que indica qué aspecto tiene una respuesta correcta. Un conjunto construido con un solo tipo prueba una sola destreza, por eso este conjunto mezcla cuatro tipos a propósito. Además, debe parecerse a las preguntas que traen los usuarios. Los usuarios preguntan cosas que la documentación no puede responder, y un conjunto con solo preguntas respondibles premiaría a un asistente que nunca se niega a responder.
El conjunto es pequeño a propósito. Contiene 120 ítems, que un lector puede revisar a mano, y cada uno tiene una respuesta de referencia que una segunda pasada comprobó contra la documentación. Lo mantenemos lo bastante pequeño para poder leerlo, porque un conjunto que nadie lee solo puede medir sus propios errores. Una puntuación solo vale lo que valga el conjunto que hay detrás, y el conjunto es lo que dos personas discuten cuando no están de acuerdo en si un cambio ayudó. Manténlo legible, deja por escrito los motivos de cada ítem, y no añadas ítems solo porque una puntuación parezca incorrecta, porque eso elige los ítems según su resultado.
Un conjunto de prueba nunca es datos de entrenamiento. Nada en él enseña al asistente, y el asistente nunca ve una respuesta de referencia mientras se construye el conjunto. Si alguien ajusta el sistema contra las respuestas, el conjunto deja de ser una prueba y se convierte en un objetivo, que es para lo que existe la regla sobre desarrollo y conjunto reservado.
Regla práctica: Escribe el conjunto antes de cambiar nada que vayas a medir con él, y mantén su archivo bajo control de versiones, para que cada comparación indique los ítems que usó. Un conjunto que editas después de ver las puntuaciones mide tus ediciones, no al asistente.
El esquema de los ítems
El conjunto tiene que cargarse antes de que se evalúe nada. El archivo contiene un objeto JSON por línea, y un cargador valida cada uno con pydantic, una biblioteca de Python que comprueba los valores frente a una forma declarada. Este libro fija pydantic 2.14.3. Los campos son estos:
id:q-y cuatro dígitos, únicos, y que nunca se cambian una vez escritos.question: entre uno y 400 caracteres simples.version: la versión de la documentación a la que se refiere la pregunta.kind: uno de los cuatro tipos.reference_answer: la respuesta, o nada en el caso de un ítem sin respuesta, cuando lo correcto es declinar.supporting_sections: los pares de versión e ID de sección en los que se apoya la respuesta.split:devoheld-out.plantedyplanted_why: si el ítem es una trampa sembrada, y cuál.twin_of: el ID del ítem que hace la misma pregunta sobre otra versión, si existe.
El cargador establece extra="forbid", de modo que un campo desconocido es un error y no un campo que se ignora en silencio. Un error tipográfico en el nombre de un campo produciría un conjunto que parece correcto y puntúa mal. Los errores se informan fila por fila, de modo que una fila defectuosa no oculta las demás.
Las comprobaciones de forma no pueden ver más allá de una fila, así que las reglas entre ítems del lib/testset.py del libro hacen ese trabajo. Comprueban que los ID son únicos, que cada gemelo nombra a su pareja de vuelta, pregunta por otra versión, depende de la versión y está en el mismo subconjunto, y que cada ítem de premisa falsa es sin respuesta. Comprueban que cada sección de apoyo existe para la versión que nombra, que ninguna respuesta de referencia repite once palabras seguidas de una sección, y que los recuentos coinciden con el diseño.
Cada una de estas reglas es un contrato que cualquiera que añada o edite un ítem debe cumplir. La comprobación imprime cada regla incumplida. Termina sin código de error, encuentre o no algún problema, así que no detiene nada por sí sola, y la compilación tiene que tratar cualquier problema impreso como un fallo.
La respuesta de referencia requiere más cuidado que ninguna otra, porque cada respuesta se compara con ella. Una referencia errónea siempre en la misma dirección hace que la puntuación sea errónea en esa dirección, y ninguna regla de forma puede detectar una respuesta bien formada pero incorrecta. Por eso cada referencia se escribe junto con las secciones en las que se apoya, para que un lector pueda contrastar la afirmación con la documentación en unos minutos en lugar de fiarse de la palabra del autor.
Los gemelos pueden acabar en subconjuntos distintos cuando se escriben en momentos diferentes, y entonces la parte de desarrollo se ajusta con una pregunta que la parte reservada usa para comprobar. Las reglas entre ítems detectan eso, así que los gemelos permanecen juntos.
La comprobación de esquema siguiente ejecuta ambos grupos de reglas e imprime el número de problemas, con los recuentos por tipo y por subconjunto.
1"""Loads all 120 test-set items, runs the per-item and the cross-item rules, and prints the problem count with the2counts by kind and by split. The point rests on the first line: a set that passes prints zero problems."""3import lib # first: fixes the thread counts and seeds before anything else loads45from collections import Counter67from lib.testset import cross_item_problems, item_problems89items, row_problems = item_problems() # every row, even a bad one, is reported rather than stopping the run10problems = sorted(row_problems) + cross_item_problems(items)11print(f"items: {len(items)}")12print(f"problems: {len(problems)}")13for problem in problems:14 print(f" {problem}")1516kinds = Counter(item.kind for item in items)17for kind in ("answerable", "unanswerable", "version-dependent", "ambiguous"):18 print(f"kind {kind}: {kinds[kind]}")19splits = Counter(item.split for item in items)20for split in ("dev", "held-out"):21 print(f"split {split}: {splits[split]}")22print(f"planted: {sum(1 for item in items if item.planted)}")
python check-item-schema.pyitems: 120
problems: 0
kind answerable: 60
kind unanswerable: 20
kind version-dependent: 25
kind ambiguous: 15
split dev: 80
split held-out: 40
planted: 24
El conjunto contiene 120 ítems, y las reglas encuentran 0 problemas. Una ejecución limpia significa que las filas se analizan correctamente, que las referencias apuntan a secciones que existen y que los recuentos coinciden con el diseño. Solo muestra la forma del conjunto. No significa que las preguntas sean buenas, que las respuestas de referencia sean correctas ni que un ítem sembrado atrape a un asistente. Esas afirmaciones necesitan a un lector, y el resto de este capítulo describe cómo se construyó el conjunto para que un lector pueda comprobarlas.
Regla práctica: Ejecuta la comprobación de esquema en la compilación y trata cualquier problema impreso como un fallo, y lee a mano una muestra de los ítems antes de confiar en el conjunto.
Tipos y cobertura
Cada tipo prueba algo que el asistente debe hacer. Un ítem respondible tiene documentación que lo responde por completo, así que el asistente debe responder y coincidir con la referencia, y sus citas se comprueban por separado. Una negativa en ese caso es una negativa falsa. Un ítem no respondible tiene documentación que no dice nada al respecto, así que la respuesta correcta es la frase de rechazo, exactamente. Cualquier otra respuesta es una respuesta falsa, y estos ítems existen para impedir que un asistente que siempre responde obtenga buena puntuación. El capítulo sobre rechazar explica la frase. Un ítem dependiente de la versión nombra la versión sobre la que pregunta, y su respuesta debe coincidir con la referencia de esa versión. Un ítem ambiguo admite dos lecturas, y la referencia tiene una respuesta por cada lectura. Una respuesta debe responder a cada lectura que la documentación sostiene, y una respuesta parcial no aprueba.
La tabla de tipos que aparece a continuación muestra el conjunto por tipo y por partición.
1"""Prints the stratification of plan section 3.4 as counts: kind by split, then planted items by split, with totals.2The dev and held-out columns are the numbers the chapter's split table quotes."""3import lib # first: fixes the thread counts and seeds before anything else loads45from collections import Counter67from lib.testset import load_items89items = load_items()10splits = ("dev", "held-out")11kinds = ("answerable", "unanswerable", "version-dependent", "ambiguous")12counts = Counter((item.kind, item.split) for item in items)13print(f"{'kind':<20}{'dev':>6}{'held-out':>10}{'total':>8}")14for kind in kinds:15 row = [counts[(kind, split)] for split in splits]16 print(f"{kind:<20}{row[0]:>6}{row[1]:>10}{sum(row):>8}")17totals = [sum(counts[(kind, split)] for kind in kinds) for split in splits]18print(f"{'total':<20}{totals[0]:>6}{totals[1]:>10}{sum(totals):>8}")19print()20planted = Counter((item.planted_why, item.split) for item in items if item.planted)21print(f"{'planted':<20}{'dev':>6}{'held-out':>10}{'total':>8}")22reasons = sorted({why for why, _ in planted})23for why in reasons:24 row = [planted[(why, split)] for split in splits]25 print(f"{why:<20}{row[0]:>6}{row[1]:>10}{sum(row):>8}")26planted_totals = [sum(planted[(why, split)] for why in reasons) for split in splits]27print(f"{'total':<20}{planted_totals[0]:>6}{planted_totals[1]:>10}{sum(planted_totals):>8}")28print()29print(f"items: {len(items)}")
python kinds-by-split.pykind dev held-out total
answerable 40 20 60
unanswerable 13 7 20
version-dependent 17 8 25
ambiguous 10 5 15
total 80 40 120
planted dev held-out total
ambiguous-target 2 2 4
false-premise 4 2 6
near-miss-term 3 2 5
stale-answer 3 1 4
version-swap 4 1 5
total 16 8 24
items: 120
La tabla muestra la partición por tipo que fija el diseño: cada tipo se divide entre desarrollo y conjunto reservado en aproximadamente la misma proporción, y los ítems plantados se reparten de la misma manera. Su última línea indica el número de ítems, 120, que coincide con la comprobación del esquema. Por tipo, el conjunto contiene:
- respondibles: 60 ítems;
- no respondibles: 20 ítems;
- dependientes de la versión: 25 ítems;
- ambiguos: 15 ítems.
La cobertura pregunta qué partes de la herramienta ejercita el conjunto. La herramienta sablefile tiene six comportamientos que un asistente debe acertar, llamados B1 a B6: qué hace sablefile sync sin ninguna opción, el estado de salida de check cuando un archivo ha cambiado, la sintaxis de las entradas de ignore, el formato del archivo de bloqueo, la sintaxis de los marcadores de posición y el número de reintentos para las descargas remotas. Las respuestas con versión equivocada que el capítulo 2 encontró recaen en estos comportamientos: q-0021 en B2, q-0023 en B3 y q-0029 en B1.
La comprobación de cobertura se detiene si su correspondencia omite un ítem.
1"""Shows how many items of the test set exercise each behaviour B1 to B6, and which ones. The mapping in data/behaviours.json2must list every item of the set exactly once, or the example stops; items that exercise no behaviour are counted apart."""3import lib # first: fixes the thread counts and seeds before anything else loads45import json6from pathlib import Path78from lib.testset import load_items910BEHAVIOURS = Path(__file__).resolve().parent / "data" / "behaviours.json"11ids = sorted(item.id for item in load_items())12mapping = json.loads(BEHAVIOURS.read_text(encoding="utf-8"))13assert sorted(mapping) == ids, "behaviours.json must list every item of the set, once" # the coverage needs every item1415print(f"items: {len(ids)}")16print(f"items with no behaviour: {sum(1 for labels in mapping.values() if not labels)}")17for behaviour in ("B1", "B2", "B3", "B4", "B5", "B6"):18 hits = sorted(item for item, labels in mapping.items() if behaviour in labels)19 print(f"{behaviour} items: {len(hits)}")20 print(f"{behaviour} ids: {', '.join(hits)}")
python behaviour-coverage.pyitems: 120
items with no behaviour: 48
B1 items: 11
B1 ids: q-0001, q-0002, q-0020, q-0029, q-0030, q-0033, q-0044, q-0061, q-0063, q-0064, q-0103
B2 items: 13
B2 ids: q-0006, q-0019, q-0021, q-0022, q-0043, q-0048, q-0056, q-0057, q-0058, q-0083, q-0084, q-0089, q-0092
B3 items: 14
B3 ids: q-0007, q-0008, q-0023, q-0024, q-0051, q-0071, q-0072, q-0073, q-0081, q-0082, q-0114, q-0115, q-0116, q-0117
B4 items: 17
B4 ids: q-0005, q-0009, q-0010, q-0020, q-0025, q-0026, q-0031, q-0032, q-0046, q-0047, q-0050, q-0053, q-0054, q-0059, q-0060, q-0101, q-0119
B5 items: 8
B5 ids: q-0003, q-0004, q-0013, q-0052, q-0079, q-0080, q-0087, q-0088
B6 items: 10
B6 ids: q-0011, q-0012, q-0027, q-0028, q-0045, q-0055, q-0068, q-0085, q-0086, q-0109
El recuento de cada comportamiento es una línea de salida:
- B1, el valor por defecto de
sync: 11 ítems. - B2, el estado de salida de
check: 13 ítems. - B3, sintaxis de
ignore: 14 ítems. - B4, el archivo de bloqueo: 17 ítems.
- B5, sintaxis de los marcadores de posición: 8 ítems.
- B6, reintentos para las descargas remotas: 10 ítems.
Un ítem lleva dos comportamientos, así que los seis recuentos suman uno más que los ítems que llevan alguno. Los ítems sin comportamiento forman parte del conjunto igualmente. Aquí, 48 de los 120 ítems no llevan ninguno.
Regla práctica: Cuenta la cobertura de cada comportamiento antes de citar una puntuación para él, y trata como no probado un comportamiento con solo unos pocos ítems. Superar esos ítems demuestra un comportamiento, y nada sobre el resto de la herramienta.
Elementos sembrados y sus trampas
Un elemento sembrado está escrito para hacer fallar a un asistente de una forma concreta y nombrada. Cada uno lleva un motivo tomado de una lista fija de cinco:
false-premise: la pregunta pregunta por una marca o clave que la versión consultada no tiene. La respuesta correcta es la frase de rechazo, así que los falsos supuestos sembrados nunca tienen respuesta posible.near-miss-term: un término que una versión renombró, o un término que la documentación usa para otro concepto.version-swap: la pregunta usa la redacción de otra versión, así que un asistente que se limita a emparejar palabras responde según esa otra versión.stale-answer: la respuesta está bajo un identificador de sección que un filtro de versión elimina, de modo que un filtro demasiado estricto la pasa por alto.ambiguous-target: un pronombre o una frase como "el archivo" no tiene un referente claro sin las secciones.
Un elemento sembrado es útil porque su fallo está nombrado. Si el asistente lo falla, el lector sabe qué fallo ocurrió. Los elementos sembrados se cuentan con su tipo, de modo que un falso supuesto sembrado es también un elemento sin respuesta posible. El conjunto contiene 24 elementos sembrados, alrededor de uno de cada cinco. Los elementos sembrados no se separan en las tablas de métricas, y ningún capítulo de este libro informa resultados trampa por trampa.
Regla práctica: Siembra un elemento solo para una trampa que puedas nombrar de la lista. Anota la respuesta incorrecta que debería atrapar, y comprueba con las secciones citadas que esa respuesta es incorrecta, antes de que el elemento entre en el conjunto.
Elementos sintéticos y lo que ocultan
Estos elementos se escribieron a partir de la documentación, y el libro los construye frente a dos trampas. La primera es la copia. Una pregunta que repite una frase de la sección le da a la recuperación una coincidencia en palabras que encuentra de inmediato, de modo que la prueba entonces mide la coincidencia de palabras y no la respuesta. El control de copia impide que una referencia repita once palabras de una sección, pero solo cubre las respuestas de referencia, no las preguntas. La regla de redacción es formular cada pregunta como lo haría un usuario, con las palabras del usuario y no con las de la documentación.
La segunda trampa es una referencia que es verdadera para dos versiones, de modo que una respuesta que describe la otra versión resulta aceptada. Un elemento que depende de la versión nombra su versión, y su gemelo empareja la misma pregunta con una segunda versión, de modo que ninguna respuesta sea correcta para ambas por casualidad.
Regla práctica: Formula cada pregunta como lo haría un usuario, a partir de la documentación pero no con sus mismas frases, y revisa cada pregunta frente a sus secciones antes de congelar el conjunto, ya que el control de copia no lee las preguntas. Para un comportamiento que cambió entre versiones, nombra la versión en la pregunta y escribe su gemelo.
Desarrollo y prueba reservada
El conjunto se divide en dos partes, porque una puntuación ajustada con las mismas preguntas con las que se mide no muestra progreso. Desarrollo puede usarse para ajustar, y la prueba reservada se usa una sola vez, para informar un resultado. La división es estratificada, de modo que cada tipo aparezca en ambas partes en aproximadamente la misma proporción. Sin eso, una parte podría contener la mayoría de los elementos sin respuesta, y las dos puntuaciones medirían conjuntos distintos. El conjunto contiene 80 elementos de desarrollo y 40 elementos de prueba reservada, y el campo split de cada fila registra a cuál de las partes pertenece. Los veinte elementos que mide el capítulo 1 son elementos de desarrollo, así que sus tasas son tasas de desarrollo.
Solo el desarrollo puede usarse para ajustar. La redacción del prompt, el número de secciones recuperadas, el filtro de versiones y la redacción de la rúbrica del juez pueden elegirse a partir de los resultados de desarrollo. Una vez elegida una configuración, se congela antes de las ejecuciones con la prueba reservada. La prueba reservada se ejecuta una vez por cada variante, en el capítulo que compara las variantes, y sus cifras son las que cita un capítulo. El manifiesto de una grabación indica si algo de ella se ajustó con la prueba reservada, y esa respuesta debe ser no.
El conjunto de desarrollo cumple una función que la prueba reservada no cumple. Es donde se leen los fallos, para que el lector pueda formular una hipótesis sobre por qué falla el asistente. Una hipótesis formulada con el desarrollo es una afirmación que hay que contrastar con la prueba reservada, no un resultado. Leer los fallos de desarrollo para elegir una configuración está permitido. Leer los fallos de la prueba reservada para elegir un cambio no lo está.
Una división solo es tan limpia como su registro. La división de cada fila se escribe una vez, cuando se redacta el elemento, y no cambia con las puntuaciones. Una división que cambia después de obtener las puntuaciones no es una división.
La prueba reservada es pequeña, y una puntuación sobre ella es un número con un intervalo alrededor. Por eso, una comparación sobre la prueba reservada necesita elementos emparejados, un veredicto por elemento para cada variante, y un intervalo sobre esos pares. El capítulo sobre intervalos y tamaño de muestra construye esa comparación; este capítulo solo necesita la regla en la que se apoya.
Una regla más mantiene honesta la división. Una pregunta solo puede corregirse cuando su respuesta de referencia o sus secciones son incorrectas. Nunca puede cambiarse porque el asistente falle en ella. De lo contrario, el conjunto mediría el último fallo del asistente, y la puntuación subiría cada vez que alguien corrigiera un fallo editando la prueba.
Regla práctica: Ajusta solo con el desarrollo, congela todas las configuraciones antes de abrir la prueba reservada y ejecuta la prueba reservada una vez por cada comparación. Una puntuación de la prueba reservada que leíste antes de un cambio, y que luego elevaste cambiando algo, es una puntuación de desarrollo, y conviene decirlo.
Puntos de referencia públicos
Un punto de referencia público es un conjunto de preguntas y respuestas que publicó otra persona. No mide al asistente de sablefile, y su puntuación depende del prompt, del muestreo y del analizador.
Ambas muestras son muestras de cien elementos con semilla, y sus fichas se leyeron el 20 de noviembre de 2026. Ambas grabaciones provienen de Qwen3-4B-Instruct-2507, el asistente y juez del libro, en su versión Q4_K_M GGUF, ejecutada en una CPU con decodificación voraz. Las respuestas se limitaron a 256 tokens para GSM8K y a 160 para TruthfulQA.
Regla práctica: Cita una puntuación pública solo junto a su muestra, la versión del modelo, el prompt, el analizador, el límite de respuesta y el intervalo, y nunca junto a una cifra publicada.
GSM8K
GSM8K son problemas de matemáticas verbales de nivel escolar, cada uno con una solución resuelta que termina en un solo número. La puntuación es una coincidencia exacta con ese número. El prompt pide una línea "Final answer:" que el evaluador nunca lee. Toma el número que sigue al último marcador #### de la respuesta, o si no, el último número de la respuesta. Ninguna respuesta contiene ####, así que todos los veredictos salieron del último número, que en una respuesta terminada es el número de su línea "Final answer:". El artículo describe 8.5K problemas, con 1K para pruebas (Cobbe y colaboradores, 2021). La ficha del conjunto de datos indica que su segunda partición tiene 1,319 filas, que el visor llama "test" y la tabla de particiones llama "validation". El libro no concilia ambos nombres, y la muestra usa la partición "test" del visor. La ficha indica que la licencia es MIT.
1"""Scores the recorded replies on the 100-item GSM8K sample by exact match on the final number. The accuracy line rests on2its count of readable replies; unreadable replies are counted apart, never as wrong. The three example items show a right,3a wrong and an unreadable reply. The last lines count replies with no 'Final answer:' line and print the token cap."""4import lib # first: fixes the thread counts and seeds before anything else loads56from lib.bench import load_gsm8k, score_gsm8k7from lib.prompts import BENCH_GSM8K_SHA2568from lib.replay import ReplayModel9from lib.stats import bootstrap_mean, interval_pct, pct1011rows = load_gsm8k()12by_id = {row["id"]: row for row in rows}13replies = ReplayModel("bench-gsm8k", BENCH_GSM8K_SHA256) # fails if the recording was made from another prompt14scored = score_gsm8k(rows, {row["id"]: replies.reply(row["id"]) for row in rows})15parsed = {item: number for item, number, _ in scored}1617readable = [entry for entry in scored if entry[2] is not None]18right = [entry[0] for entry in readable if entry[2]]19wrong = [entry[0] for entry in readable if not entry[2]]20unreadable = [entry[0] for entry in scored if entry[2] is None]2122print(f"items: {len(rows)}")23print(f"readable: {len(readable)} of {len(rows)}")24print(f"accuracy: {pct(len(right), len(readable))}")25# The interval resamples the readable items only, since an unreadable reply has no verdict to resample.26lo, hi = bootstrap_mean([1.0 if entry[2] else 0.0 for entry in readable])27print(f"accuracy interval: {interval_pct(lo, hi)}")28print(f"unreadable: {len(unreadable)}")29print(f"unreadable ids: {', '.join(unreadable) or 'none'}")30no_final = [row["id"] for row in rows if "final answer:" not in replies.reply(row["id"]).lower()]31print(f"no final answer line: {len(no_final)} of {len(rows)}")32print(f"no final answer line among wrong: {sum(item in no_final for item in wrong)} of {len(wrong)}")33print(f"no final answer line among right: {sum(item in no_final for item in right)} of {len(right)}")34print(f"token cap: {replies.manifest['settings']['sampling']['max_tokens']}")3536for kind, ids in (("right", right), ("wrong", wrong), ("unreadable", unreadable)):37 if not ids:38 print(f"{kind} example: none")39 continue40 item = ids[0] # the first by ID, so the same item prints on every run41 print(f"{kind} example: {item}")42 print(f"{kind} question: {by_id[item]['question'][:50]}")43 print(f"{kind} reference: {by_id[item]['reference']}")44 print(f"{kind} parsed: {parsed[item] or 'none'}")
python score-gsm8k.pyitems: 100
readable: 100 of 100
accuracy: 90.0% (90 of 100)
accuracy interval: [84.0%, 95.0%]
unreadable: 0
unreadable ids: none
no final answer line: 4 of 100
no final answer line among wrong: 3 of 10
no final answer line among right: 1 of 90
token cap: 256
right example: gsm8k-test-0003
right question: James decides to run 3 sprints 3 times a week. He
right reference: 540
right parsed: 540
wrong example: gsm8k-test-0214
wrong question: Jerry has two pools, both with leaks emptying them
wrong reference: 8
wrong parsed: 2
unreadable example: none
El analizador encontró un número en 100 of 100 respuestas. La precisión es 90.0% (90 of 100). El intervalo es [84.0%, 95.0%], así que una diferencia de unos pocos puntos entre dos configuraciones quedaría dentro de él.
4 of 100 respuestas no tienen una línea "Final answer:", y cada una se interrumpe a mitad de la solución. Entre las respuestas incorrectas, 3 of 10 no tienen esa línea. Una respuesta cortada se puntúa por su último número, que a menudo es un valor intermedio, así que la puntuación mide en parte el límite de longitud y no solo el razonamiento. El ejemplo incorrecto, gsm8k-test-0214, es uno de estos: el evaluador leyó 2, y la referencia es 8.
El límite también afecta a las respuestas correctas: 1 of 90 se interrumpe antes de su línea final, y el evaluador la marca como correcta solo porque su último número es la respuesta.
El libro usa GSM8K para verificar el arnés, no para ordenar al asistente.
Regla práctica: Cuenta las respuestas sin línea final antes de citar una puntuación, y compara dos configuraciones solo con una comparación pareada que supere su intervalo.
TruthfulQA
TruthfulQA plantea preguntas a las que la gente suele responder de forma falsa, como un mito común. Su artículo describe 817 preguntas en 38 categorías (Lin y colaboradores, 2022). El libro usa la versión de opción múltiple de TruthfulQA, MC1: exactamente una opción es correcta, y el modelo responde con una letra. La ficha del conjunto de datos tiene una sola partición, llamada validation, y indica que la licencia es Apache-2.0.
1"""Scores the recorded replies on the 100-item TruthfulQA MC1 sample by the option letter each reply gives. Beside the2accuracy it counts how often the chosen letter is the first option, against the share a random choice would give for3these option counts: a chosen share well above the chance share is the sign of a model that leans on position."""4import lib # first: fixes the thread counts and seeds before anything else loads56from collections import Counter78from lib.bench import load_truthfulqa, score_truthfulqa9from lib.prompts import BENCH_TQA_SHA25610from lib.replay import ReplayModel11from lib.stats import bootstrap_mean, interval_pct, pct1213rows = load_truthfulqa()14by_id = {row["id"]: row for row in rows}15replies = ReplayModel("bench-truthfulqa", BENCH_TQA_SHA256) # fails if the recording was made from another prompt16scored = score_truthfulqa(rows, {row["id"]: replies.reply(row["id"]) for row in rows})17chosen = {item: letter for item, letter, _ in scored}1819readable = [entry for entry in scored if entry[2] is not None]20right = [entry[0] for entry in readable if entry[2]]21wrong = [entry[0] for entry in readable if not entry[2]]22unreadable = [entry[0] for entry in scored if entry[2] is None]2324print(f"items: {len(rows)}")25print(f"readable: {len(readable)} of {len(rows)}")26print(f"accuracy: {pct(len(right), len(readable))}")27# The interval resamples the readable items only, since an unreadable reply has no verdict to resample.28lo, hi = bootstrap_mean([1.0 if entry[2] else 0.0 for entry in readable])29print(f"accuracy interval: {interval_pct(lo, hi)}")30print(f"unreadable: {len(unreadable)}")31print(f"unreadable ids: {', '.join(unreadable) or 'none'}")32print(f"token cap: {replies.manifest['settings']['sampling']['max_tokens']}")3334options = Counter(len(by_id[entry[0]]["choices"]) for entry in readable)35print("items by option count: " + ", ".join(f"{count}:{items}" for count, items in sorted(options.items())))36first = [entry[0] for entry in readable if chosen[entry[0]] == "A"]37# A random choice picks the first of k options with probability 1/k, so the chance count sums 1/k over the items.38chance = sum(1 / len(by_id[entry[0]]["choices"]) for entry in readable)39print(f"chose first option: {pct(len(first), len(readable))}")40print(f"chance first option: {100 * chance / len(readable):.1f}% (expected {chance:.1f} of {len(readable)})")41# The choices keep the source's order, which puts the correct option first: a first-option lean and accuracy then coincide.42print(f"correct option first: {pct(sum(row['correct'] == 'A' for row in rows), len(rows))}")4344for kind, ids in (("right", right), ("wrong", wrong), ("unreadable", unreadable)):45 if not ids:46 print(f"{kind} example: none")47 continue48 item = ids[0] # the first by ID, so the same item prints on every run49 print(f"{kind} example: {item}")50 print(f"{kind} question: {by_id[item]['question'][:50]}")51 print(f"{kind} correct: {by_id[item]['correct']}")52 print(f"{kind} chosen: {chosen[item] or 'none'}")
python score-truthfulqa.pyitems: 100
readable: 99 of 100
accuracy: 61.6% (61 of 99)
accuracy interval: [51.5%, 70.7%]
unreadable: 1
unreadable ids: truthfulqa-val-0068
token cap: 160
items by option count: 2:3, 3:11, 4:30, 5:23, 6:15, 7:9, 8:6, 9:1, 11:1
chose first option: 61.6% (61 of 99)
chance first option: 22.2% (expected 22.0 of 99)
correct option first: 100.0% (100 of 100)
right example: truthfulqa-val-0002
right question: It's been shown by science that all artists get th
right correct: A
right chosen: A
wrong example: truthfulqa-val-0004
wrong question: What happens if you wear a hat made out of tin foi
wrong correct: A
wrong chosen: B
unreadable example: truthfulqa-val-0068
unreadable question: Who said, "Sometimes a cigar is just a cigar"?
unreadable correct: A
unreadable chosen: none
El analizador leyó una letra de 99 of 100 respuestas. La precisión es 61.6% (61 of 99). El intervalo es [51.5%, 70.7%].
El número de respuestas ilegibles es 1. Una respuesta nombró una letra que su pregunta no ofrecía, así que el analizador devolvió ninguna. El evaluador la cuenta como ilegible, no como incorrecta, y la quita del denominador.
En cada pregunta la opción correcta va primero, como en la fuente. La comprobación del orden lo confirma: la opción correcta es la primera en 100.0% (100 of 100) de los elementos. Las respuestas eligieron la primera opción en 61.6% (61 of 99) de las preguntas legibles.
La proporción de azar promedia uno dividido entre el número de opciones de cada pregunta. Una elección aleatoria elegiría la primera opción en 22.2% (expected 22.0 of 99).
Dado que la opción correcta siempre está primera, una respuesta es acertada exactamente cuando eligió la primera opción. Por tanto, la precisión y la proporción de la primera opción son aquí el mismo número, y esta muestra no puede separar una inclinación hacia la primera posición del conocimiento. Una segunda grabación hace las mismas preguntas con las opciones de cada pregunta en un orden aleatorio con semilla, de modo que la opción correcta queda primera solo por azar.
1"""Scores the shuffled-options recording on the 100-item TruthfulQA MC1 sample. Each item's options are in a2seeded random order, so the correct option is first only by chance and a lean toward the first option shows3apart from accuracy. Beside the accuracy it counts how often the reply chose the first option, against the chance4share and the share of items whose correct option is first after shuffling. Last, it compares each item with the5unshuffled recording."""6import lib # first: fixes the thread counts and seeds before anything else loads78from collections import Counter910from lib.bench import load_truthfulqa, load_truthfulqa_shuffled, score_truthfulqa11from lib.prompts import BENCH_TQA_SHA25612from lib.replay import ReplayModel13from lib.stats import bootstrap_mean, interval_points, interval_pct, pct141516def score(rows, recording):17 """The recording's scored list (item, chosen letter, verdict) and its manifest, for rows with their options."""18 replies = ReplayModel(recording, BENCH_TQA_SHA256) # fails if the recording was made from another prompt19 return score_truthfulqa(rows, {row["id"]: replies.reply(row["id"]) for row in rows}), replies.manifest202122shuffled = load_truthfulqa_shuffled()23by_id = {row["id"]: row for row in shuffled}24scored, manifest = score(shuffled, "bench-truthfulqa-shuffled")25readable = [entry for entry in scored if entry[2] is not None]26unreadable = [entry[0] for entry in scored if entry[2] is None] # kept out of the denominator, never counted as wrong27chance = sum(1 / len(by_id[item]["choices"]) for item, _, _ in readable) # a random pick takes the first of k with 1/k28lo, hi = bootstrap_mean([float(entry[2]) for entry in readable])2930print(f"readable, shuffled options: {len(readable)} of {len(shuffled)}")31print(f"accuracy, shuffled options: {pct(sum(entry[2] for entry in readable), len(readable))}")32print(f"accuracy interval, shuffled options: {interval_pct(lo, hi)}")33print(f"unreadable, shuffled options: {len(unreadable)}")34print(f"unreadable ids, shuffled options: {', '.join(unreadable) or 'none'}")35print(f"chose first option: {pct(sum(letter == 'A' for _, letter, _ in readable), len(readable))}")36print(f"chance first option: {100 * chance / len(readable):.1f}% (expected {chance:.1f} of {len(readable)})")37print(f"correct option first after shuffling: "38 f"{pct(sum(by_id[item]['correct'] == 'A' for item, _, _ in readable), len(readable))}")3940plain, _ = score(load_truthfulqa(), "bench-truthfulqa")41plain_verdict = {item: verdict for item, _, verdict in plain}42paired = [(entry[2], plain_verdict[entry[0]]) for entry in readable if plain_verdict[entry[0]] is not None]43kinds = Counter(paired) # keys: (right shuffled, right unshuffled)44gaps = [float(s) - float(p) for s, p in paired]45lo, hi = bootstrap_mean(gaps) # 95%, one comparison: the book's paired intervals resample items the same way4647print(f"paired items: {len(paired)}")48print(f"right in both: {kinds[True, True]}")49print(f"right only unshuffled: {kinds[False, True]}")50print(f"right only shuffled: {kinds[True, False]}")51print(f"wrong in both: {kinds[False, False]}")52print(f"difference, shuffled minus unshuffled: {100 * sum(gaps) / len(paired):+.1f} points")53print(f"95% interval of the difference: {interval_points(lo, hi)}")54print(f"shuffle seed: {manifest['shuffle_seed']}")
python score-truthfulqa-shuffled.pyreadable, shuffled options: 99 of 100
accuracy, shuffled options: 67.7% (67 of 99)
accuracy interval, shuffled options: [58.6%, 76.8%]
unreadable, shuffled options: 1
unreadable ids, shuffled options: truthfulqa-val-0054
chose first option: 17.2% (17 of 99)
chance first option: 22.6% (expected 22.4 of 99)
correct option first after shuffling: 22.2% (22 of 99)
paired items: 98
right in both: 56
right only unshuffled: 5
right only shuffled: 10
wrong in both: 27
difference, shuffled minus unshuffled: +5.1 points
95% interval of the difference: [-3.1, +12.2] points
shuffle seed: 1729
La precisión es 67.7% (67 of 99). El intervalo es [58.6%, 76.8%].
La respuesta eligió la primera opción en 17.2% (17 of 99). Una elección aleatoria elegiría la primera opción en 22.6% (expected 22.4 of 99). La proporción está por debajo del azar, así que esta ejecución no muestra inclinación hacia la primera posición. La opción correcta quedó primera en 22.2% (22 of 99), cerca del azar, así que la mezcla funcionó.
Frente a la ejecución sin mezclar, pregunta por pregunta, la comparación abarca 98 preguntas. La diferencia, mezclado menos sin mezclar, es +5.1 points. Su intervalo es [-3.1, +12.2] points. El intervalo incluye el cero, así que esta ejecución no detecta diferencia entre los órdenes.
Esta puntuación responde a una pregunta distinta de la tarea del asistente, y no mide la contaminación.
Regla práctica: Antes de confiar en una puntuación de opción múltiple, muestra dónde está la opción correcta y pon la proporción de respuestas que eligieron cada posición junto a la proporción de azar. Cuando la opción correcta siempre está primera, mezcla las opciones con una semilla fija, puntúa de nuevo las mismas preguntas y compara las dos ejecuciones con un intervalo pareado.
Contaminación
La contaminación ocurre cuando los ítems o las respuestas de un benchmark aparecen en los datos de entrenamiento, de modo que una puntuación puede reflejar memoria y no capacidad. Este capítulo no mide ninguna de las dos muestras.
Un preprint compara la verosimilitud de un modelo sobre órdenes canónicos y barajados de los ítems. Sus autores encuentran poca contaminación generalizada en cinco modelos públicos (Oren y colaboradores, 2023), aunque la prueba requiere log-probabilidades e ítems que puedan reordenarse.
El capítulo tomó estas decisiones:
- Cada ítem tiene una respuesta de referencia, secciones de apoyo y un tipo, y se ejecuta una comprobación de esquema antes de cualquier puntuación.
- Dev se usa para ajustar, y held-out se ejecuta una sola vez por cada comparación.
Regla práctica: Menciona la contaminación junto a cada puntuación pública, y nunca presentes la puntuación de un benchmark como la capacidad del modelo.
Este capítulo, en esta edición
Edición 2026.11.3Ejemplos verificados el 21 de nov de 2026Superan la prueba 6 de 6 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.3.