Decide si un cambio es mejor, y cuántas preguntas necesitas

Unos 20 minutos de lectura, con 5 ejemplos en 6 secciones.

Edición 2026.11.3 Ejemplos verificados el 21 de nov de 2026 54 de 54 ejemplos pasan Qué ha cambiado

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 decir si una diferencia entre dos versiones del asistente es más que ruido, usando un intervalo en una comparación pareada. También podrás calcular cuántas preguntas necesita una diferencia de un tamaño dado antes de que una prueba pueda mostrarla.

El capítulo 1 midió al asistente una vez y dio un intervalo a su tasa de aciertos. Después comparó dos prompts con veinte ítems. El intervalo de su diferencia tenía un ancho de 30.0 points, y el capítulo terminó con una promesa: un capítulo posterior calcularía cuántos ítems necesita una diferencia para poder mostrarse. Este capítulo cumple esa promesa. Un equipo que cambia un prompt necesita tres respuestas. ¿La tasa se movió por una razón que va más allá del azar de la prueba? ¿La comparación era capaz de mostrar alguna diferencia? Y ¿cuántas preguntas necesitaría para mostrar la diferencia que le interesa?

Todos los números de aquí provienen de un mismo modelo asistente, Qwen3-4B-Instruct-2507, y de un mismo juez, el mismo modelo ejecutado con temperatura cero. Los intervalos cubren la dispersión que surge al extraer ítems. La primera sección mide la dispersión que proviene de muestrear respuestas, sin intervalo. Los intervalos no cubren los sesgos del juez, que el capítulo 7 pone a prueba. Lee cada resultado teniendo esto en cuenta.

Variabilidad dentro de un mismo ítem

Haz la misma pregunta dos veces y un modelo puede responder de forma distinta. Las comparaciones de este capítulo usan una única respuesta registrada por ítem y prompt, de modo que cada veredicto se apoya en una sola respuesta. Con una temperatura más alta, el modelo muestrea, y el veredicto de un ítem puede cambiar de una muestra a otra. Eso importa en las comparaciones. Una diferencia entre dos prompts que sea menor que la oscilación de una muestra a otra no es una diferencia en absoluto, y una tasa leída de una sola ejecución oculta esa oscilación.

El conjunto de varianza contiene cinco muestras de la respuesta del asistente a cada ítem de desarrollo, tomadas con una temperatura de 0.7. El juez lee cada respuesta con temperatura cero. Un ítem cambia ("flip") cuando sus cinco veredictos no son todos iguales. Contar esos cambios da una medida de cuánto se mueven los veredictos de una muestra a otra, antes de introducir ningún cambio.

flip-rate.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""The flip rate over the dev variance set: the share of items whose judge verdict differs across their five samples. Theprinted line 'flip rate' rests on the per-item PASS counts, which are printed with it: how many items passed 0, 1, 2, 3, 4or 5 of 5 samples, and the mean pass rate. The temperature-0 baseline's pass rate over the same items is printed forcomparison. An item with an unreadable verdict is printed by id and left out, never counted as FAIL."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import readable_verdictsfrom lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import pctfrom lib.testset import load_itemsfrom lib.variance import VARIANCE_SAMPLES, item_pass_countsVARIANCE = "judge-answers-variance"BASELINE = "judge-answers-baseline"SAMPLES = len(VARIANCE_SAMPLES)items = [item.id for item in load_items(split="dev")]  # eighty dev items, sorted by idcounts = item_pass_counts(VARIANCE, items)excluded = [row for row in counts if not row.complete]kept = [row for row in counts if row.complete]for row in excluded:    samples = ", ".join(str(sample) for sample in row.unreadable)    print(f"unreadable, {row.item_id}: samples {samples} (left out, not counted as FAIL)")print(f"left out of the flip rate (unreadable verdict): {len(excluded)}")n = len(kept)print(f"variance items compared (n): {n}")print(f"flip rate: {pct(sum(1 for row in kept if row.flaky), n)}")spread = [sum(1 for row in kept if row.passes == passes) for passes in range(SAMPLES + 1)]assert sum(spread) == n  # every kept item falls in exactly one PASS countfor passes, count in enumerate(spread):    print(f"items with {passes} of {SAMPLES} PASS: {count}")print(f"mean per-item pass rate across samples: {pct(sum(row.passes for row in kept), n * SAMPLES)}")found, baseline_unreadable = readable_verdicts(BASELINE, [row.item_id for row in kept], REF_SHA256)assert not baseline_unreadable  # q-0043 is already left out above, so no kept item is unreadable under the baselinebaseline = passed(found)print(f"baseline pass rate, same items (temperature 0): {pct(int(baseline.sum()), len(baseline))}")
Salidapython flip-rate.py
unreadable, q-0043: samples 1, 4 (left out, not counted as FAIL)
left out of the flip rate (unreadable verdict): 1
variance items compared (n): 79
flip rate: 2.5% (2 of 79)
items with 0 of 5 PASS: 16
items with 1 of 5 PASS: 1
items with 2 of 5 PASS: 0
items with 3 of 5 PASS: 0
items with 4 of 5 PASS: 1
items with 5 of 5 PASS: 61
mean per-item pass rate across samples: 78.5% (310 of 395)
baseline pass rate, same items (temperature 0): 78.5% (62 of 79)

Contando por ítem, el código calcula cuántas de sus cinco muestras aprobó el juez. Un ítem con un veredicto que no puede leerse se deja fuera, no se cuenta como suspenso, y la salida indica qué ítem dejó fuera.

La mayoría de los ítems no cambia. 61 ítems aprueban las cinco muestras, y 16 suspenden las cinco. De los ítems que cambian, 1 aprueba una muestra y 1 aprueba cuatro.

La tasa de cambios es 2.5% (2 of 79).

La tasa media de aprobados en todas las muestras es 78.5% (310 of 395). La línea base, una respuesta por ítem con temperatura cero, aprueba 78.5% (62 of 79). Ambas son iguales, y los dos ítems que cambian tiran en direcciones opuestas. Eso se cumple para P1, el prompt que usa el conjunto de varianza, y otro prompt podría ser menos estable.

Es un resultado acotado. Un conjunto con más preguntas límite cambiaría más, y la tasa de cambios cuenta ítems y no tiene un intervalo propio. Un recuento de ítems que cambian tan pequeño dice poco sobre con qué frecuencia cambiará el siguiente.

La tasa de cambios mide solo la dispersión que procede del muestreo de las respuestas de este asistente, con los ítems fijos. Una comparación entre dos prompts también varía según los ítems que cada prompt acierta. La última sección usa esa dispersión del muestreo como cota inferior, y solo para una comparación que muestrea sus respuestas: Cuántas preguntas necesita una diferencia.

Regla práctica: antes de confiar en la tasa de una sola ejecución, ejecuta el conjunto de varianza a la temperatura que vas a usar en producción, y lee la tasa de cambios junto a la tasa media de aprobados. La tasa de cambios indica cuánto mueve el muestreo los veredictos de un prompt. Solo acota una comparación cuando esa comparación también muestrea sus respuestas.

El bootstrap sobre ítems

Último cambio en la edición 2026.11.3

El capítulo 1 mostró un intervalo sobre una tasa de aciertos y lo usó para leer un conjunto pequeño. Esta sección explica el método, porque el resto del capítulo lo usa de tres maneras: sobre una tasa, sobre una diferencia emparejada y sobre una diferencia que tiene que superar un nivel más exigente.

El método es el bootstrap percentil. Los ítems de un conjunto son una muestra de las preguntas que un equipo podría haber escrito, así que otro conjunto daría una tasa algo distinta. Para estimar cuánto, extrae ítems del conjunto con reemplazo, tantos como tenga el conjunto, de modo que algunos ítems aparezcan dos veces y otros no aparezcan. Calcula el estadístico para esa extracción, repite la extracción muchas veces y conserva el 95% central de los resultados. El bootstrap no añade datos. Reutiliza los ítems que el conjunto ya tiene y muestra cuánto se movería el estadístico si el conjunto hubiera sido otra extracción del mismo tipo.

La unidad de remuestreo es el ítem, y esa es la regla que hay que mantener. En una tasa, cada ítem aporta su veredicto. En una diferencia emparejada, cada ítem aporta un número: el veredicto del prompt B menos el veredicto de la línea base, que es más uno, cero o menos uno. En el conjunto de varianza, las cinco muestras de un ítem se mantienen juntas, porque responden a una misma pregunta. Separarlas haría que parecieran cinco preguntas independientes, y el intervalo saldría demasiado estrecho. Miller (2024) plantea el mismo punto para preguntas que vienen en grupos relacionados. Ese artículo es una preimpresión y una nota práctica, no un método revisado, así que este libro lo usa por la razón que expone y no como prueba.

El libro fija la configuración para que un número pueda reproducirse. El método extrae 2,000 remuestras con una semilla de cero y crea un generador aleatorio nuevo dentro de cada llamada. Por eso los mismos datos dan el mismo intervalo, sea lo que sea que se haya ejecutado antes. La semilla es una elección, no una propiedad de los datos. Una semilla distinta mueve un poco los extremos, y por eso la configuración se escribe.

El método depende también de que el conjunto sea una muestra justa de las preguntas, algo que el capítulo 1 defendió y que ningún intervalo puede comprobar. Un conjunto pequeño da un intervalo burdo. Los extremos de un intervalo percentil sobre un conjunto de este tamaño son una primera estimación y deben leerse como aproximados.

Regla práctica: Remuestrea ítems, nunca ejecuciones dentro de un ítem, y mantén juntas las muestras de un ítem. Fija en el código el número de remuestras y la semilla, de modo que los mismos datos den el mismo intervalo. Cuando el conjunto tenga pocos ítems, llama al intervalo aproximado y dilo junto a él.

Comparaciones emparejadas

Último cambio en la edición 2026.11.3

Dos prompts responden las mismas preguntas, así que sus resultados están emparejados. Una comparación emparejada resta, para cada ítem, el veredicto de la línea base del veredicto del prompt B, y promedia las diferencias sobre el conjunto. Su intervalo proviene del bootstrap sobre los ítems.

El emparejamiento importa porque la mayoría de los ítems coinciden. Un ítem que ambos prompts superan, o que ambos fallan, no aporta nada a la diferencia, sea cual sea la dificultad de la pregunta. La dispersión de la comparación procede de los ítems en los que los dos prompts se separan. Una comparación no emparejada toma dos tasas de aprobación por separado y las pone una al lado de la otra. Arrastra la variación entre preguntas en cada ítem, incluidos los que coinciden, y esa variación puede ocultar una diferencia real. La versión emparejada cancela la parte que los dos prompts comparten. El argumento a favor de las diferencias emparejadas en Miller (2024) dice lo mismo: la varianza de una diferencia emparejada disminuye siempre que las puntuaciones de los dos modelos en cada ítem estén correlacionadas positivamente.

paired-prompt-b.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Compares prompt-b (P2) with the baseline prompt (P1) on the eighty dev items: each pass rate, the paired difference withits 95% interval, and how the items split between the two prompts. 'Better' is used only when the whole interval is abovezero (plan section 6.4); the interval here includes zero, so the reading is no difference detected."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import readable_verdictsfrom lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import bootstrap_mean, interval_points, pctfrom lib.testset import load_itemsBASELINE = "judge-answers-baseline"PROMPT_B = "judge-answers-prompt-b"items = [item.id for item in load_items(split="dev")]  # eighty dev items, sorted by idp1_found, p1_unreadable = readable_verdicts(BASELINE, items, REF_SHA256)p2_found, p2_unreadable = readable_verdicts(PROMPT_B, items, REF_SHA256)for label, unreadable in (("P1 (baseline)", p1_unreadable), ("P2 (prompt-b)", p2_unreadable)):    details = "".join(f' ({item_id}, "{first}")' for item_id, first in unreadable)    print(f"unreadable verdicts, {label}: {len(unreadable)}{details}")# An item without a readable verdict under either prompt is dropped from both sides: a paired difference needs the same items.excluded = {item_id for item_id, _ in p1_unreadable + p2_unreadable}kept = [item_id for item_id in items if item_id not in excluded]first = passed({item_id: p1_found[item_id] for item_id in kept})  # 1.0 or 0.0 per item, in id ordersecond = passed({item_id: p2_found[item_id] for item_id in kept})n = len(kept)lo, hi = bootstrap_mean(second - first)  # 95%, one comparison: the default levelprint(f"P1 (baseline) pass rate: {pct(int(first.sum()), n)}")print(f"P2 (prompt-b) pass rate: {pct(int(second.sum()), n)}")print(f"difference, P2 minus P1: {100 * float((second - first).mean()):+.1f} points")print(f"95% interval of the difference: {interval_points(lo, hi)}")print(f"paired items (n): {n}")print(f"items only P1 passes: {int(((first == 1) & (second == 0)).sum())}")print(f"items only P2 passes: {int(((first == 0) & (second == 1)).sum())}")print(f"items both pass: {int(((first == 1) & (second == 1)).sum())}")print(f"items neither passes: {int(((first == 0) & (second == 0)).sum())}")if lo > 0:    print(f"reading: P2 is better at n = {n}")elif hi < 0:    print(f"reading: P2 is worse at n = {n}")else:    print(f"reading: no difference detected at n = {n}")
Salidapython paired-prompt-b.py
unreadable verdicts, P1 (baseline): 1 (q-0043, "VERDICT: PARTIAL")
unreadable verdicts, P2 (prompt-b): 0
P1 (baseline) pass rate: 78.5% (62 of 79)
P2 (prompt-b) pass rate: 81.0% (64 of 79)
difference, P2 minus P1: +2.5 points
95% interval of the difference: [-3.8, +10.1] points
paired items (n): 79
items only P1 passes: 3
items only P2 passes: 5
items both pass: 59
items neither passes: 12
reading: no difference detected at n = 79

Aquí el prompt B se ejecuta frente a la línea base sobre los ítems de desarrollo. Un ítem cuyo veredicto no puede leerse con ninguno de los dos prompts se excluye de ambos lados, porque una diferencia emparejada necesita los mismos ítems en los dos lados. Las líneas impresas dan cada tasa de aprobación, la diferencia, su intervalo y el número de ítems emparejados.

La línea base supera 78.5% (62 of 79). El prompt B supera 81.0% (64 of 79). La diferencia, el prompt B menos la línea base, es +2.5 points, con un intervalo del 95 % de [-3.8, +10.1] points.

La separación muestra dónde está la diferencia. 59 ítems se superan con ambos prompts, y 12 fallan con ambos. Solo los ítems que se separan mueven la diferencia: 5 se superan solo con el prompt B, y 3 solo con la línea base.

El intervalo incluye el cero, así que la lectura es no difference detected at n = 79. El intervalo va de una caída a una subida, y este conjunto no puede decir cuál de los dos extremos está más cerca. No detectar diferencia es una constatación sobre un conjunto de ese tamaño. No es una afirmación de que los prompts sean iguales, y el texto no debe decir que lo son.

Regla práctica: Compara variantes sobre los mismos ítems, emparejadas, e informa de la diferencia con su intervalo y n. Considera que una variante es mejor solo cuando todo el intervalo está por encima de cero, y peor solo cuando todo el intervalo está por debajo. Cuando el intervalo incluye el cero, informa de que no se detecta diferencia con ese n, e indica cuántos ítems necesitaría la diferencia, como lo calcula Cuántas preguntas necesita una diferencia.

Held-out, una vez

Último cambio en la edición 2026.11.3

Los ítems de desarrollo sirven para construir. Un equipo puede ajustar un prompt con ellos, leer los fallos y cambiar la siguiente versión. Los resultados de desarrollo no pueden entonces demostrar que un cambio funciona, porque el cambio se moldeó con ellos. El conjunto held-out es la comprobación que no se ajusta. Una comparación sobre held-out se ejecuta una sola vez, con reglas fijadas antes de la ejecución: las variantes, el nivel y la lectura. Si la vuelves a ejecutar tras cambiar de opinión, o eliges el nivel después de ver el número, el intervalo deja de significar lo que dice.

Esta sección ejecuta tres comparaciones sobre el conjunto held-out, cada variante contra la línea base. El prompt B es el de Comparaciones pareadas. La variante k5 recupera cinco secciones en lugar de tres. La variante unfiltered recupera de todas las versiones de la documentación a la vez, con tres secciones, en lugar de solo la versión consultada.

held-out-variants.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Compares prompt-b, k5 and unfiltered with the baseline on the held-out items, each variant once, at the level theBonferroni rule gives for three comparisons (98.33%). Each variant gets its paired difference, interval, n and a reading byplan section 6.4. Nothing was chosen with these numbers: the variants, the level and the reading rule were fixed beforethis run, and the run happens once."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import readable_verdictsfrom lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import RESAMPLES, bootstrap_mean, interval_pointsfrom lib.testset import load_itemsBASELINE = "baseline"VARIANTS = ("prompt-b", "k5", "unfiltered")M = len(VARIANTS)  # one comparison per variant, each against the baselineLEVEL = 1 - 0.05 / M  # Bonferroni: 1 - 0.05/m, which is 98.33% for m = 3 (plan section 6.3)items = [item.id for item in load_items(split="held-out")]  # sorted by idprint(f"comparisons (m): {M}")print(f"share of the 5% for each comparison, 0.05 / m: {0.05 / M:.4f}")print(f"level of each interval, 1 - 0.05 / m: {100 * LEVEL:.2f}%")print(f"resamples beyond each end of an interval: {RESAMPLES * (1 - LEVEL) / 2:.1f}")base_found, base_unreadable = readable_verdicts(f"judge-answers-{BASELINE}", items, REF_SHA256)details = "".join(f' ({item_id}, "{first}")' for item_id, first in base_unreadable)print(f"unreadable verdicts, baseline: {len(base_unreadable)}{details}")for name in VARIANTS:    found, unreadable = readable_verdicts(f"judge-answers-{name}", items, REF_SHA256)    details = "".join(f' ({item_id}, "{first}")' for item_id, first in unreadable)    print(f"unreadable verdicts, {name}: {len(unreadable)}{details}")    # An item unreadable under the baseline or this variant is dropped from both sides of this pair only.    excluded = {item_id for item_id, _ in base_unreadable + unreadable}    kept = [item_id for item_id in items if item_id not in excluded]    first = passed({item_id: base_found[item_id] for item_id in kept})    second = passed({item_id: found[item_id] for item_id in kept})    n = len(kept)    lo, hi = bootstrap_mean(second - first, level=LEVEL)    if name == "prompt-b":  # the chapter says this lower end is exactly zero, so the run must show it        assert lo == 0.0, "the prompt-b lower bound must be exactly zero"    print(f"{name} minus baseline, difference: {100 * float((second - first).mean()):+.1f} points")    print(f"{name} minus baseline, {100 * LEVEL:.2f}% interval: {interval_points(lo, hi)}")    print(f"{name} minus baseline, n: {n}")    if lo > 0:        print(f"{name} minus baseline, reading: better at n = {n}")    elif hi < 0:        print(f"{name} minus baseline, reading: worse at n = {n}")    else:        print(f"{name} minus baseline, reading: no difference detected at n = {n}")
Salidapython held-out-variants.py
comparisons (m): 3
share of the 5% for each comparison, 0.05 / m: 0.0167
level of each interval, 1 - 0.05 / m: 98.33%
resamples beyond each end of an interval: 16.7
unreadable verdicts, baseline: 0
unreadable verdicts, prompt-b: 0
prompt-b minus baseline, difference: +10.0 points
prompt-b minus baseline, 98.33% interval: [+0.0, +22.5] points
prompt-b minus baseline, n: 40
prompt-b minus baseline, reading: no difference detected at n = 40
unreadable verdicts, k5: 0
k5 minus baseline, difference: +2.5 points
k5 minus baseline, 98.33% interval: [-12.5, +18.4] points
k5 minus baseline, n: 40
k5 minus baseline, reading: no difference detected at n = 40
unreadable verdicts, unfiltered: 0
unfiltered minus baseline, difference: -10.0 points
unfiltered minus baseline, 98.33% interval: [-27.5, +8.4] points
unfiltered minus baseline, n: 40
unfiltered minus baseline, reading: no difference detected at n = 40

Tres comparaciones comparten un mismo conjunto held-out, así que cada intervalo se establece en un nivel superior al 95%, y Muchas comparaciones explica por qué. El nivel es 98.33%. Cada variante obtiene una diferencia, un intervalo, un recuento de ítems pareados y una lectura, todo impreso.

Held-out tiene 40 ítems, frente a 79 en desarrollo. Por eso sus intervalos son más anchos para la misma diferencia, y un resultado sobre él solo puede ser tan preciso como permita su número de ítems. La división mantiene honesto un resultado, y su coste son menos ítems que gastar.

La diferencia del prompt B es +10.0 points, con un intervalo de [+0.0, +22.5] points. La comparación tiene 40 ítems pareados.

La diferencia de k5 es +2.5 points, con un intervalo de [-12.5, +18.4] points. La diferencia de unfiltered es -10.0 points, con un intervalo de [-27.5, +8.4] points.

Desarrollo dio +2.5 points para el mismo prompt, y las dos estimaciones puntuales difieren. Los 40 ítems held-out no pueden decir cuál está más cerca de la verdad. La menor diferencia que detectan, con una confianza del 98.33% y una potencia del 80%, es 16.2 points, así que ambas estimaciones puntuales quedan por debajo de lo que este conjunto puede detectar. Cuántas preguntas necesita una diferencia hace el cálculo.

Según la regla, las tres se leen como ninguna diferencia detectada. Para el prompt B la lectura impresa es no difference detected at n = 40. Para k5 es no difference detected at n = 40, y para unfiltered no difference detected at n = 40.

El prompt B es el caso límite. Su intervalo es [+0.0, +22.5] points, y su extremo inferior es exactamente cero. La regla de lectura indica mejor solo cuando todo el intervalo está por encima de cero, y este llega a cero sin superarlo, así que según la regla la lectura es ninguna diferencia detectada. Más allá de cada extremo del intervalo quedan 16.7 de los 2,000 remuestreos, por lo que la decisión está sobre la línea. La semilla se fijó antes de la ejecución por esa razón. Un lector podría argumentar que una estimación puntual de ese tamaño debería contar, y esta sección no hace ese argumento. La regla se fijó antes de la ejecución, la comparación se ejecuta una sola vez, y nadie puede volver a mirar estas tres con un nivel más bajo o una lectura distinta. Si el prompt B va a someterse a más pruebas, necesita un nuevo conjunto held-out, dimensionado según Cuántas preguntas necesita una diferencia y fijado antes de que nadie vea sus resultados, leído por sí solo. Añadir ítems a los 40 ya leídos, y volver a leer el conjunto, sería una segunda mirada a un resultado ya visto.

Regla práctica: Fija las variantes, el nivel y la regla de lectura antes de abrir el conjunto held-out, y ejecuta cada comparación una sola vez. Un intervalo que llega a cero es ninguna diferencia detectada con ese n. No vuelvas a ejecutar la comparación, no bajes el nivel ni cambies la lectura para obtener otra respuesta. Añade ítems held-out solo antes de que se puntúen.

Muchas comparaciones

Cada comparación es una oportunidad de dejarse engañar. Un intervalo del 95 % en una comparación sin diferencia real excluye el cero por azar alrededor de una vez de cada veinte. Si realizas tres comparaciones de este tipo y reportas cada una al 95 %, la probabilidad de que al menos una de ellas parezca mostrar una diferencia supera el cinco por ciento. Cuantas más comparaciones reporte un capítulo, más probable es que alguna de ellas sea un resultado afortunado.

La solución habitual es la corrección de Bonferroni, que reparte el presupuesto de error entre las comparaciones. Con m comparaciones de una métrica, cada intervalo se fija en 1 menos 0.05 dividido entre m. Para tres comparaciones, 0.05 dividido entre 3 es 0.0167, así que el nivel de cada intervalo es 98.33%, el mismo nivel que usó la sección de held-out. El 0.05 se reparte entre las dos colas de cada intervalo, de modo que cada cola recibe 0.05 dividido entre el doble de m. El cálculo se sostiene sea lo que sea lo que las comparaciones tengan en común. La probabilidad de que alguna de ellas muestre una diferencia falsa no puede superar la suma de sus probabilidades por separado, y esa suma es 5 %.

El código calcula el nivel a partir de m y lo imprime, de modo que puedas comprobarlo contra el recuento. El precio es la anchura. Con este nivel, cada intervalo es más ancho que uno del 95 %, así que una diferencia debe ser mayor antes de que su intervalo deje de incluir el cero. La suma de las probabilidades por separado es una cota superior de la probabilidad de cualquier diferencia falsa, por lo que la corrección es conservadora siempre que los resultados falsos de las comparaciones se solapen. Este libro usa esta corrección porque su regla es breve de enunciar y de verificar, y puedes recalcularla a partir del número de comparaciones.

¿Qué comparaciones forman el recuento? En este capítulo, la comparación de desarrollo de la sección de pares aparece sola, y se reporta al 95 % porque es un ejemplo resuelto sobre datos de ajuste. Las tres comparaciones de held-out forman una familia y se reportan al nivel ajustado. Quien vea ambas no debe leer el intervalo de desarrollo como un resultado de held-out, y el resultado de held-out es el que el capítulo utiliza.

El recuento forma parte del diseño. Cuenta las comparaciones de una misma métrica que el capítulo va a reportar antes de ejecutar cualquiera de ellas. Una comparación añadida después de conocer los resultados se reporta aparte de la familia, como exploratoria, con su propio recuento. Los intervalos de la familia se mantienen tal como se calcularon, porque volver a fijarlos después de ver los resultados cambiaría la regla a la que se sujetó la ejecución.

Regla práctica: Cuenta las comparaciones de una métrica antes de ejecutarlas, y fija el nivel de cada intervalo en 1 menos 0.05 dividido entre ese recuento. Muestra el nivel junto a cada intervalo. Una comparación añadida después de conocer los resultados se reporta aparte como exploratoria, y los intervalos de la familia no se vuelven a fijar.

Cuántas preguntas necesita una diferencia

La pregunta que debes hacerte antes de una comparación es cuántos ítems necesita para mostrar una diferencia del tamaño que le importa al equipo. La respuesta depende de una sola cantidad: cuánto discrepan las dos variantes, ítem por ítem. Dos prompts que discrepan en pocos ítems muestran una diferencia pequeña con pocos ítems.

La fórmula pareada lo hace concreto. Escribe z-confianza para el valor normal bilateral al nivel de confianza, y z-potencia para el valor al nivel de potencia. Entonces n = (z-confianza + z-potencia)² · varianza(d) / δ², donde varianza(d) es la varianza de la diferencia pareada de un ítem y δ es la diferencia que se quiere detectar. La varianza es la proporción de ítems en los que las dos variantes discrepan, menos el cuadrado de su diferencia media. Así, la estimación depende del desacuerdo, no de las tasas de acierto en sí. Esta sección usa 95% de confianza y 80% de potencia.

sample-size.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""How many items a paired comparison needs to detect a difference of 5 and of 10 points, with 95% confidence and 80% power.The main estimate reads the paired differences that prompt-b and the baseline show on the dev items: each item's d is+1, 0 or -1 (P2 minus P1), and the items on which they disagree set the variance. The floor uses only the judge'swithin-item sampling noise over five samples; it leaves the disagreement between variants out, so it is a lower bound."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib import variancefrom lib.answers import chapter_itemsfrom lib.calibration import readable_verdictsfrom lib.judging import paired, passedfrom lib.prompts import REF_SHA256from lib.stats import pctfrom lib.testset import load_items# n = (z_alpha + z_beta)^2 * var_d / delta^2, rounded up (variance.items_needed). var_d = p_discordant - mean(d)^2.# Smallest difference that n items detect: (z_alpha + z_beta) * sqrt(var_d / n) (variance.smallest_difference_points).BASELINE, PROMPT_B = "judge-answers-baseline", "judge-answers-prompt-b"CHAPTER_ONE_ITEMS = 20  # the chapter 1 set, read below the way twenty-cannot-tell reads ititems = [item.id for item in load_items(split="dev")]  # eighty dev items, sorted by idp1_found, p1_unreadable = readable_verdicts(BASELINE, items, REF_SHA256)p2_found, p2_unreadable = readable_verdicts(PROMPT_B, items, REF_SHA256)kept = [item_id for item_id in items if item_id not in {i for i, _ in p1_unreadable + p2_unreadable}]first = passed({item_id: p1_found[item_id] for item_id in kept})  # 1.0 or 0.0 per itemsecond = passed({item_id: p2_found[item_id] for item_id in kept})var_d = variance.paired_difference_variance(first, second)print(f"share of discordant items, P2 and P1 disagree: {pct(int((first != second).sum()), len(kept))}")print(f"assumption, the next change disagrees with the baseline on about as many items as prompt-b did "      f"({100 * (first != second).mean():.1f}% of items)")# Floor: five samples of a 0/1 verdict with k PASS give the unbiased within-item variance k(5 - k) / (5 * 4).rows = [row for row in variance.item_pass_counts("judge-answers-variance", items) if row.complete]noise = sum(row.passes * (5 - row.passes) / 20 for row in rows) / len(rows)print(f"floor, sampling noise only: dev items with five readable verdicts (n): {len(rows)}")print(f"floor, sampling noise only: mean within-item variance of one verdict: {noise:.4f}")# Two variants judged separately: their two noises add and the item's difficulty cancels, so the floor is 2 * noise.for label, var in (("main estimate", var_d), ("floor, sampling noise only", 2 * noise)):    print(f"{label}, variance of one item's paired difference: {var:.4f}")    for delta in (5.0, 10.0):        print(f"{label}, items needed for a {delta:.0f}-point difference: {variance.items_needed(var, delta)}")    print(f"{label}, smallest difference that {CHAPTER_ONE_ITEMS} items detect, 80% power and 95% confidence: "          f"{variance.smallest_difference_points(var, CHAPTER_ONE_ITEMS):.1f} points")# The chapter 1 set, read as twenty-cannot-tell reads it: its share of discordant items and its interval width.chapter_one = paired(BASELINE, PROMPT_B, [item.id for item in chapter_items()])width_20 = variance.interval_width_points(var_d, CHAPTER_ONE_ITEMS)print(f"chapter 1 set, share of items where the two verdicts differ: "      f"{pct(int((chapter_one.first != chapter_one.second).sum()), chapter_one.n)}")print(f"chapter 1 set, 95% interval width: {100 * (chapter_one.diff_hi - chapter_one.diff_lo):.1f} points")print(f"main estimate, 95% width at {CHAPTER_ONE_ITEMS} items: {width_20:.1f} points")print(f"reading: with {CHAPTER_ONE_ITEMS} items and a change that disagrees with the baseline on "      f"{100 * (first != second).mean():.1f}% of items, as prompt-b did, the smallest difference detected with 80% power "      f"at 95% confidence is {variance.smallest_difference_points(var_d, CHAPTER_ONE_ITEMS):.1f} points")
Salidapython sample-size.py
share of discordant items, P2 and P1 disagree: 10.1% (8 of 79)
assumption, the next change disagrees with the baseline on about as many items as prompt-b did (10.1% of items)
floor, sampling noise only: dev items with five readable verdicts (n): 79
floor, sampling noise only: mean within-item variance of one verdict: 0.0051
main estimate, variance of one item's paired difference: 0.1006
main estimate, items needed for a 5-point difference: 316
main estimate, items needed for a 10-point difference: 79
main estimate, smallest difference that 20 items detect, 80% power and 95% confidence: 19.9 points
floor, sampling noise only, variance of one item's paired difference: 0.0101
floor, sampling noise only, items needed for a 5-point difference: 32
floor, sampling noise only, items needed for a 10-point difference: 8
floor, sampling noise only, smallest difference that 20 items detect, 80% power and 95% confidence: 6.3 points
chapter 1 set, share of items where the two verdicts differ: 10.0% (2 of 20)
chapter 1 set, 95% interval width: 30.0 points
main estimate, 95% width at 20 items: 27.8 points
reading: with 20 items and a change that disagrees with the baseline on 10.1% of items, as prompt-b did, the smallest difference detected with 80% power at 95% confidence is 19.9 points

Aquí el código lee el desacuerdo entre el prompt B y la línea base en los ítems de desarrollo. Su supuesto está impreso, y es el que conviene comprobar: el siguiente cambio discrepa de la línea base en casi tantos ítems como lo hizo el prompt B. Aquí la proporción de ítems que discrepan es 10.1% (8 of 79).

sample-size-limits.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""The arithmetic behind the five-point figure in sample-size, and the limits of its inputs: the interval on the share ofdiscordant items (a percentile bootstrap over items, as lib.stats computes every interval), the held-out level of 98.33%,and the difference that the 40 held-out items can detect. The disagreement is the dev items' paired run, as in sample-size."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib import variancefrom lib.calibration import readable_verdictsfrom lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import bootstrap_mean, interval_pctfrom lib.testset import load_itemsBASELINE = "judge-answers-baseline"PROMPT_B = "judge-answers-prompt-b"ALPHA_HELD_OUT = 0.05 / 3  # two-sided alpha for each of the three held-out comparisons (Bonferroni)HELD_OUT_LEVEL = 1 - ALPHA_HELD_OUTitems = [item.id for item in load_items(split="dev")]  # eighty dev items, sorted by idp1_found, p1_unreadable = readable_verdicts(BASELINE, items, REF_SHA256)p2_found, p2_unreadable = readable_verdicts(PROMPT_B, items, REF_SHA256)kept = [item_id for item_id in items if item_id not in {i for i, _ in p1_unreadable + p2_unreadable}]first = passed({item_id: p1_found[item_id] for item_id in kept})second = passed({item_id: p2_found[item_id] for item_id in kept})discordant = (first != second).astype(float)  # 1 where the two prompts disagree on an item, else 0var_d = variance.paired_difference_variance(first, second)mean_d = float((second - first).mean())# The five-point figure, worked: n = (z_alpha + z_beta)^2 * var(d) / delta^2z2, delta2 = variance.z_sum() ** 2, 0.05 ** 2print(f"z sum squared, 95% confidence and 80% power: {z2:.2f}")print(f"var(d), variance of one item paired difference: {var_d:.4f}")print(f"delta squared, a five-point difference: {delta2:.4f}")print(f"n for five points: {z2:.2f} x {var_d:.4f} / {delta2:.4f} = {z2 * var_d / delta2:.1f}, "      f"rounded up to {variance.items_needed(var_d, 5.0)}")# The share rests on the discordant items alone, so its 95% interval is a range for the answer.share_lo, share_hi = bootstrap_mean(discordant)print(f"discordant share, 95% interval: {interval_pct(share_lo, share_hi)}")for end, share in (("low", share_lo), ("high", share_hi)):    # mean(d) stays at its observed value; only the share moves    print(f"items needed for 5 points, {end} end of the share: {variance.items_needed(share - mean_d ** 2, 5.0)}")print(f"items needed for 5 points at {100 * HELD_OUT_LEVEL:.2f}% confidence: "      f"{variance.items_needed_at(var_d, 5.0, ALPHA_HELD_OUT)}")# Only the count is read here: no held-out verdict is opened by this example.held_out_n = len(load_items(split="held-out"))print(f"held-out items (n): {held_out_n}")print(f"smallest difference {held_out_n} held-out items detect at {100 * HELD_OUT_LEVEL:.2f}% and 80% power: "      f"{variance.smallest_difference_at(var_d, held_out_n, ALPHA_HELD_OUT):.1f} points")
Salidapython sample-size-limits.py
z sum squared, 95% confidence and 80% power: 7.85
var(d), variance of one item paired difference: 0.1006
delta squared, a five-point difference: 0.0025
n for five points: 7.85 x 0.1006 / 0.0025 = 315.9, rounded up to 316
discordant share, 95% interval: [3.8%, 17.7%]
items needed for 5 points, low end of the share: 118
items needed for 5 points, high end of the share: 555
items needed for 5 points at 98.33% confidence: 422
held-out items (n): 40
smallest difference 40 held-out items detect at 98.33% and 80% power: 16.2 points

El cálculo detallado para una diferencia de cinco puntos se desarrolla en ese ejemplo. El cuadrado de la suma de los dos valores z es 7.85. La varianza de la diferencia pareada de un ítem es 0.1006. La diferencia de cinco puntos al cuadrado es 0.0025. Así, n es 7.85 x 0.1006 / 0.0025 = 315.9, rounded up to 316.

Miller (2024) presenta la fórmula pareada en una forma más general, con términos para el ruido dentro de cada ítem. La fórmula aquí es esa forma con una respuesta por ítem, que elimina los términos dentro del ítem. Su ejemplo resuelto, con los datos del artículo, llega a unos 969 ítems. Esos datos describen un experimento distinto, así que los números del libro provienen solo de la ejecución impresa.

La potencia funciona también en sentido contrario. Con 80% de potencia, un conjunto dimensionado para una diferencia real aún no la detecta una de cada cinco veces. Ese es el precio de un presupuesto fijo de preguntas, y un equipo que no pueda asumirlo debe aceptar como objetivo una diferencia mayor o ampliar el conjunto antes de la ejecución.

Como los ítems necesarios crecen con esa proporción cuando la diferencia media es pequeña, un cambio que discrepa en el doble de ítems necesita aproximadamente el doble de preguntas. Un equipo debe estimar la proporción a partir de una comparación pareada en dev, indicarla, y volver a comprobarla cuando el cambio sea mayor que aquel con el que se midió.

La estimación principal dice que una diferencia de cinco puntos necesita 316 ítems, y una de diez puntos necesita 79. El suelo usa solo el ruido de muestreo dentro de cada ítem, y da 32 y 8. Lee el suelo como una cota inferior de lo necesario, no como un plan. Deja fuera el desacuerdo entre variantes, que es real. Dos prompts cambian lo que dice el asistente, no solo lo constante que es al decirlo. El suelo solo vale para una comparación que muestree una respuesta por ítem a temperatura 0.7, con variantes tan estables como P1. Solo dos de los ítems aportan a su ruido, así que descansa en muy pocos ítems. Un plan hecho sobre el suelo se queda corto siempre que un cambio discrepa más de lo que el muestreo por sí solo explicaría.

La misma estimación responde la pregunta para el conjunto del capítulo 1. Con veinte ítems, la diferencia más pequeña que la prueba detecta con 80% de potencia y 95% de confianza es 19.9 points, bajo el supuesto de desacuerdo indicado arriba.

El conjunto del capítulo 1 discrepó en 10.0% (2 of 20) de sus ítems.

Su intervalo fue de 30.0 points de ancho. La fórmula da 27.8 points con el mismo desacuerdo, lo cual es parecido. El ejemplo de veinte ítems muestra ese conjunto. Con ese desacuerdo, veinte ítems por lo general no detectarían una diferencia de diez puntos, y un equipo que quiera ver una diferencia de cinco puntos necesita cientos de ítems, no decenas.

La estimación descansa solo en los ítems discordantes, así que es un orden de magnitud, no un recuento. Su intervalo de 95% sobre la proporción es [3.8%, 17.7%]. En todo ese intervalo, una diferencia de cinco puntos necesita 118 ítems en el extremo bajo y 555 en el extremo alto. La fórmula es una aproximación normal, mientras que la regla de lectura usa bootstrap, y ambas coinciden solo aproximadamente cuando discrepan pocos ítems. Con el nivel de reserva (held-out) de 98.33%, los mismos datos necesitan 422 ítems para una diferencia de cinco puntos.

En producción, el error es elegir el tamaño del conjunto a ojo y luego leer el resultado como una decisión. Un equipo que quiere una mejora de cinco puntos y ejecuta unas pocas decenas de ítems normalmente no detectará ninguna diferencia, y puede tomarlo como un veredicto de que el cambio no funciona. Anota el tamaño antes de la ejecución, con el supuesto de desacuerdo, e informa el resultado frente a él. No detectar diferencia con una n indicada es un hallazgo sobre ese conjunto. No es un cambio que haya fallado.

Regla práctica: Antes de una comparación, haz una comparación pareada en dev para estimar con qué frecuencia discrepan las dos variantes, e indica esa proporción como supuesto. Calcula los ítems necesarios para la diferencia que te interesa, al nivel en que se leerá la comparación, y da su rango a partir del intervalo sobre esa proporción. Si el conjunto es más pequeño, informa de que no puede detectar una diferencia de ese tamaño, y no leas su «no se detectó diferencia» como un dictamen contra el cambio. Usa el suelo solo como cota inferior, y solo para una comparación que muestree sus respuestas.

Este capítulo, en esta edición

Edición 2026.11.3Ejemplos verificados el 21 de nov de 2026Superan la prueba 5 de 5 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.3.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 8 de 11: Decide si un cambio es mejor, y cuántas preguntas necesitas

  1. Variabilidad dentro de un mismo ítem
  2. El bootstrap sobre ítems
  3. Comparaciones emparejadas
  4. Held-out, una vez
  5. Muchas comparaciones
  6. Cuántas preguntas necesita una diferencia

Volver arribaTodos los capítulos