Pon la evaluación en CI y compara variantes con tráfico real
Unos 19 minutos de lectura, con 4 ejemplos en 5 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.3. Lee el original
Al final de este capítulo podrás poner la evaluación en una puerta de control que bloquee un cambio solo cuando el cambio sea mediblemente peor. También podrás decir qué puede mostrar una comparación en vivo de dos variantes, y qué no puede mostrar.
El asistente de sablefile responde a partir de la documentación de la herramienta, y un equipo cambia su prompt, su recuperación o su modelo de una semana a otra. El equipo quiere saber, antes de fusionar un cambio, si el asistente empeoró. Una puerta que falla ante cualquier caída en la tasa de aprobados parece la opción segura, y no lo es. Con 80 elementos de desarrollo, un solo elemento mueve una tasa de aprobados unos 1.3 puntos, así que una puerta basada en las tasas brutas bloquearía por una diferencia de uno o dos elementos. Un equipo bloqueado por el ruido suele acabar aprendiendo a saltarse la puerta, y entonces la puerta no protege nada.
Capítulo 1 ejecutó por primera vez la evaluación completa: el conjunto de pruebas, las comprobaciones, el juez y las respuestas reproducidas. Este capítulo mantiene esa ejecución tal como está. Recorre tres partes por orden: una puerta que respeta el intervalo, los elementos cuyos veredictos cambian entre muestras, y las pruebas del propio código de la evaluación. Después relaciona esas mismas partes con los términos de un marco de evaluación, y termina con lo que una comparación de variantes con tráfico real puede y no puede mostrar.
Una puerta que respeta el intervalo
Una puerta es una regla que impide que un cambio se fusione. En este libro, la regla se apoya en un solo número: la diferencia pareada en la tasa de aciertos entre un candidato y la línea base, sobre los mismos ítems de desarrollo. La comparación es pareada, tal como la define el Capítulo 8. Para cada ítem, el veredicto del candidato menos el veredicto de la línea base, promediado sobre los ítems, con el intervalo calculado por bootstrap sobre los ítems. Como ambas ejecuciones responden las mismas preguntas, los ítems en los que coinciden ambas ejecuciones se cancelan en la diferencia.
La puerta tiene una sola regla. Falla solo cuando el límite superior del intervalo está por debajo de menos el umbral. El límite superior es la lectura menos negativa que los datos todavía permiten, así que la puerta falla cuando incluso la lectura más optimista de los datos muestra una caída mayor que el umbral. Una puerta ingenua fallaría siempre que la estimación puntual de la diferencia estuviera por debajo de menos el umbral, y fallaría por ruido. El precio de la regla del libro es que deja pasar algunas caídas reales que los datos todavía no pueden demostrar, por eso un resultado de aprobado se lee junto con su amplitud, como explican los párrafos siguientes.
El umbral son cinco puntos. El comentario del ejemplo dice que es una elección para este libro, no un estándar. Con el conjunto de desarrollo de este tamaño, un ítem equivale a unos 1.3 puntos, así que cinco puntos son cuatro ítems netos.
La primera ejecución muestra una caída grande, según mide este juez. El segundo modelo, Qwen3-0.6B, es más pequeño que la línea base de 4B, y respondió los mismos ítems de desarrollo. El juez es Qwen3-4B-Instruct-2507, el propio modelo de la línea base, así que la brecha no puede separar a un asistente más débil de la autopreferencia. La autopreferencia explica por qué este libro no puede probar eso. Lee la decisión al final, ya que se deriva del intervalo.
1"""Runs the gate on second-model against the baseline over the eighty dev items: both pass rates with their counts, the paired2difference, its interval, the threshold and the decision. The gate fails only when the upper bound of the interval is below3minus the threshold, so a drop that the interval cannot rule out below the threshold does not fail it."""4import lib # first: fixes the thread counts and seeds before anything else loads56from lib.calibration import readable_verdicts7from lib.gate import FAIL, gate8from lib.judging import passed9from lib.prompts import REF_SHA25610from lib.stats import interval_points, pct11from lib.testset import load_items1213BASELINE = "judge-answers-baseline"14CANDIDATE = "judge-answers-second-model"15# Five points is this gate's threshold, chosen for the book, not a standard. With eighty dev items one item moves a rate16# by 1.25 points, so five points is four items net: a smaller threshold would ask the gate to see drops the interval17# cannot resolve at this size.18THRESHOLD_POINTS = 5.01920items = [item.id for item in load_items(split="dev")] # eighty dev items, sorted by id21baseline_found, baseline_unreadable = readable_verdicts(BASELINE, items, REF_SHA256)22candidate_found, candidate_unreadable = readable_verdicts(CANDIDATE, items, REF_SHA256)23for label, unreadable in (("baseline", baseline_unreadable), ("second-model", candidate_unreadable)):24 details = "".join(f' ({item_id}, "{first}")' for item_id, first in unreadable)25 print(f"unreadable verdicts, {label}: {len(unreadable)}{details}")26# An item the judge did not give a readable verdict on, under either run, is left out of both sides: a paired27# difference needs the same items under both runs.28excluded = {item_id for item_id, _ in baseline_unreadable + candidate_unreadable}29kept = [item_id for item_id in items if item_id not in excluded]30first = passed({item_id: baseline_found[item_id] for item_id in kept}) # 1.0 or 0.0 per item, in id order31second = passed({item_id: candidate_found[item_id] for item_id in kept})3233result = gate(first, second, threshold_points=THRESHOLD_POINTS)34print(f"dev items compared (n): {result.n}")35print(f"baseline pass rate: {pct(int(first.sum()), result.n)}")36print(f"second-model pass rate: {pct(int(second.sum()), result.n)}")37print(f"difference, second-model minus baseline: {100 * result.difference:+.1f} points")38print(f"{100 * result.level:.0f}% interval of the difference: {interval_points(result.lo, result.hi)}")39print(f"upper bound of the interval: {100 * result.hi:+.1f} points")40print(f"threshold: {THRESHOLD_POINTS:.1f} points")41if result.decision == FAIL:42 print(f"decision: fail, since the upper bound {100 * result.hi:+.1f} is below {-THRESHOLD_POINTS:+.1f}")43else:44 print(f"decision: pass, since the upper bound {100 * result.hi:+.1f} is not below {-THRESHOLD_POINTS:+.1f}")
python gate-real-drop.pyunreadable verdicts, baseline: 1 (q-0043, "VERDICT: PARTIAL")
unreadable verdicts, second-model: 0
dev items compared (n): 79
baseline pass rate: 78.5% (62 of 79)
second-model pass rate: 40.5% (32 of 79)
difference, second-model minus baseline: -38.0 points
95% interval of the difference: [-48.1, -26.6] points
upper bound of the interval: -26.6 points
threshold: 5.0 points
decision: fail, since the upper bound -26.6 is below -5.0
La puerta falla, y la razón está en el intervalo, no en las estimaciones puntuales. La línea base aprueba 78.5% (62 of 79). El segundo modelo aprueba 40.5% (32 of 79).
La comparación abarca 79 ítems, no todos los ítems de desarrollo, porque un ítem cuyo veredicto de la línea base no era legible se deja fuera de ambas ejecuciones. Una diferencia pareada necesita los mismos ítems en ambas. La diferencia, segundo modelo menos línea base, es -38.0 points, y su intervalo del 95% es [-48.1, -26.6] points.
El límite superior es -26.6 points, y el umbral es 5.0 points, así que incluso el límite superior queda muy por debajo del umbral. Esta caída no es una que el intervalo pueda explicar, así que la puerta está diseñada para fallar ante una caída de este tipo, según mide este juez. La decisión dice: fail, since the upper bound -26.6 is below -5.0.
Un cambio menor da un resultado distinto. Supón que el cambio reduce la tasa de aciertos en menos, o que el conjunto es más pequeño y el intervalo se amplía, de modo que el límite superior llega por encima de menos cinco puntos. Entonces la puerta aprueba. No ha encontrado ninguna caída mayor que el umbral, y no ha demostrado que el candidato sea tan bueno como la línea base. Un resultado de aprobado con un intervalo amplio es un aprobado débil, así que la amplitud del intervalo es la razón para leerlo, no solo la decisión. Cuánto se amplía un intervalo para un tamaño dado, y cuántos ítems necesita una diferencia pareada pequeña para resolverse, es lo que trabaja el Capítulo 8.
El límite de la puerta es su tamaño. Con 79 ítems, el límite superior tiene que caer muy por debajo de menos el umbral antes de que la puerta falle, así que las caídas pequeñas pasan. El Capítulo 8 estima, con el desacuerdo que supone, que 79 ítems bastan para mostrar una diferencia de diez puntos con un 80% de potencia, y una diferencia de cinco puntos necesita 316. La puerta es una prueba más estricta que ese cálculo de potencia, así que una caída real de diez puntos todavía puede pasar. El umbral y el tamaño del conjunto deben elegirse juntos.
Algunas puertas revisan más de una métrica. Cada métrica adicional es otra oportunidad para que el ruido parezca una caída, así que la puerta tiene en cuenta el número de comparaciones. Con m métricas, cada intervalo se calcula al nivel 1 menos 0.05 dividido entre m: 97.5% para dos métricas y alrededor de 98.3% para tres. En conjunto, las comprobaciones mantienen la probabilidad de un fallo falso en o por debajo del cinco por ciento. El nivel ajustado es el que da el Capítulo 8, y la puerta usa el mismo. El número de remuestreos se mantiene en 2,000, y la semilla queda fija, de modo que una nueva ejecución da el mismo intervalo.
La puerta se ejecuta sobre los ítems de desarrollo en cada cambio, porque una puerta tiene que ejecutarse cada vez y el equipo puede haber ajustado con esos ítems. El conjunto de held-out se ejecuta una sola vez por decisión de publicación, contra reglas fijadas antes de la ejecución, como explica Held-out, una vez. Después de eso hace falta un conjunto held-out nuevo.
Para incorporar la puerta en la CI, un trabajo calcula la puerta sobre el registro del candidato y falla la compilación cuando la decisión es fail. La puerta lee solo los valores por ítem, así que el trabajo no necesita ningún otro estado. Un trabajo que no logra ejecutarse cuenta como puerta fallida, porque una puerta omitida parecería un aprobado. Las pruebas de la propia puerta comprueban la regla anterior. Se ejecutan junto con el resto de las pruebas de la evaluación en las pruebas propias de la evaluación.
Regla práctica: Informa cada diferencia pareada con su intervalo y su n, y deja que la decisión se derive del límite superior. No califiques un cambio como mejor o peor a partir de una estimación puntual, y no leas un aprobado con un intervalo amplio como prueba de que el candidato iguala a la línea base.
Marcar los ítems inestables, nunca editarlos
Un ítem cambia cuando sus respuestas muestreadas reciben veredictos distintos. Cada ítem de desarrollo tiene cinco veredictos del conjunto de varianza, y un ítem es inestable cuando no son todos iguales. El conjunto de varianza y la tasa de cambios, es decir, la proporción de ítems que cambian, se presentan en Varianza dentro de un mismo ítem. Un equipo vigila la tasa de cambios para ver cuánto se mueven los veredictos cuando se mueven las respuestas del asistente.
Cada ítem marcado viene con su recuento de APROBADO sobre cinco, en orden de id, y la regla a la que se somete aparece impresa junto a la lista.
1"""The dev items flagged as flaky: the judge's verdict differs across their five variance samples. Each flagged item prints its2PASS count out of five, sorted by id, and the count matches the flip rate in flip-rate.py, since both read the same per-item3counts. A flagged item is kept as it is, so the rule printed last is the whole policy: flagged, never edited or deleted."""4import lib # first: fixes the thread counts and seeds before anything else loads56from lib.testset import load_items7from lib.variance import VARIANCE_SAMPLES, item_pass_counts89VARIANCE = "judge-answers-variance"10SAMPLES = len(VARIANCE_SAMPLES)1112items = [item.id for item in load_items(split="dev")] # eighty dev items, sorted by id13counts = item_pass_counts(VARIANCE, items)14for row in counts:15 if not row.complete: # an unreadable sample is not a FAIL: the item is named here and not flagged16 samples = ", ".join(str(sample) for sample in row.unreadable)17 print(f"left out, unreadable verdict, {row.item_id}: samples {samples}")18flagged = [row for row in counts if row.flaky]19for row in flagged:20 print(f"{row.item_id}: {row.passes} of {SAMPLES} PASS")21print(f"flagged items: {len(flagged)}")22print(f"dev items compared (n): {sum(1 for row in counts if row.complete)}")23print("rule: flagged, never edited or deleted")
python flaky-items.pyleft out, unreadable verdict, q-0043: samples 1, 4
q-0047: 4 of 5 PASS
q-0058: 1 of 5 PASS
flagged items: 2
dev items compared (n): 79
rule: flagged, never edited or deleted
Pocos ítems cambian en este conjunto. Los ítems marcados suman 2 de los 79 ítems de desarrollo comparados. Vale la pena leer los dos ítems marcados.
En q-0047, los veredictos de sus cinco respuestas son 4 of 5 PASS, así que la mayoría de sus respuestas aprobaron. En q-0058, los veredictos son 1 of 5 PASS, así que la mayoría de sus respuestas fallaron.
Un ítem se deja de lado en lugar de usarse. El ítem q-0043 queda fuera, ya que su veredicto no se pudo leer en samples 1, 4. Una muestra ilegible no es un fallo. Es una muestra que el ejemplo no puede leer, así que el ítem no se marca ni se cuenta por ese motivo.
La regla es que un ítem marcado sigue marcado, nunca se edita ni se borra. Permanece en el conjunto con los veredictos que dio el juez. Editarlo hasta que el juez coincida más a menudo ocultaría justamente la señal que la marca existe para mostrar. Borrarlo reduciría el conjunto y haría que la tasa de aprobados pareciera más estable de lo que es. La marca cumple su función cuando alguien la lee. Un ítem marcado con un solo APROBADO de cinco es una pregunta sobre el ítem, la rúbrica, el juez o las respuestas del asistente, y conviene revisarlo antes de juzgar sobre él el siguiente cambio.
El recuento es pequeño y describe a este asistente, este juez y estos ítems de desarrollo. Muestra que pocos ítems cambian en este conjunto. No muestra que otros asistentes, otros ajustes de muestreo u otros jueces cambien con tan poca frecuencia. Un equipo que cambie cualquiera de ellos debe volver a ejecutar el conjunto de varianza antes de confiar en una tasa de cambios baja.
Un ítem marcado también puede modificar una diferencia pareada de una ejecución a otra. Cuando una puerta falla por una diferencia que depende de un ítem marcado, lee la marca antes del cambio.
Regla práctica: Marca un ítem cuyos veredictos difieran entre sus muestras, imprime su recuento junto a la marca y deja el ítem como está. Informa de la tasa de cambios con su denominador, y di que una tasa baja vale solo para este asistente, este juez y este conjunto.
Las pruebas propias de la evaluación
La evaluación es código, y su código puede contener errores de maneras que parecen un resultado. Un error en el bootstrap, en el lector de veredictos o en la diferencia pareada mueve un número de la misma forma en que lo haría un cambio en el asistente. Por eso la evaluación tiene pruebas propias, en una carpeta de pruebas dentro de la biblioteca del libro, y cada módulo que el libro añade trae sus pruebas consigo. Las pruebas revisan el código de puntuación. No revisan al asistente. Una prueba que pasa dice que el código cuenta lo que dice que cuenta. No dice nada sobre si el asistente responde bien.
Esas pruebas se ejecutan en un solo proceso, y los resultados se cuentan módulo por módulo. El ejemplo imprime después el código de salida de pytest, de 9.2.0. La referencia de códigos de salida indica que 0 significa que todas las pruebas se recogieron y pasaron, y que 5 significa que no se recogió ninguna prueba. Así, una ejecución que no prueba nada aparece como 5, no como un éxito silencioso.
1"""Runs the book's own tests, lib/tests, in this process and prints how many passed and failed in each module, then pytest's2exit code. Exit code 0 means every test was collected and passed. Exit code 5 means nothing was collected, so the example3prints the code it got rather than a silent pass. No paths and no timings are printed: they vary from run to run."""4import lib # first: fixes the thread counts and seeds before anything else loads56from collections import Counter7from pathlib import Path89import pytest1011TESTS = Path(lib.__file__).resolve().parent / "tests" # read here, never printed121314class Outcomes:15 """Counts each test's outcome by module. A failed setup or teardown counts as a failure of its test."""1617 def __init__(self) -> None:18 self.passed = Counter()19 self.failed = Counter()2021 def pytest_runtest_logreport(self, report) -> None:22 # The node id starts with the file's path; keep only the module's name, so no path is printed.23 module = Path(report.nodeid.split("::")[0]).stem24 if report.when == "call" and report.passed:25 self.passed[module] += 126 elif report.failed:27 self.failed[module] += 1282930collector = Outcomes()31# -p no:terminal turns off pytest's own printing, which carries timings. That also removes the -q option, which belongs to32# the terminal reporter, so it is not passed. -p no:cacheprovider keeps .pytest_cache out of the working copy.33exit_code = pytest.main(34 [str(TESTS), "-p", "no:terminal", "-p", "no:cacheprovider"],35 plugins=[collector],36)3738modules = sorted(path.stem for path in TESTS.glob("test_*.py")) # every module, even one with no failures39print("tests by module (passed, failed):")40for module in modules:41 print(f" {module}: {collector.passed[module]} passed, {collector.failed[module]} failed")42print(f"total: {sum(collector.passed.values())} passed, {sum(collector.failed.values())} failed")43print(f"pytest exit code: {int(exit_code)}")
python own-tests-run.pytests by module (passed, failed):
test_bench: 11 passed, 0 failed
test_bias: 14 passed, 0 failed
test_both_orders: 14 passed, 0 failed
test_calibration: 9 passed, 0 failed
test_calibration_bootstrap: 8 passed, 0 failed
test_contract: 5 passed, 0 failed
test_gate: 11 passed, 0 failed
test_guard: 4 passed, 0 failed
test_judging: 3 passed, 0 failed
test_stats: 10 passed, 0 failed
test_support_verdict: 5 passed, 0 failed
test_testset: 5 passed, 0 failed
test_variance: 15 passed, 0 failed
total: 114 passed, 0 failed
pytest exit code: 0
La tabla muestra el resultado de cada módulo, junto con lo que el módulo prueba.
| Módulo | Qué prueba | Resultado |
|---|---|---|
| test_bench | Los cargadores y los puntuadores del benchmark | 11 passed, 0 failed |
| test_bias | Las bandas de longitud, los veredictos ilegibles, la dirección de los cambios y la brecha entre bandas | 14 passed, 0 failed |
| test_both_orders | El lector por pares y ambos órdenes: la correspondencia con las respuestas, y los cuatro tipos | 14 passed, 0 failed |
| test_calibration | Los recuentos del juez frente a los humanos, la concordancia, kappa, TPR, TNR y la tasa de aprobación corregida | 9 passed, 0 failed |
| test_calibration_bootstrap | El punto de cruce y el intervalo bootstrap de la tasa de aprobación corregida | 8 passed, 0 failed |
| test_contract | Los formatos de respuesta y de veredicto que el juez y el asistente deben mantener | 5 passed, 0 failed |
| test_gate | La regla de la compuerta: un fallo solo cuando el límite superior está por debajo de menos el umbral | 11 passed, 0 failed |
| test_guard | La regla del guardia de negativas y su umbral, con filas hechas a mano | 4 passed, 0 failed |
| test_judging | La lectura de los veredictos del juez, y el tipo de diferencia pareada | 3 passed, 0 failed |
| test_stats | Las funciones auxiliares de impresión y el bootstrap con semilla | 10 passed, 0 failed |
| test_support_verdict | El lector del veredicto de fidelidad: SUPPORTED o UNSUPPORTED en la primera línea | 5 passed, 0 failed |
| test_testset | La carga del conjunto de prueba y las reglas que comparan varios elementos entre sí | 5 passed, 0 failed |
| test_variance | El recuento de veredictos por elemento sobre el conjunto de varianza | 15 passed, 0 failed |
Los totales van al final: 114 passed, 0 failed, y el código de salida es 0, el código de una ejecución en la que pasaron todas las pruebas recogidas.
Lee la tabla como una comprobación de los instrumentos, no del asistente. Ejecuta estas pruebas primero en el trabajo de la compuerta, para que un código de puntuación roto detenga el trabajo antes de leer una tasa de aprobación. No se imprime nada que varíe entre ejecuciones: ni tiempos ni rutas. Un lector puede volver a ejecutar el código y comparar la salida línea por línea.
Regla práctica: Ejecuta las pruebas propias de la evaluación antes de cualquier ejecución que lea un número, y trata el código de salida 5 como un fallo, no como un éxito. Una prueba que falla en el código de puntuación significa que los números todavía no son fiables, sea lo que sea lo que digan.
Ejecutarlo como tarea de un marco de trabajo
Los equipos que ya usan un marco de trabajo para evaluaciones pueden trasladar las partes de este libro a sus términos, y conviene ver esa correspondencia una vez. En Inspect AI 0.3.291, fechada el 17 de noviembre de 2026 en su registro de cambios, una tarea es la receta de una evaluación, compuesta como mínimo por un conjunto de datos, un solucionador y un calificador, tal como describe la documentación del marco en esa versión. Según esa lectura, el conjunto de prueba es el conjunto de datos, con una muestra por cada elemento. El camino del asistente, que primero recupera y luego responde, es el solucionador, y las comprobaciones y el juez forman el calificador. El libro no ejecuta esa correspondencia ni pretende hacerlo. En cambio, mantiene un único entorno de ejemplo: un conjunto de archivos que importan todos los ejemplos de cada capítulo, fijado a las mismas versiones, de modo que el modelo de repetición, las comprobaciones y la compuerta son el mismo código en cada capítulo. Este capítulo describe dónde iría cada parte, para que quien use un marco pueda trasladar las partes mientras los ejemplos del libro siguen como están.
Regla práctica: Cuando asignes una evaluación a un marco de trabajo, indica la versión del marco y la fecha de su documentación. Conserva el conjunto de prueba, las comprobaciones y el modelo de repetición como los archivos que ejecutan los ejemplos del libro, y trata la correspondencia como una lectura de la documentación hasta que alguien la ejecute.
Variantes en el tráfico
Sin conexión, el conjunto de prueba y las respuestas reproducidas pueden indicar qué variante es mejor en los casos que escribió el equipo. Una vez que el asistente está en vivo, un equipo puede querer comparar dos variantes con preguntas reales, por ejemplo dos prompts o dos modelos, enviando cada una a una parte de los usuarios. Eso es una comparación, y solo es tan buena como la forma en que se asignaron los usuarios a las variantes. Si quienes ven una variante son los que hacen preguntas más difíciles, la diferencia refleja a esos usuarios y no a la variante. La asignación aleatoria, y un intervalo leído como el resto de este capítulo lo lee, son lo que convierte una comparación en vivo en una prueba. La guía de Kohavi y colegas, que cita el capítulo 10, recomienda decidir la potencia y el efecto que se quiere detectar, y estimar la variabilidad, antes de empezar la prueba. Sin eso, una comparación en vivo es solo una lista de quién vio qué variante.
La tabla de comentarios de esta sección no es tráfico. Sus filas son generadas. El voto de cada elemento de desarrollo se extrae de un modelo declarado con una semilla fija. Una respuesta es correcta con probabilidad 0.85. Un usuario que ve una respuesta incorrecta da un pulgar hacia abajo con probabilidad 0.5 y un pulgar hacia arriba con 0.05. Un usuario que ve una respuesta correcta da un pulgar hacia abajo con 0.03 y un pulgar hacia arriba con 0.15. La mayoría de los elementos no recibe ningún voto. Si cada respuesta fue correcta se extrae y luego se descarta, como ocurriría en un registro real, de modo que la tabla solo contiene los votos. Es un recurso didáctico, y sus cifras son lo que produce el modelo declarado. No dicen nada sobre este asistente.
1"""A generated table of thumbs-up and thumbs-down rows over the eighty dev items, with what such a table can show and what it2can't. The rows are generated from a stated model with a fixed seed, not taken from users, so the table is a teaching3device only.45The model: an answer is right with probability 0.85. A user who sees a wrong answer gives thumbs-down with probability 0.5 and6thumbs-up with 0.05; one who sees a right answer gives thumbs-down with 0.03 and thumbs-up with 0.15. Most items get no vote.7The table keeps the votes only: whether each answer was right is drawn and then dropped, as it would be in a real log."""8import lib # first: fixes the thread counts and seeds before anything else loads910import numpy as np1112from lib import SEED13from lib.stats import pct14from lib.testset import load_items1516P_RIGHT = 0.8517P_DOWN_WRONG, P_UP_WRONG = 0.50, 0.0518P_DOWN_RIGHT, P_UP_RIGHT = 0.03, 0.151920rng = np.random.default_rng(SEED) # one generator for the whole table, so the same seed gives the same rows21items = [item.id for item in load_items(split="dev")]22rows = [] # (item id, vote) for each item that got a vote23for item_id in items:24 right = rng.random() < P_RIGHT # hidden: the table has no column for it25 draw = rng.random()26 down, up = (P_DOWN_RIGHT, P_UP_RIGHT) if right else (P_DOWN_WRONG, P_UP_WRONG)27 if draw < down:28 rows.append((item_id, "thumbs-down"))29 elif draw < down + up:30 rows.append((item_id, "thumbs-up"))3132print("generated rows from a stated model, not user feedback (seed 0)")33print("item vote")34for item_id, vote in rows:35 print(f"{item_id} {vote}")3637ups = sum(vote == "thumbs-up" for _, vote in rows)38downs = sum(vote == "thumbs-down" for _, vote in rows)39voted = len({item_id for item_id, _ in rows})40print(f"dev items: {len(items)}")41print(f"items with a vote: {voted}")42print(f"items nobody voted on: {len(items) - voted}")43print(f"thumbs-down among those who voted: {pct(downs, ups + downs)}")44print(f"thumbs-up among those who voted: {pct(ups, ups + downs)}")45print("what the table can show: the share of each kind of vote, among the votes cast, with its n.")46print("what it can't show: anything about the items nobody voted on; whether a thumbs-up answer was right.")
python feedback-table.pygenerated rows from a stated model, not user feedback (seed 0)
item vote
q-0002 thumbs-down
q-0006 thumbs-down
q-0007 thumbs-down
q-0008 thumbs-up
q-0009 thumbs-up
q-0011 thumbs-up
q-0020 thumbs-down
q-0027 thumbs-down
q-0028 thumbs-up
q-0030 thumbs-up
q-0035 thumbs-up
q-0040 thumbs-down
q-0056 thumbs-down
q-0057 thumbs-down
q-0059 thumbs-down
q-0060 thumbs-up
q-0064 thumbs-down
q-0070 thumbs-down
q-0072 thumbs-up
q-0079 thumbs-down
q-0080 thumbs-down
dev items: 80
items with a vote: 21
items nobody voted on: 59
thumbs-down among those who voted: 61.9% (13 of 21)
thumbs-up among those who voted: 38.1% (8 of 21)
what the table can show: the share of each kind of vote, among the votes cast, with its n.
what it can't show: anything about the items nobody voted on; whether a thumbs-up answer was right.
Según el modelo declarado, solo 21 de los 80 elementos de desarrollo reciben un voto, y 59 no reciben ninguno. Así que la tabla dice poco sobre los demás elementos.
Un voto no es una etiqueta de corrección, y esta tabla muestra por qué. Según el modelo declarado, las respuestas son correctas el 85 % de las veces, y aun así la mayoría de los votos son pulgares hacia abajo, porque una respuesta incorrecta recibe un voto mucho más a menudo. Entre los votos emitidos, el pulgar hacia abajo es 61.9% (13 of 21). El pulgar hacia arriba es 38.1% (8 of 21).
Una tabla de votos puede mostrar la proporción de cada tipo de voto, entre los votos emitidos, con el recuento al lado, y las últimas líneas del ejemplo dicen exactamente eso. No puede mostrar si una respuesta con pulgar hacia arriba fue correcta, pues la tabla no tiene una columna de corrección. No dice nada sobre los elementos que nadie votó, y un voto procede de alguien que eligió votar sobre lo que eligió leer.
Joachims y colegas estudiaron en 2005 los clics en resultados de búsqueda y hallaron que eran informativos pero sesgados, de modo que un clic no es un juicio absoluto de relevancia. Informan de que las preferencias relativas derivadas de los clics son razonablemente precisas en promedio, en su artículo sobre la interpretación de los datos de clics. Este libro usa ese hallazgo solo como analogía, y es la lectura propia del libro. Un pulgar hacia arriba es un voto, no una etiqueta. Una respuesta correcta puede recibir aun así un pulgar hacia abajo, y la tabla no tiene forma de saber cuáles son esos votos.
Dos grupos de usuarios se comparan de forma distinta a los elementos pareados de arriba. Cada usuario ve una variante, así que los dos grupos son separados, y el intervalo para su diferencia es un cálculo distinto del pareado que usa este capítulo. El capítulo 8 cubre la comparación pareada que usa este capítulo. No cubre un intervalo para dos grupos separados.
Una tabla de votos tampoco puede comparar variantes a menos que cada voto esté vinculado a la variante que vio el usuario. Esta tabla no tiene una columna de variante, así que no puede comparar nada. Una comparación en vivo necesitaría esa columna, la asignación aleatoria de arriba y un intervalo. Si pocos elementos reciben un voto, como en esta tabla generada, el intervalo sería amplio, y la mayoría de los elementos no tendría ningún voto que comparar.
Antes de que se pudiera confiar en una tabla real de votos, necesitaría tres cosas. Cada voto tendría que estar vinculado a la variante que vio el usuario. La proporción de elementos que reciben un voto tendría que informarse junto con su recuento, pues una tabla de votos solo habla de los elementos que fueron votados. Y una muestra de sus votos tendría que verificarse contra la corrección, para que un pulgar hacia arriba o hacia abajo pueda leerse frente a lo que se supone que mide.
Las partes del libro suman una evaluación para una función propia. Primero viene un conjunto de prueba etiquetado (capítulo 3), luego las comprobaciones en código (capítulo 4). Sigue un juez con una rúbrica y un error medido (capítulo 5, capítulo 6). Una comparación informa su intervalo y n (capítulo 8), y la puerta en CI lee todo ello. El capítulo 7 indica dónde deja de ser fiable el juez. El capítulo 9 y el capítulo 10 aplican los mismos recuentos a la fundamentación y a la negativa a responder.
El libro deja tres temas a otros. A Primer on Search Relevance cubre las métricas de ranking. Agent Harnesses cubre las tareas que requieren varios pasos. Observability for LLM Applications cubre el seguimiento de una solicitud a través de la recuperación y el modelo, y el conteo de lo que cuesta cada solicitud. Está planeado, así que se nombra aquí y no se enlaza.
Regla práctica: No compares variantes a partir del tráfico sin asignación aleatoria y sin la variante registrada junto a cada voto o respuesta. Lee una tabla de votos como una proporción de los votos emitidos, con su recuento, y nunca como una medida de corrección.
Este capítulo, en esta edición
Edición 2026.11.3Ejemplos verificados el 21 de nov de 2026Superan la prueba 4 de 4 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.3.