Juicios de personas y de LLM

Unos 40 minutos de lectura, con 11 ejemplos en 13 secciones.

Edición 2026.11.10 Ejemplos verificados el 19 de nov de 2026 132 de 132 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.10. Lee el original

Al final de este capítulo podrás escribir pautas de juicio, medir qué tan de acuerdo están dos jueces con kappa y kappa ponderada, leer los errores de un juez LLM en una matriz de confusión y decidir dónde los juicios de un LLM pueden sustituir a los de personas y dónde no pueden.

Cada puntuación de este libro se apoya en juicios: personas leen una consulta escrita en el cuadro de búsqueda de la tienda junto a un producto que devolvió, y calificaron el par. Esos juicios son las etiquetas de WANDS, cada una el voto mayoritario de hasta tres anotadores entrenados, y tienen huecos: en las consultas de prueba, los 10 primeros de BM25 contienen 22 productos que nadie juzgó (Contar productos sin juzgar). Además, consumen tiempo de personas, y el acuerdo entre los anotadores de WANDS subió durante cuatro meses de calibración (Espera que los jueces discrepen). Un LLM puede calificar cualquier consulta y producto que se le muestre. Antes de que la tienda deje que un LLM juzgue, necesita saber con qué frecuencia el LLM coincide con los jueces de la tienda y si sus calificaciones llevarían a las mismas decisiones sobre los rankers.

Las calificaciones del LLM provienen de una grabación: recordings/llm_judgments.py ejecutó una vez, de forma local, el modelo abierto gemma4:12b-it-q4_K_M con temperatura 0 y una semilla fija, y guardó sus respuestas, de modo que los ejemplos las leen mediante lib.recorded.llm_judgments() sin llamar al modelo. Elegimos ese modelo porque es abierto, con licencia Apache 2.0, y se ejecuta localmente, así que cualquiera puede repetir la grabación. Un esquema JSON limita cada respuesta a una de las tres etiquetas. La grabación calificó cada par con dos prompts, short y guidelines (Escribir pautas de juicio), y tomó sus pares de dos conjuntos, que este capítulo llama grupos.

Las puntuaciones que deciden entre rankers se mantienen en las calificaciones humanas. Las comparaciones planificadas del capítulo sobre las consultas de prueba son las tres del capítulo 3, recalificadas con las calificaciones del LLM de cada prompt, con el umbral del capítulo 3 de 0.0167, para la prueba de permutación pareada: recuperación semántica frente a BM25, el híbrido frente a la recuperación semántica, y el híbrido reordenado frente al híbrido.

Escribir pautas de juicio

Último cambio en la edición 2026.11.10

Este capítulo llama juez a quien emite un juicio, sea una persona o un LLM, y una calificación es el número que lo representa. El capítulo 1 define un juicio como la etiqueta de una persona; este capítulo amplía la definición para incluir también la etiqueta de un LLM. Los juicios dependen de las instrucciones que los sustentan. Las pautas de juicio indican qué significa cada calificación, cómo elegir entre calificaciones y qué hacer con los casos que quedan entre ellas.

WANDS publicó las pautas que usaban sus anotadores: ocho páginas, bajo la licencia MIT (pautas de anotación). Para cada par, enumeran lo que ve el juez: la consulta y el ID, el nombre, la imagen y la página web del producto. Definen las tres calificaciones y añaden dos notas: una pide al juez que entienda primero la consulta, con la frase «Se recomienda encarecidamente buscarlo en Google primero», y otra indica que se deben ignorar las faltas de ortografía y anotar el par tal como está escrito. Luego enseñan con ejemplos, dando para cada calificación una consulta, un producto y una razón: una cesta de alambre sin divisiones es parcial para wire basket with dividers, una de las consultas de la propia tienda sobre trenes, y una alfombrilla antifatiga de salón es irrelevante para salon chair, porque el cliente busca una silla de salón, no una alfombrilla. Las pautas también cambian a medida que los jueces las usan. Los autores de WANDS afirman que el acuerdo de sus anotadores aumentó a lo largo de cuatro meses, y entre las razones que dan figuran una rutina diaria para discutir las anotaciones en conflicto y unas pautas refinadas con la aportación de los anotadores (Chen et al., 2022, sección 5). Las pautas de evaluadores de un buscador web hacen lo mismo, en 182 páginas en su versión del 11 de septiembre de 2025 (Directrices de evaluación de la calidad de búsqueda).

Las dos indicaciones de la grabación son pautas de juicio para el LLM. short contiene solo las tres definiciones de WANDS; guidelines las conserva y añade cinco reglas, así que se muestra la grabación tal como la envió:

La indicación de guidelines es la más larga de las dos, con 206 palabras frente a 59 de short. Sus dos primeras reglas desarrollan la definición de parcial de WANDS: primero encontrar la entidad, luego los modificadores. La regla sobre accesorios resuelve un caso que las propias etiquetas de WANDS dividen: para clear shower curtain, WANDS incluye un mismo juego de ganchos para cortina de ducha dos veces, una como parcial y otra como irrelevante (Espera que los jueces discrepen). La regla sobre faltas de ortografía sigue la nota de WANDS. La última regla no tiene equivalente en las pautas de WANDS, porque los datos de la tienda no contienen imágenes, así que la grabación muestra al LLM solo el texto. Ninguna de las dos indicaciones incluye ejemplos resueltos, en los que sí se apoyan las pautas de WANDS.

Regla práctica: Escribe las pautas como definiciones, un procedimiento, un ejemplo resuelto con una razón para cada calificación y una regla para cada caso en el que tus jueces hayan discrepado. Registra las discrepancias y revisa las pautas cuando un mismo tipo vuelva a aparecer. Da a un juez LLM las mismas pautas que a las personas, más una regla sobre lo que no puede ver, y después mide lo que hace, porque una regla que tú escribes no es una regla que el juez siga.

Mide el acuerdo más allá del azar con kappa

Último cambio en la edición 2026.11.10

Antes de confiar en un segundo juez, mide con qué frecuencia coincide con el primero. La proporción de pares en los que dos jueces dan la misma calificación, el acuerdo observado, es el número obvio, y resulta engañosamente favorable. Dos jueces que hubieran adivinado de forma independiente coincidirían en algunos pares por azar, y en más de ellos cuando ambos usan con frecuencia una misma etiqueta. El kappa de Cohen corrige el acuerdo observado por el azar, comparándolo con el acuerdo esperado si cada juez conservara sus propias proporciones de etiquetas pero eligiera de forma independiente del otro. Un kappa de 1 significa acuerdo completo, y 0 significa "ningún acuerdo más allá de lo que cabría esperar por azar" (documentación de scikit-learn):

kappa    = (observed - expected) / (1 - expected)
expected = sum over grades g of  (share of pairs judge A gives g) × (share of pairs judge B gives g)

El conjunto de entrenamiento, para medir el acuerdo, contiene pares que personas juzgaron para consultas de entrenamiento, extraídos de forma equilibrada por etiqueta: hasta 4 de cada etiqueta por consulta, 550 pares en total. El conjunto de prueba contiene los pares que un LLM calificaría para puntuar los rankers de la tienda: cada producto del top 10 de los cuatro rankers del capítulo 1 para cada consulta de prueba, juzgados por personas o no, 590 pares. Los cuatro son BM25, la recuperación semántica con embeddings de Snowflake/snowflake-arctic-embed-m-v1.5, el híbrido de ambos, y el híbrido reordenado por el codificador cruzado Alibaba-NLP/gte-reranker-modernbert-base. Cada medición del juez LLM vale para el conjunto sobre el que se toma, así que este capítulo nombra el conjunto cada vez.

La pregunta es con qué frecuencia el LLM de la grabación califica un par del mismo modo que los jueces de la tienda. El conjunto de entrenamiento, con el prompt short (solo las tres definiciones de WANDS), responde a ella. Una tabla de 3×3 con recuentos, construida a mano, da el kappa, y cohen_kappa_score de scikit-learn lo comprueba:

kappa-by-hand.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Builds the 3×3 table of the store's grades against the short prompt's on the train pool, then computes observed agreement, chance agreement and kappa from it. The prose's point rests on the printed kappa by hand, which matches the scikit-learn line."""import numpy as npfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import graded_pairspairs = graded_pairs("train")                     # up to 4 human-judged pairs per label per train query# the grades are nullable integers; plain ones compare and count the way the formulas below expecthuman, llm = pairs["human"].astype(int), pairs["short"].astype(int)grades = [2, 1, 0]                                # exact, partial, irrelevantcounts = np.array([[((human == row) & (llm == column)).sum() for column in grades] for row in grades])print("pairs:", counts.sum())print("rows are the human grades 2, 1, 0 and columns the LLM's, short prompt")print(counts)observed = np.trace(counts) / counts.sum()                          # the share of pairs on the diagonalhuman_share, llm_share = counts.sum(axis=1) / counts.sum(), counts.sum(axis=0) / counts.sum()expected = (human_share * llm_share).sum()                          # agreement if the two judged independentlykappa = (observed - expected) / (1 - expected)print(f"observed agreement, short prompt: {observed:.3f}")print(f"agreement expected by chance, short prompt: {expected:.3f}")print(f"kappa by hand, short prompt: {kappa:.3f}")print(f"kappa from scikit-learn, short prompt: {cohen_kappa_score(human, llm):.3f}")other = pairs["guidelines"].astype(int)print(f"observed agreement, guidelines prompt: {(human == other).mean():.3f}")print(f"kappa from scikit-learn, guidelines prompt: {cohen_kappa_score(human, other):.3f}")
Salidapython kappa-by-hand.py
pairs: 550
rows are the human grades 2, 1, 0 and columns the LLM's, short prompt
[[102  85   9]
 [ 22 132  46]
 [  3  42 109]]
observed agreement, short prompt: 0.624
agreement expected by chance, short prompt: 0.337
kappa by hand, short prompt: 0.432
kappa from scikit-learn, short prompt: 0.432
observed agreement, guidelines prompt: 0.633
kappa from scikit-learn, guidelines prompt: 0.454

El LLM y los jueces de la tienda dan la misma calificación a 0.624 de los pares de entrenamiento, y el azar solo produciría 0.337. Kappa resta esa proporción debida al azar del acuerdo observado, y luego divide entre el margen que queda por encima del azar, lo que da 0.432 para short, igual que 0.432 de scikit-learn.

guidelines coincide con los jueces un poco más a menudo que short, en 0.633 de los pares, para un kappa de 0.454.

¿Es bueno? Las escalas que califican un kappa de "moderado" o "sustancial" son convenciones de campos concretos. El estudio de Artstein y Poesio concluye que elegir un nivel de acuerdo adecuado para un propósito específico es "todavía poco más que un arte negro" (Artstein y Poesio, 2008).

Las cifras publicadas dan contexto, no un umbral. Los anotadores de WANDS coincidieron entre sí con un kappa de 0.467 en sus dos primeros meses y de 0.826 en el cuarto (Chen et al., 2022, Tabla 2).

En una muestra estratificada de pares de TREC, las evaluaciones compartidas de la Text REtrieval Conference, Thomas et al. hallaron que el kappa de GPT-4 frente a los evaluadores iba desde tan solo 0.20 hasta 0.64, según el prompt. Dos grupos de evaluadores humanos entrenados alcanzaron 0.52 en documentos ad hoc de TREC que juzgaron una segunda vez (Cormack et al., 1998, según lo citado por Thomas et al., 2024). Cada cifra procede de una muestra distinta, y el kappa depende de la proporción de etiquetas de la muestra.

Regla práctica: Informa el kappa, con el acuerdo observado junto a él, nunca el acuerdo observado solo. Mídelo sobre pares que personas juzgaron para consultas de entrenamiento, y etiqueta cualquier umbral que uses como una regla práctica. Con más de dos jueces o con etiquetas faltantes, usa el alfa de Krippendorff, que compara el desacuerdo observado con el desacuerdo por azar y admite cualquier número de observadores y datos incompletos (Krippendorff, 2011).

Dale crédito parcial a los casi aciertos con kappa ponderado

Último cambio en la edición 2026.11.8

Kappa cuenta cada desacuerdo igual. Las calificaciones de la tienda están ordenadas: exacto por encima de parcial, y parcial por encima de irrelevante. Llamar exacto a un producto parcial es un error menor que llamarlo irrelevante. En nDCG@10 (Puntúa un ranking) cuesta la mitad de ganancia: una calificación en lugar de dos. El kappa ponderado asigna a cada desacuerdo un peso según su distancia y compara el desacuerdo ponderado con el desacuerdo ponderado esperado por azar (Artstein y Poesio, 2008, sección 2.6). Con pesos lineales, un desacuerdo de una calificación de distancia pesa 0.5 y uno de dos calificaciones pesa 1:

weighted kappa = 1 - (sum of weight × observed count) / (sum of weight × count expected by chance)

Con cada desacuerdo pesando 1, la fórmula da el kappa simple. La función cohen_kappa_score de scikit-learn calcula los tres tipos de esta forma: peso 1 por defecto, la distancia entre calificaciones con weights="linear", y su cuadrado con weights="quadratic" (código fuente de scikit-learn). Escalar los pesos no cambia el resultado.

Para ambos prompts, el ejemplo construye a mano los pesos lineales sobre los pares de entrenamiento repartidos de forma uniforme de Mide el acuerdo más allá del azar, y luego compara cada resultado con scikit-learn:

weighted-kappa-by-hand.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Computes linear weighted kappa by hand for both prompts on the train pool and checks each against scikit-learn. The prose's point rests on the two linear weighted kappa lines, which match scikit-learn's, and on the one-grade-apart shares beside them."""import numpy as npfrom sklearn.metrics import cohen_kappa_score, confusion_matrixfrom lib.agreement import PROMPTS, graded_pairspairs = graded_pairs("train")                     # up to 4 human-judged pairs per label per train querygrades = [2, 1, 0]                                # exact, partial, irrelevantcost = np.abs(np.subtract.outer(grades, grades)) / 2    # 0 on the diagonal, 0.5 one grade apart, 1 two apartprint("disagreement weights, rows and columns 2, 1, 0")print(cost)for prompt in PROMPTS:    human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)    # labels fixes the rows and columns to 2, 1, 0 in that order, not the order the grades first appear    counts = confusion_matrix(human, llm, labels=grades)                       # rows human, columns LLM    expected = np.outer(counts.sum(axis=1), counts.sum(axis=0)) / counts.sum()   # counts if independent    weighted = 1 - (cost * counts).sum() / (cost * expected).sum()    near = cost == 0.5                                                         # cells one grade apart    print()    # row 0 is exact and column 2 is irrelevant, so these two corners are the far misses    print(f"pairs two grades apart, {prompt} prompt: {counts[0, 2] + counts[2, 0]}")    print(f"disagreements one grade apart, share, {prompt} prompt: {counts[near].sum() / counts[cost > 0].sum():.3f}")    print(f"one grade apart, share expected by chance, {prompt} prompt: {expected[near].sum() / expected[cost > 0].sum():.3f}")    print(f"kappa, {prompt} prompt: {cohen_kappa_score(human, llm):.3f}")    print(f"linear weighted kappa by hand, {prompt} prompt: {weighted:.3f}")    print(f"linear weighted kappa from scikit-learn, {prompt} prompt: "          f"{cohen_kappa_score(human, llm, weights='linear'):.3f}")
Salidapython weighted-kappa-by-hand.py
disagreement weights, rows and columns 2, 1, 0
[[0.  0.5 1. ]
 [0.5 0.  0.5]
 [1.  0.5 0. ]]

pairs two grades apart, short prompt: 12
disagreements one grade apart, share, short prompt: 0.942
one grade apart, share expected by chance, short prompt: 0.742
kappa, short prompt: 0.432
linear weighted kappa by hand, short prompt: 0.523
linear weighted kappa from scikit-learn, short prompt: 0.523

pairs two grades apart, guidelines prompt: 30
disagreements one grade apart, share, guidelines prompt: 0.851
one grade apart, share expected by chance, guidelines prompt: 0.664
kappa, guidelines prompt: 0.454
linear weighted kappa by hand, guidelines prompt: 0.531
linear weighted kappa from scikit-learn, guidelines prompt: 0.531

Ponderar eleva el kappa de short de 0.432 a 0.523, y el de guidelines de 0.454 a 0.531, y ambos coinciden con scikit-learn. Lo eleva porque los desacuerdos caen a una calificación de distancia más a menudo de lo que el azar los pondría: 0.942 de los de short frente a 0.742, y 0.851 de los de guidelines frente a 0.664.

Los prompts también difieren en sus fallos lejanos, los pares a dos calificaciones de distancia: 12 para short y 30 para guidelines. Cuál de los dos prompts concuerda mejor es una pregunta para un intervalo.

Regla práctica: Para calificaciones ordenadas, informa el kappa ponderado lineal junto al kappa simple, y cuenta los fallos lejanos por separado. Pondera cada desacuerdo según la diferencia de ganancia que cuesta. Con las ganancias lineales del libro, eso son pesos lineales. Con ganancias exponenciales de 0, 1 y 3 (Elige una métrica), las diferencias son 1, 2 y 3, que ninguna de las dos opciones de scikit-learn ofrece, así que construye esa matriz como el ejemplo construye la lineal.

Lee el kappa frente a la mezcla de etiquetas

Último cambio en la edición 2026.11.8

La corrección del kappa depende de con qué frecuencia cada juez usa cada etiqueta, así que el mismo juez obtiene un kappa distinto en una muestra con una mezcla de etiquetas diferente. Cuando una etiqueta domina, el acuerdo observado puede ser alto mientras el kappa sigue siendo bajo. Artstein y Poesio llaman a esto el problema de la prevalencia: "los codificadores pueden coincidir en una proporción alta de elementos y producir anotaciones que son en efecto correctas en un alto grado, y aun así los coeficientes de fiabilidad siguen siendo bajos" (Artstein y Poesio, 2008).

La grabación extrajo el conjunto de entrenamiento de forma equilibrada entre etiquetas, hasta 4 pares de cada etiqueta por consulta de entrenamiento, así que el conjunto contiene más pares exactos e irrelevantes de lo que contienen los juicios de la tienda. Para ver qué efecto tiene eso sobre el kappa, pondera cada par para que el conjunto tenga la mezcla de etiquetas de todos los juicios de las consultas de entrenamiento, y vuelve a medir:

kappa-under-two-label-mixes.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Measures each prompt's agreement with the store's judges on the train pool, as drawn and reweighted to the label mix of all the train judgments. The prose's point rests on the kappa lines for each mix and on the higher-kappa lines, which change with the mix."""import numpy as npfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, PROMPTS, graded_pairsfrom lib.store import load_labels, load_queriespairs = graded_pairs("train")                     # drawn evenly: up to 4 pairs per label per train querydrawn = pairs["human"].value_counts(normalize=True)labels = load_labels()# every judged label for the train queries, not only the pairs that were drawnnatural = labels[labels["query_id"].isin(load_queries("train").index)]["grade"].value_counts(normalize=True)top = graded_pairs("test")["human"].dropna().value_counts(normalize=True)    # the rankers' top 10s, judged pairsfor grade, label in LABELS.items():    print(f"{label} share, as drawn: {drawn[grade]:.3f}")    print(f"{label} share, in the train judgments: {natural[grade]:.3f}")    print(f"{label} share, judged test-pool pairs: {top[grade]:.3f}")# each pair counts for its label's share in the judgments divided by its share as drawnweight = pairs["human"].map(natural / drawn).astype(float)            # count each pair as if drawn in that mixkappas = {}for prompt in PROMPTS:    human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)    print()    print(f"observed agreement, {prompt} prompt, as drawn: {(human == llm).mean():.3f}")    print(f"kappa, {prompt} prompt, as drawn: {cohen_kappa_score(human, llm):.3f}")    print(f"observed agreement, {prompt} prompt, train judgments' mix: {np.average(human == llm, weights=weight):.3f}")    # sample_weight counts each pair that many times; it is not the linear weights of the last section    kappas[prompt] = cohen_kappa_score(human, llm), cohen_kappa_score(human, llm, sample_weight=weight)    print(f"kappa, {prompt} prompt, train judgments' mix: {kappas[prompt][1]:.3f}")print()for position, mix in enumerate(["as drawn", "train judgments' mix"]):    # on a tie, max returns the first prompt, short    print(f"higher kappa, {mix}: {max(PROMPTS, key=lambda prompt: kappas[prompt][position])}")
Salidapython kappa-under-two-label-mixes.py
exact share, as drawn: 0.356
exact share, in the train judgments: 0.234
exact share, judged test-pool pairs: 0.543
partial share, as drawn: 0.364
partial share, in the train judgments: 0.613
partial share, judged test-pool pairs: 0.427
irrelevant share, as drawn: 0.280
irrelevant share, in the train judgments: 0.153
irrelevant share, judged test-pool pairs: 0.030

observed agreement, short prompt, as drawn: 0.624
kappa, short prompt, as drawn: 0.432
observed agreement, short prompt, train judgments' mix: 0.635
kappa, short prompt, train judgments' mix: 0.370

observed agreement, guidelines prompt, as drawn: 0.633
kappa, guidelines prompt, as drawn: 0.454
observed agreement, guidelines prompt, train judgments' mix: 0.573
kappa, guidelines prompt, train judgments' mix: 0.345

higher kappa, as drawn: guidelines
higher kappa, train judgments' mix: short

Las etiquetas parciales constituyen 0.364 del conjunto tal como se extrajo, pero 0.613 de los juicios de entrenamiento, así que la ponderación cuenta los pares parciales con más peso y los pares exactos e irrelevantes con menos.

En la mezcla de los juicios, el acuerdo observado de short pasa de 0.624 a 0.635, y su kappa de 0.432 a 0.370. Para guidelines, el acuerdo observado pasa de 0.633 a 0.573, y el kappa de 0.454 a 0.345.

El prompt con el kappa más alto es guidelines tal como se extrajo, y short en la mezcla de los juicios.

Las cifras publicadas arrastran consigo su mezcla. El único estudio sobre jueces LLM en WANDS que encontramos extrajo 5,000 pares consulta-producto de forma equilibrada entre las tres etiquetas. Informa de una exactitud que va de 0.726 para el mejor modelo abierto, con 70 000 millones de parámetros, a 0.837 para el mejor cerrado, cada uno en su mejor configuración, con 16 ejemplos resueltos recuperados para cada par (Sachdev et al., 2025, Tabla 3). Los prompts de la tienda no tienen ejemplos resueltos. Esa exactitud es un acuerdo observado sobre una muestra equilibrada, como lo es el del conjunto de entrenamiento, así que ninguna de las dos cifras se traslada a la mezcla de etiquetas de los juicios de la tienda.

Los pares que la tienda pedirá a un LLM que juzgue son los productos que sus rankers colocan en sus top 10, el conjunto de prueba. De sus pares juzgados, 0.543 son exactos, 0.427 parciales y 0.030 irrelevantes. Esa es una tercera mezcla, y un tipo de par distinto, que mide Lee la dirección de los errores del LLM.

Regla práctica: Informa de la mezcla de etiquetas junto a cada kappa, y nunca compares kappas de muestras con mezclas distintas, sean tuyos o publicados. Te recomendamos extraer la muestra de acuerdo de la misma forma en que vas a usar el juez: si va a evaluar los top 10 de tus rankers, extrae pares de los top 10 en consultas de entrenamiento.

Lee la dirección de los errores del LLM

Último cambio en la edición 2026.11.10

Kappa indica cuánto coinciden dos jueces, no en qué difieren. Una matriz de confusión muestra cómo difieren dos jueces: una tabla de recuentos con una fila para cada calificación de la tienda y una columna para cada una del LLM, ambas en el orden exacto, parcial, irrelevante. Por encima de la diagonal, el LLM dio una calificación más baja que los jueces de la tienda; por debajo, una más alta. Un juez cuyos errores caen mayoritariamente por debajo es indulgente, y si caen mayoritariamente por encima, estricto.

Varios estudios encuentran que los jueces LLM son indulgentes. En la pista RAG de TREC 2024, que evalúa la generación aumentada por recuperación (respuestas escritas a partir de texto recuperado), los evaluadores humanos parecen más estrictos en conjunto que UMBRELA, un juez LLM de código abierto (Upadhyay et al., 2024a). Arabzadeh y Clarke informan de que UMBRELA, basado en GPT-4o (Upadhyay et al., 2024b), etiquetó más de un 26 % más de documentos como perfectamente relevantes que las personas en las pistas Deep Learning de TREC de 2019 a 2021, 3,063 frente a 2,429 (Arabzadeh y Clarke, 2025a). Yu et al. informan de que los jueces LLM "dan de forma consistente puntuaciones de relevancia infladas" (Yu et al., 2026).

No todos los estudios coinciden. Thomas et al., con uno de sus 32 prompts sobre una muestra estratificada por etiqueta, hallaron que el LLM era más propenso que los evaluadores de TREC a considerar que un par no es relevante, 44 % frente a 33 % (Thomas et al., 2024).

Una matriz para cada prompt en cada conjunto muestra en qué sentido yerra el LLM, y si esa dirección se mantiene al pasar de los pares de entrenamiento equilibrados a los 10 primeros de los rankers: el conjunto de entrenamiento se extrae de forma equilibrada por etiqueta, y los pares evaluados del conjunto de prueba son los 10 primeros de los cuatro rankers del capítulo 1 que un LLM calificaría. Las matrices del conjunto de prueba informan sobre las consultas de prueba; no sirven para elegir un prompt:

llm-confusion-matrix.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Prints the confusion matrix of the store's grades against each prompt's grades, on the train pool and on the judged test pairs, with the counts of lower and higher grades. The prose's point rests on the 'stricter' line for each pool, read with the largest error printed beside it."""import pandas as pdfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, PROMPTS, graded_pairsorder = list(LABELS.values())                     # rows: the store's grades; columns: the LLM's; both exact firstfor pool in ["train", "test"]:    pairs = graded_pairs(pool).dropna(subset=["human"])                    # in the test pool, the pairs people judged    human = pairs["human"].astype(int)    print(f"\njudged pairs, {pool} pool: {len(pairs)}\nmean human grade, {pool} pool: {human.mean():.3f}")    for prompt in PROMPTS:        llm, name = pairs[prompt].astype(int), f"{pool} pool, {prompt} prompt"        table = pd.crosstab(human.map(LABELS).rename("human"), llm.map(LABELS).rename(f"llm, {name}"))        table = table.reindex(index=order, columns=order, fill_value=0)        errors = {f"{row} called {column}": table.at[row, column] for row in order for column in order if row != column}        # on a tie, max returns the first cell, in row order        largest = max(errors, key=errors.get)        print(table)        print(f"kappa, {name}: {cohen_kappa_score(human, llm):.3f}\nmean llm grade, {name}: {llm.mean():.3f}")        print(f"llm grade higher than human, {name}: {(llm > human).sum()}")        print(f"llm grade lower than human, {name}: {(llm < human).sum()}")        # a tie counts as not stricter        print(f"stricter than the store's judges, {name}: {'yes' if (llm < human).sum() > (llm > human).sum() else 'no'}")        print(f"largest error, {name}: {largest} ({errors[largest]})")
Salidapython llm-confusion-matrix.py

judged pairs, train pool: 550
mean human grade, train pool: 1.076
llm, train pool, short prompt  exact  partial  irrelevant
human
exact                            102       85           9
partial                           22      132          46
irrelevant                         3       42         109
kappa, train pool, short prompt: 0.432
mean llm grade, train pool, short prompt: 0.933
llm grade higher than human, train pool, short prompt: 67
llm grade lower than human, train pool, short prompt: 140
stricter than the store's judges, train pool, short prompt: yes
largest error, train pool, short prompt: exact called partial (85)
llm, train pool, guidelines prompt  exact  partial  irrelevant
human
exact                                 118       53          25
partial                                30       98          72
irrelevant                              5       17         132
kappa, train pool, guidelines prompt: 0.454
mean llm grade, train pool, guidelines prompt: 0.862
llm grade higher than human, train pool, guidelines prompt: 52
llm grade lower than human, train pool, guidelines prompt: 150
stricter than the store's judges, train pool, guidelines prompt: yes
largest error, train pool, guidelines prompt: partial called irrelevant (72)

judged pairs, test pool: 564
mean human grade, test pool: 1.512
llm, test pool, short prompt  exact  partial  irrelevant
human
exact                           252       53           1
partial                          57      177           7
irrelevant                        2        6           9
kappa, test pool, short prompt: 0.571
mean llm grade, test pool, short prompt: 1.521
llm grade higher than human, test pool, short prompt: 65
llm grade lower than human, test pool, short prompt: 61
stricter than the store's judges, test pool, short prompt: no
largest error, test pool, short prompt: partial called exact (57)
llm, test pool, guidelines prompt  exact  partial  irrelevant
human
exact                                261       41           4
partial                               76      133          32
irrelevant                             3        4          10
kappa, test pool, guidelines prompt: 0.470
mean llm grade, test pool, guidelines prompt: 1.521
llm grade higher than human, test pool, guidelines prompt: 83
llm grade lower than human, test pool, guidelines prompt: 77
stricter than the store's judges, test pool, guidelines prompt: no
largest error, test pool, guidelines prompt: partial called exact (76)

¿Es el LLM más estricto que los jueces de la tienda en el conjunto de entrenamiento? Con short: yes. Con guidelines: yes. Con short califica 140 pares más bajo y 67 más alto, y con guidelines, 150 más bajo y 52 más alto. El mayor error es exact called partial (85) con short, y partial called irrelevant (72) con guidelines.

En el conjunto de prueba, la respuesta es no con short y no con guidelines. Con short, la calificación del LLM es más alta en 65 pares y más baja en 61; con guidelines, más alta en 83 y más baja en 77. Su calificación media es 1.521 con short y 1.521 con guidelines, frente a 1.512 para los jueces. Sus mayores errores son partial called exact (57) con short y partial called exact (76) con guidelines.

Kappa es 0.571 con short y 0.470 con guidelines, frente a 0.432 y 0.454 en el conjunto de entrenamiento. La dirección, el mayor error y kappa cambian todos con el conjunto, como advierte la mezcla de etiquetas. Compara lo que vio el LLM encuentra un patrón que encaja con ambos conjuntos.

Tampoco la dirección de los errores dice qué ocurre con la puntuación de un ranker. Un juez indulgente cuenta más productos como relevantes, lo que eleva la precisión@10 (Cuenta los productos relevantes). nDCG@10 divide entre un top 10 ideal construido con las mismas calificaciones (Puntúa un ranking), así que al subir las calificaciones también puede subir el ideal, y el efecto neto puede ir en cualquier sentido y diferir según el ranker. La comprobación del orden de los rankers lo mide en el conjunto de prueba.

Regla práctica: Lee la matriz de confusión antes que kappa, con pares extraídos de la misma forma en que usarás el juez, y nombra la dirección y el mayor error para ese conjunto. No traslades una dirección de un conjunto a otro, y no predigas a partir de ella el nDCG@10 de un ranker. Compara los rankers entre sí bajo las mismas calificaciones, y nunca compares una puntuación con calificaciones del LLM con una puntuación con calificaciones humanas.

Compara lo que vio el LLM con lo que vieron los jueces

Último cambio en la edición 2026.11.8

Un juez solo puede calificar la evidencia que se le muestra. Los jueces de WANDS vieron la consulta y el ID, el nombre, la imagen y la página web del producto, y las pautas les pedían entender primero la consulta: "Strongly recommend google it first" (pautas de anotación). La grabación le mostró al LLM el nombre, la clase, la categoría, la descripción y los atributos de cada producto, tal como lib.agreement.as_the_llm_saw los escribe. La muestra de la tienda recorta las descripciones a unos 400 caracteres (ficha de datos) y no contiene imágenes, así que la grabación envió al LLM solo texto. Parte del desacuerdo puede venir de esta brecha y no de qué tan bien juzga el LLM; esto es nuestra inferencia. Una consecuencia puede comprobarse: si el LLM califica lo que está escrito, debería dar una calificación más baja a los productos exactos cuyo texto no dice lo que pide la consulta, y una calificación más alta a los productos parciales cuyo texto sí lo dice.

Esta verificación toma un par de entrenamiento, luego la consulta de prueba clear shower curtain y cada par exacto y parcial juzgado en ambos conjuntos (la grabación). Busca cada palabra de la consulta en lo que vio el LLM, dividido en palabras en minúsculas de la misma forma que la verificación del capítulo 2:

llm-grades-follow-written-words.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Checks whether the LLM's grades follow the words in each product's text, for one train pair, for the clear shower curtain products, and across both pools. The prose's point rests on the 'share graded lower' and 'share graded higher' lines, which compare pairs whose text has every query word with pairs that miss one."""import refrom lib.agreement import PROMPTS, as_the_llm_saw, graded_pairsfrom lib.store import load_products, load_queriesdef words(text):    """Lowercase word tokens, as chapter 2 matches query words against product text."""    # runs of letters, digits and underscores, so 7qt is one word and '7 qt' is two    return set(re.findall(r"\w+", text.lower()))products, queries = load_products(), load_queries()# query 163 is a train query, and product 20718 is the pair the prose followsprint("query:", queries.at[163, "query"])                              # a train queryprint(as_the_llm_saw(products.loc[20718]))print("grades from people, short, guidelines:", *graded_pairs("train").set_index(["query_id", "product_id"]).loc[(163, 20718)])curtains = graded_pairs("test").query("query_id == 246")      # clear shower curtain: every product in a top 10# whole words only, so 'unclear' doesn't count as saying clearsays = curtains["product_id"].map(lambda product_id: "clear" in words(as_the_llm_saw(products.loc[product_id])))for kind, group in [("say clear", curtains[says]), ("never say clear", curtains[~says])]:    print(f"\nclear shower curtain products that {kind}: {len(group)}")    for column, judge in [("human", "people"), ("short", "the short prompt"), ("guidelines", "the guidelines prompt")]:        print(f"products that {kind}, graded exact by {judge}: {(group[column] == 2).sum()}")for pool in ["train", "test"]:    pairs = graded_pairs(pool).dropna(subset=["human"])                     # in the test pool, the pairs people judged    # subset: every query word appears in the text the LLM saw    pairs["every word"] = [words(queries.at[query_id, "query"]) <= words(as_the_llm_saw(products.loc[product_id]))                           for query_id, product_id in zip(pairs["query_id"], pairs["product_id"])]    # share of each group that the LLM grades below people (exact) or above them (partial), for each prompt    for label, grade, every_word, direction in [("exact", 2, False, "lower"), ("exact", 2, True, "lower"),                                                ("partial", 1, True, "higher"), ("partial", 1, False, "higher")]:        group = pairs[(pairs["human"] == grade) & (pairs["every word"] == every_word)]        kind = f"{label} {pool} pairs {'with every query word' if every_word else 'missing a query word'}"        print(f"\n{kind}: {len(group)}")        for prompt in PROMPTS:            moved = group[prompt] < grade if direction == "lower" else group[prompt] > grade            print(f"share graded {direction}, {prompt} prompt, {kind}: {moved.mean():.3f}")
Salidapython llm-grades-follow-written-words.py
query: dual monitor stand
Name: abramowski monitor stand
Class: Desktop Organizers & Desk Pads
Category:
Description: the monitor stand riser can help !
Attributes: color: white; material: wood; style: modern; width: 23.5; height: 4.64; depth: 9.2
grades from people, short, guidelines: 2 1 1

clear shower curtain products that say clear: 9
products that say clear, graded exact by people: 5
products that say clear, graded exact by the short prompt: 7
products that say clear, graded exact by the guidelines prompt: 7

clear shower curtain products that never say clear: 9
products that never say clear, graded exact by people: 1
products that never say clear, graded exact by the short prompt: 0
products that never say clear, graded exact by the guidelines prompt: 0

exact train pairs missing a query word: 149
share graded lower, short prompt, exact train pairs missing a query word: 0.584
share graded lower, guidelines prompt, exact train pairs missing a query word: 0.483

exact train pairs with every query word: 47
share graded lower, short prompt, exact train pairs with every query word: 0.149
share graded lower, guidelines prompt, exact train pairs with every query word: 0.128

partial train pairs with every query word: 8
share graded higher, short prompt, partial train pairs with every query word: 0.875
share graded higher, guidelines prompt, partial train pairs with every query word: 0.875

partial train pairs missing a query word: 192
share graded higher, short prompt, partial train pairs missing a query word: 0.078
share graded higher, guidelines prompt, partial train pairs missing a query word: 0.120

exact test pairs missing a query word: 128
share graded lower, short prompt, exact test pairs missing a query word: 0.305
share graded lower, guidelines prompt, exact test pairs missing a query word: 0.281

exact test pairs with every query word: 178
share graded lower, short prompt, exact test pairs with every query word: 0.084
share graded lower, guidelines prompt, exact test pairs with every query word: 0.051

partial test pairs with every query word: 42
share graded higher, short prompt, partial test pairs with every query word: 0.548
share graded higher, guidelines prompt, partial test pairs with every query word: 0.667

partial test pairs missing a query word: 199
share graded higher, short prompt, partial test pairs missing a query word: 0.171
share graded higher, guidelines prompt, partial test pairs missing a query word: 0.241

Para dual monitor stand, una consulta de entrenamiento, los jueces de la tienda calificaron abramowski monitor stand como exacto, y ambas indicaciones lo calificaron como parcial (2 1 1, en ese orden); nada de lo que vio el LLM dice que el soporte tiene dos monitores.

Para clear shower curtain, las calificaciones exactas del LLM siguen la palabra. De los 9 productos del conjunto de prueba que dicen clear en algún lugar que el LLM pudo leer, los jueces llamaron 5 exactos, short 7 y guidelines 7. De los 9 que nunca lo dicen, los jueces llamaron 1 exactos, y short 0 y guidelines 0.

Contado sobre los conjuntos, el patrón se sostiene. Con short, los pares exactos cuyo texto no contiene una palabra de la consulta reciben una calificación más baja del LLM en una proporción de 0.584 en el conjunto de entrenamiento y 0.305 en el de prueba, frente a 0.149 y 0.084 para los pares exactos cuyo texto tiene todas las palabras.

En el conjunto de prueba, los que tienen en su texto todas las palabras de la consulta reciben una calificación más alta en una proporción de 0.548, frente a 0.171 para los que les falta una palabra. En el conjunto de prueba, guidelines se divide de la misma forma: 0.281 frente a 0.051 para los pares exactos, y 0.667 frente a 0.241 para los parciales.

Los conjuntos difieren en qué caso es común. El conjunto de entrenamiento tiene 149 pares exactos a los que les falta una palabra y 8 pares parciales con todas las palabras; el conjunto de prueba tiene 128 y 42. Según nuestra lectura, esa es la razón por la que la dirección de los errores difiere entre los conjuntos. La verificación es aproximada: un plural o una falta de ortografía también cuenta como palabra que falta. La indicación guidelines pide las rebajas: "If a modifier isn't mentioned, decide from what is written, and don't assume it is met." La indicación short no tiene una regla así, y también rebaja.

Regla práctica: Da a un juez LLM todos los campos en los que se basaron tus jueces y que puedas convertir en texto, como los atributos y la descripción completa, y anota lo que no puede ver. Antes de contar un desacuerdo en contra del LLM, comprueba si la evidencia estaba en lo que vio. Cuando la evidencia de tus jueces es visual, mide si el LLM califica más bajo los productos exactos, como en este caso en ambos conjuntos, o dale las imágenes si tu modelo las acepta.

Mide cuánto cambian las etiquetas según el prompt

Último cambio en la edición 2026.11.8

Un juez basado en LLM es un modelo y un prompt a la vez. En 42 parafraseos de un mismo prompt, Thomas et al. encontraron que los kappa medios variaban entre 0.50, que ellos llaman acuerdo moderado, y 0.72. Advierten de que la puntuación de un solo prompt es una extracción única del rango que un juez podría alcanzar (Thomas et al., 2024).

En tres LLM y 72 prompts sobre las colecciones Deep Learning de TREC, Arabzadeh y Clarke hallaron que los métodos binarios y por pares eran los menos sensibles a la redacción del prompt, mientras que los juicios de relevancia graduada, el tipo que usa la tienda, eran muy sensibles a ella (Arabzadeh y Clarke, 2025b). Ningún prompt fue el mejor para todos los LLM, aunque UMBRELA obtuvo buenos resultados de forma consistente en evaluaciones graduadas con distintos LLM.

Los dos prompts comparten sus definiciones, y guidelines añade cinco reglas sobre ellas (Redactar directrices de juicio). Cada conjunto de la grabación muestra dónde discrepan los prompts, y el conjunto de entrenamiento indica si es posible saber cuál de los dos coincide mejor con los jueces de la tienda. Los pares de una misma consulta no son independientes, así que el intervalo remuestrea consultas de entrenamiento completas, como el bootstrap del capítulo 3 remuestrea consultas:

prompt-disagreement.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Counts where the two prompts disagree, their kappa with each other, and how far their kappas with people differ across resampled train queries. The prose's point rests on the 95% interval line, which includes 0 for this recording."""import numpy as npimport pandas as pdfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, graded_pairsfrom lib.store import load_products, load_queriesdef kappa_gap(sample):    """Kappa with people under the guidelines prompt, minus kappa under the short prompt."""    human = sample["human"].astype(int)    return cohen_kappa_score(human, sample["guidelines"].astype(int)) - cohen_kappa_score(human, sample["short"].astype(int))order = list(LABELS.values())                     # exact, partial, irrelevantfor pool in ["train", "test"]:    # the test pool includes pairs nobody judged, so these counts cover every pair    pairs = graded_pairs(pool)    print(f"\n{pool} pairs where the prompts disagree: {(pairs['short'] != pairs['guidelines']).sum()} of {len(pairs)}\n"          f"kappa between the prompts, {pool} pool: {cohen_kappa_score(pairs['short'], pairs['guidelines']):.3f}")    table = pd.crosstab(pairs["short"].map(LABELS).rename(f"short, {pool}"), pairs["guidelines"].map(LABELS).rename("guidelines"))    table = table.reindex(index=order, columns=order, fill_value=0)    cells = {f"{row} under short, {column} under guidelines": table.at[row, column] for row in order for column in order if row != column}    print(f"{table}\nlargest disagreement, {pool} pool: {max(cells, key=cells.get)} ({max(cells.values())})")pairs, products, queries = graded_pairs("train"), load_products(), load_queries()moved = pairs[(pairs["short"] == 1) & (pairs["guidelines"] == 0)]          # partial under one prompt, irrelevant under the otherprint("\n".join(f"moved train pairs judged {label} by people: {(moved['human'] == grade).sum()}" for grade, label in LABELS.items()))# the first five queries in order, not a random samplefor query_id, product_id in moved[["query_id", "product_id"]].drop_duplicates("query_id").head(5).itertuples(index=False):    print(f"  {queries.at[query_id, 'query']:<28} {products.at[product_id, 'name'][:50]}")# a fixed seed, so the interval is the same on every runrng, train_queries = np.random.default_rng(2026), pairs["query_id"].unique()by_query = {query_id: group for query_id, group in pairs.groupby("query_id")}# each resample draws train queries with replacement, so some repeat and others are left outgaps = [kappa_gap(pd.concat([by_query[query_id] for query_id in rng.choice(train_queries, len(train_queries))]))        for _ in range(2000)]                                               # resample whole train querieslow, high = np.percentile(gaps, [2.5, 97.5])print(f"kappa with people, guidelines minus short: {kappa_gap(pairs):.3f}\n95% interval over resampled train queries: {low:.3f} to {high:.3f}")
Salidapython prompt-disagreement.py

train pairs where the prompts disagree: 122 of 550
kappa between the prompts, train pool: 0.668
guidelines    exact  partial  irrelevant
short, train
exact           122        4           1
partial          31      153          75
irrelevant        0       11         153
largest disagreement, train pool: partial under short, irrelevant under guidelines (75)

test pairs where the prompts disagree: 93 of 590
kappa between the prompts, test pool: 0.712
guidelines   exact  partial  irrelevant
short, test
exact          303       11           1
partial         42      174          37
irrelevant       0        2          20
largest disagreement, test pool: partial under short, exact under guidelines (42)
moved train pairs judged exact by people: 18
moved train pairs judged partial by people: 31
moved train pairs judged irrelevant by people: 26
  toddler couch fold out       eulah 79 '' cotton rolled arm sofa bed
  70s inspired furniture       angels moroccan window curtains , oriental wavy cu
  7qt slow cooker              berghoff international eclipse 7 qt non-stick cove
  gnome fairy garden           fairy house tea pot fairy garden
  wall sconce with usb port    2 piece wall sconce set
kappa with people, guidelines minus short: 0.022
95% interval over resampled train queries: -0.042 to 0.086

Los dos prompts discrepan en 122 of 550 pares de entrenamiento y en 93 of 590 pares de prueba, y su kappa entre ellos es 0.668 en el conjunto de entrenamiento y 0.712 en el conjunto de prueba.

La mayor discrepancia varía según el conjunto. En el conjunto de entrenamiento es partial under short, irrelevant under guidelines (75); en el conjunto de prueba, los 10 primeros resultados de cada ranker, es partial under short, exact under guidelines (42).

De los pares de entrenamiento que short califica como parciales y guidelines como irrelevantes, los jueces de la tienda calificaron 26 como irrelevantes, dando la razón a guidelines, 31 como parciales, dando la razón a short, y 18 como exactos. Entre los pares que cambiaron, los ejemplos que se listan son un sofá cama para toddler couch fold out y cortinas para ventanas para 70s inspired furniture. La grabación guarda etiquetas, no razones, así que a partir de nombres como estos inferimos que el cambio proviene de la regla guidelines, que califica como irrelevante el tipo de producto equivocado.

En cuanto al kappa con los jueces de la tienda, guidelines supera a short en 0.022, y el intervalo del 95% sobre consultas de entrenamiento remuestreadas va de -0.042 to 0.086. Ese intervalo incluye el 0, así que el conjunto de entrenamiento no puede distinguir los prompts, y la tienda conserva ambos.

Regla práctica: Trata el prompt como parte del juez. Registra cada palabra del prompt tal cual, junto con la versión del modelo, la configuración y el esquema de respuesta, como hace esta grabación en su manifiesto y en su script. Considera que un cambio de prompt es un juez distinto cuyo acuerdo debes volver a medir. Usa al menos dos prompts y confía en una conclusión a partir de calificaciones de un LLM solo cuando ambos la respalden. Elige un prompt sobre otro basándote en los pares de entrenamiento, y solo cuando el intervalo de su diferencia no incluya el 0.

Rellenar los pares sin juzgar con calificaciones de LLM

Último cambio en la edición 2026.11.8

Consideramos que rellenar los huecos de los juicios humanos es el uso menos arriesgado de un juez LLM. Conserva cada calificación humana y usa el LLM solo para los pares que nadie juzgó, que una métrica contaría como calificación 0 (Contar productos sin juzgar). El LLM decide entonces únicamente lo que antes era una suposición.

De los 590 pares en los top 10 de los cuatro rankers del capítulo 1, 26 no están juzgados; los top 10 de BM25 contienen 22 de ellos, frente a 3 de la recuperación semántica y 6 del híbrido.

Deja que cada prompt los rellene, vuelve a puntuar los cuatro rankers con nDCG@10 (Puntuar un ranking) y repite las comparaciones planificadas del capítulo 3 con las calificaciones rellenadas:

fill-unjudged-pairs.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Fills the pairs nobody judged with each prompt's grades, then rescores the four rankers and the planned verdicts with the filled grades. The prose's point rests on the 'that change' lines, which list the rankers and verdicts that move when the holes are filled."""from lib.agreement import LABELS, PLANNED, PROMPTS, chapter_one_runs, fill_unjudged, graded_pairs, llm_qrels, planned_verdictsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsdef order(scores):    """Rankers by mean nDCG@10 over the test queries, best first."""    return sorted(scores, key=lambda name: scores[name].mean(), reverse=True)products, queries, people = load_products(), load_queries("test"), qrels("test")runs = chapter_one_runs(products, queries)pairs = graded_pairs("test")                      # every product in the top 10 of the four runs, per test queryunjudged = pairs[pairs["human"].isna()]print(f"pairs in the test pool: {len(pairs)}\nof them, unjudged: {len(unjudged)}")for name, run in runs.items():    # people[query_id] holds the human judgments for a query, so a product missing from it was never judged    missing = sum(product_id not in people[query_id] for query_id, ranking in run.items() for product_id in ranking[:10])    print(f"unjudged products in the top 10s, {name}: {missing}")lights = unjudged[unjudged["query_id"] == 133]                             # outdoor light fixturesprint(f"unjudged products for outdoor light fixtures: {len(lights)}\n"      f"of them, with bulb in the name: {lights['product_id'].map(products['name']).str.contains('bulb').sum()}")threshold = 0.05 / len(PLANNED)                                            # chapter 3's rulehuman = {name: evaluate(run, people)["ndcg@10"] for name, run in runs.items()}            # per-query scoresprint(f"order, people's grades only: {' > '.join(order(human))}")for prompt in PROMPTS:    counts = ", ".join(str((unjudged[prompt] == grade).sum()) for grade in LABELS)        # grades 2, 1 and 0    print(f"\nunjudged pairs graded exact, partial, irrelevant, {prompt} prompt: {counts}")    print(f"unjudged bulbs graded irrelevant, {prompt} prompt: {(lights[prompt] == 0).sum()}")    filled = {name: evaluate(run, fill_unjudged(people, llm_qrels(prompt)))["ndcg@10"] for name, run in runs.items()}    print("\n".join(f"{name} ndcg@10, filled by the {prompt} prompt: {filled[name].mean():.3f}" for name in runs))    print(f"order, filled by the {prompt} prompt: {' > '.join(order(filled))}")    # compares the two orders place by place    moved = [name for name, place in zip(order(filled), order(human)) if name != place]    print(f"rankers that change place when filled, {prompt} prompt: {', '.join(moved) or 'none'}")    changed = [pair for pair, established in planned_verdicts(filled, threshold).items()               if established != planned_verdicts(human, threshold)[pair]]    print(f"verdicts that change when filled, {prompt} prompt: {'; '.join(' minus '.join(pair) for pair in changed) or 'none'}")
Salidapython fill-unjudged-pairs.py
pairs in the test pool: 590
of them, unjudged: 26
unjudged products in the top 10s, bm25: 22
unjudged products in the top 10s, semantic: 3
unjudged products in the top 10s, hybrid: 6
unjudged products in the top 10s, reranked: 6
unjudged products for outdoor light fixtures: 8
of them, with bulb in the name: 8
order, people's grades only: semantic > hybrid > reranked > bm25

unjudged pairs graded exact, partial, irrelevant, short prompt: 4, 17, 5
unjudged bulbs graded irrelevant, short prompt: 0
bm25 ndcg@10, filled by the short prompt: 0.754
semantic ndcg@10, filled by the short prompt: 0.833
hybrid ndcg@10, filled by the short prompt: 0.821
reranked ndcg@10, filled by the short prompt: 0.813
order, filled by the short prompt: semantic > hybrid > reranked > bm25
rankers that change place when filled, short prompt: none
verdicts that change when filled, short prompt: none

unjudged pairs graded exact, partial, irrelevant, guidelines prompt: 5, 9, 12
unjudged bulbs graded irrelevant, guidelines prompt: 7
bm25 ndcg@10, filled by the guidelines prompt: 0.745
semantic ndcg@10, filled by the guidelines prompt: 0.834
hybrid ndcg@10, filled by the guidelines prompt: 0.821
reranked ndcg@10, filled by the guidelines prompt: 0.813
order, filled by the guidelines prompt: semantic > hybrid > reranked > bm25
rankers that change place when filled, guidelines prompt: none
verdicts that change when filled, guidelines prompt: none

Los prompts no coinciden en los pares sin juzgar. Contados como exacto, parcial e irrelevante, short los califica como 4, 17, 5, y guidelines como 5, 9, 12. Divergen en los productos sin juzgar de outdoor light fixtures en el top 10 de BM25 (Puntuar cada consulta de prueba): 8 de los 8 tienen bulb en su nombre.

guidelines considera irrelevantes 7 de las bombillas, y short considera 0. El capítulo 1 sostuvo que una bombilla no es una luminaria. Qué interpretación seguirían los jueces de la tienda, nadie lo sabe hasta que juzguen las bombillas.

Con los huecos rellenos, BM25 puntúa 0.754 con short y 0.745 con guidelines, frente a 0.725 con solo calificaciones humanas, y la recuperación semántica puntúa 0.833 y 0.834, frente a 0.830.

El orden con solo calificaciones humanas es semantic > hybrid > reranked > bm25. Los rankers que cambian de posición cuando short rellena los huecos son none, y cuando lo hace guidelines, none. Los veredictos de las comparaciones planificadas que cambian son none con short y none con guidelines.

Con calificaciones humanas, el judged@10 medio de los rankers, la proporción de cada top 10 que las personas juzgaron, va desde 0.927 para BM25 hasta 0.990 para la recuperación semántica (Comparar ejecuciones en un arnés).

¿Hasta qué punto se puede confiar en las calificaciones rellenadas? La evidencia más cercana son los pares juzgados del mismo conjunto, donde el kappa del LLM con los jueces de la tienda es 0.571 para short y 0.470 para guidelines. En esos pares juzgados, su calificación es inferior a la de los jueces en 61 pares y superior en 65 con short, e inferior en 77 y superior en 83 con guidelines (Leer la dirección de los errores del LLM).

Regla práctica: Rellena los pares sin juzgar de los top 10 de tus rankers con calificaciones de LLM como diagnóstico, con cada prompt que ejecutes, e informa la puntuación rellenada junto a la de solo humanos, con el número de pares rellenados. Si rellenar cambia el orden de dos rankers o un veredicto, haz que personas juzguen esos pares. Nunca dejes que una calificación rellenada reemplace a una humana.

Comprueba si las calificaciones del LLM ordenan los sistemas de la misma manera

Último cambio en la edición 2026.11.10

Dos conjuntos de juicios pueden discrepar en muchas etiquetas y, aun así, ordenar los sistemas de forma parecida. Voorhees puntuó los sistemas de TREC con distintos conjuntos de juicios de relevancia y encontró que "Very high correlations were found among the rankings of systems produced using different relevance judgment sets" (Voorhees, 1998). Los jueces LLM muestran la misma separación. En 42 conjuntos de etiquetas de LLM para la pista Deep Learning de TREC de 2023, el kappa osciló entre aproximadamente 0.06 y 0.29, mientras que la correlación de las clasificaciones de sistemas se mantuvo entre aproximadamente 0.83 y 0.95 (Rahmani et al., 2025, Tabla 3).

Esa correlación es la tau de Kendall. Un par de sistemas es concordante cuando dos ordenaciones lo colocan en el mismo orden, y discordante cuando las dos ordenaciones lo colocan en orden opuesto. Tau es los pares concordantes menos los pares discordantes, dividido entre todos los pares, y va de 1 para el mismo orden a −1 para el orden inverso. La función kendalltau de SciPy calcula τ_b, una forma que también gestiona los empates (documentación de SciPy).

Yilmaz et al. señalan que las clasificaciones con una tau de 0.9 o más suelen tratarse como efectivamente equivalentes, al menos de forma empírica (Yilmaz et al., 2008). Sanderson y Soboroff comprobaron que decidir con ese umbral es menos fiable de lo que el campo había supuesto (Sanderson y Soboroff, 2007).

Puntuar los cuatro rankers del capítulo 1 con nDCG@10 según las calificaciones humanas y según las calificaciones del LLM de cada prompt muestra si el LLM los ordena como lo hacen las personas. El LLM juzgó solo el conjunto de prueba, es decir, los productos de los 10 primeros resultados de esos rankers, así que un control también puntúa los rankers con calificaciones humanas solo para los pares del conjunto. Con cuatro rankers hay 6 pares, de modo que un solo par intercambiado mueve la tau en 0.333, y la tau solo puede tomar siete valores. Es una medida burda. Un juez tan alejado de las personas en pares individuales podría, aun así, ordenar los rankers como lo hacen ellas. ¿Lo hará? Responde primero:

kendall-tau-four-rankers.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Scores the four rankers under human grades, under people's grades on the LLM's pairs as a control, and under each prompt, then counts the swapped pairs for each set. The prose's point rests on the 'swapped under' lines, read with the tau lines beside them."""from itertools import combinationsfrom scipy.stats import kendalltaufrom lib.agreement import chapter_one_runs, llm_qrelsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsproducts, queries, people = load_products(), load_queries("test"), qrels("test")runs = chapter_one_runs(products, queries)short, guidelines = llm_qrels("short"), llm_qrels("guidelines")pooled = {query_id: {product_id: grade for product_id, grade in people[query_id].items() if product_id in short[query_id]}          for query_id in people}                 # people's grades for the pairs the LLM judged, and no othersjudgment_sets = {"people": people, "people on the LLM's pairs": pooled, "the short prompt": short,                 "the guidelines prompt": guidelines}means = {name: {ranker: evaluate(run, judgments)["ndcg@10"].mean() for ranker, run in runs.items()}         for name, judgments in judgment_sets.items()}for name, scores in means.items():    print(f"order under {name}: {' > '.join(sorted(scores, key=scores.get, reverse=True))}")    for ranker, score in scores.items():        print(f"{ranker} ndcg@10 under {name}: {score:.3f}")orders = [sorted(scores, key=scores.get, reverse=True) for scores in means.values()]steady = [ranker for position, ranker in enumerate(orders[0]) if all(order[position] == ranker for order in orders)]print(f"rankers in the same place under every set of grades: {', '.join(steady) or 'none'}")control = means["people on the LLM's pairs"]                              # the same pool, human gradesfor name in ["the short prompt", "the guidelines prompt"]:    print("\n".join(f"{ranker}, {name} minus people on the LLM's pairs: {means[name][ranker] - control[ranker]:+.3f}" for ranker in runs))# people's scores are the reference that every other set of grades is compared withpairs, reference = list(combinations(runs, 2)), means["people"]# one swap turns a concordant pair into a discordant one, which moves tau by 2 over the number of pairsprint(f"\npairs of rankers: {len(pairs)}\nchange in tau from one swapped pair: {2 / len(pairs):.3f}")for name, scores in list(means.items())[1:]:    swapped = [(first, second) for first, second in pairs                # discordant: opposite signs               if (reference[first] - reference[second]) * (scores[first] - scores[second]) < 0]    print(f"swapped under {name}: {'; '.join(f'{first} and {second}' for first, second in swapped) or 'none'}")    # concordant minus discordant, over all pairs; the discordant count is the number of swaps    print(f"tau by hand, people against {name}: {(len(pairs) - 2 * len(swapped)) / len(pairs):.3f}")    # SciPy's tau_b, which handles ties; .statistic is the tau value    print(f"tau from scipy, people against {name}: {kendalltau(list(reference.values()), list(scores.values())).statistic:.3f}")
Salidapython kendall-tau-four-rankers.py
order under people: semantic > hybrid > reranked > bm25
bm25 ndcg@10 under people: 0.725
semantic ndcg@10 under people: 0.830
hybrid ndcg@10 under people: 0.812
reranked ndcg@10 under people: 0.798
order under people on the LLM's pairs: semantic > hybrid > reranked > bm25
bm25 ndcg@10 under people on the LLM's pairs: 0.795
semantic ndcg@10 under people on the LLM's pairs: 0.904
hybrid ndcg@10 under people on the LLM's pairs: 0.885
reranked ndcg@10 under people on the LLM's pairs: 0.869
order under the short prompt: reranked > semantic > hybrid > bm25
bm25 ndcg@10 under the short prompt: 0.832
semantic ndcg@10 under the short prompt: 0.903
hybrid ndcg@10 under the short prompt: 0.900
reranked ndcg@10 under the short prompt: 0.906
order under the guidelines prompt: reranked > semantic > hybrid > bm25
bm25 ndcg@10 under the guidelines prompt: 0.805
semantic ndcg@10 under the guidelines prompt: 0.878
hybrid ndcg@10 under the guidelines prompt: 0.876
reranked ndcg@10 under the guidelines prompt: 0.886
rankers in the same place under every set of grades: bm25
bm25, the short prompt minus people on the LLM's pairs: +0.037
semantic, the short prompt minus people on the LLM's pairs: -0.001
hybrid, the short prompt minus people on the LLM's pairs: +0.016
reranked, the short prompt minus people on the LLM's pairs: +0.037
bm25, the guidelines prompt minus people on the LLM's pairs: +0.010
semantic, the guidelines prompt minus people on the LLM's pairs: -0.026
hybrid, the guidelines prompt minus people on the LLM's pairs: -0.008
reranked, the guidelines prompt minus people on the LLM's pairs: +0.017

pairs of rankers: 6
change in tau from one swapped pair: 0.333
swapped under people on the LLM's pairs: none
tau by hand, people against people on the LLM's pairs: 1.000
tau from scipy, people against people on the LLM's pairs: 1.000
swapped under the short prompt: semantic and reranked; hybrid and reranked
tau by hand, people against the short prompt: 0.333
tau from scipy, people against the short prompt: 0.333
swapped under the guidelines prompt: semantic and reranked; hybrid and reranked
tau by hand, people against the guidelines prompt: 0.333
tau from scipy, people against the guidelines prompt: 0.333

Las calificaciones humanas dan semantic > hybrid > reranked > bm25. El control, las calificaciones de las personas sobre los pares del LLM, mantiene ese orden, con una tau de 1.000, de modo que limitar las calificaciones al conjunto no desplaza a ningún ranker. Sí eleva todas las puntuaciones, la de BM25 de 0.725 a 0.795, porque el top 10 ideal solo puede contener productos del conjunto.

El orden con short es reranked > semantic > hybrid > bm25, y con guidelines es reranked > semantic > hybrid > bm25. short intercambia semantic and reranked; hybrid and reranked, y guidelines intercambia semantic and reranked; hybrid and reranked.

La tau para short es 0.333 calculada a mano y 0.333 con SciPy, y para guidelines, 0.333.

Frente al control, las calificaciones del LLM no desplazan a los cuatro rankers en la misma medida ni en la misma dirección. Con short, BM25 cambia en +0.037, la recuperación semántica en -0.001, el híbrido en +0.016 y el híbrido reordenado en +0.037. Con guidelines, los cambios son +0.010, -0.026, -0.008 y +0.017. El juez sube a unos rankers y baja a otros, y eso los hace adelantarse unos a otros.

Con short, la recuperación semántica, el híbrido y el híbrido reordenado casi empatan, con 0.903, 0.900 y 0.906. La tau no tiene en cuenta cuánto se separan dos rankers en puntuación, así que un intercambio entre casi empates cuenta lo mismo que uno entre el mejor ranker y el peor.

La tau también pesa igual un intercambio en la cima que uno en la base, una debilidad que señalan Yilmaz et al. (Yilmaz et al., 2008). Yilmaz et al. observan, sobre las ejecuciones (runs) de TREC que compararon, que los sistemas "have very similar performance. Hence, the Kendall’s τ statistic may be affected by these systems" (Yilmaz et al., 2012).

El ranker que mantiene su posición con cualquier conjunto de calificaciones es bm25. Los órdenes solo difieren entre los tres rankers que las calificaciones humanas puntúan con 0.830, 0.812 y 0.798, y esas diferencias son de las que ninguna comparación planificada establece (Repita las comparaciones planificadas).

Regla práctica: Informa de la tau junto con la lista de pares intercambiados, nunca sola. Con un puñado de rankers, donde un solo intercambio mueve la tau en 0.333, no la compares con 0.9. Luego prueba si los pares intercambiados difieren, con las comparaciones planificadas bajo cada conjunto de calificaciones.

Vuelve a ejecutar las comparaciones planificadas con calificaciones de LLM

Último cambio en la edición 2026.11.8

Las decisiones provienen de veredictos según la regla del libro, no de los órdenes que compara tau. ¿Habrían dado las calificaciones de LLM al almacén los mismos veredictos? Espera problemas cerca de la cima: Otero et al. encontraron que "los juicios basados en LLM son injustos al clasificar los sistemas de mejor rendimiento", con "una tasa excesivamente alta de falsos positivos en cuanto a diferencias estadísticas" (Otero et al., 2025).

Las tres comparaciones planificadas del capítulo 3 usan un umbral de 0.0167 e intervalos al nivel de 0.9833. Al volver a ejecutarlas con calificaciones humanas y con las calificaciones de cada prompt sobre el conjunto de prueba, y añadiendo la comparación exploratoria del capítulo 3 entre el híbrido reordenado y la recuperación semántica, se muestra si el almacén habría enviado los mismos rankers:

planned-comparisons-llm-grades.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Runs chapter 3's three planned comparisons, and the exploratory one, under human grades and under each prompt's grades on the test pool. The prose's point rests on the 'verdicts that differ' lines and the count of disagreeing checks."""from lib.agreement import PLANNED, PROMPTS, chapter_one_runs, llm_qrels   # PLANNED: chapter 3's, each stage against the lastfrom lib.metrics import evaluatefrom lib.significance import compare, verdictfrom lib.store import load_products, load_queries, qrelsEXPLORATORY = [("reranked", "semantic")]                                           # chosen after seeing test meansthreshold = 0.05 / len(PLANNED)                   # chapter 3's threshold, so that a verdict means the same either wayprint(f"planned comparisons: {len(PLANNED)}\np-value threshold: {threshold:.4f}\ninterval level: {1 - threshold:.4f}")runs = chapter_one_runs(load_products(), load_queries("test"))judgment_sets = {"people": qrels("test"), **{f"{prompt} prompt": llm_qrels(prompt) for prompt in PROMPTS}}established, disagreements = {}, {judges: 0 for judges in judgment_sets}for judges, judgments in judgment_sets.items():    ndcg = {ranker: evaluate(run, judgments)["ndcg@10"] for ranker, run in runs.items()}    for after, before in PLANNED + EXPLORATORY:        # the interval's level matches the threshold, so each interval and p-value follow one rule        result, name = compare(ndcg[after], ndcg[before], confidence=1 - threshold), f"{after} minus {before}, {judges}"        print(f"\n{name}: {result['mean difference']:.3f}\n{name}, permutation p: {result['permutation p']:.3f}")        # the exploratory comparison gets no t-test, interval or verdict        if (after, before) in PLANNED:            print(f"{name}, t-test p: {result['t-test p']:.3f}\n{name}, interval: {result['ci low']:.3f} to {result['ci high']:.3f}")            checks = verdict(result, threshold)            established[(judges, after, before)] = checks["established"]            disagree = [check for check in ["t-test", "interval"] if not checks[f"{check} agrees"]]            disagreements[judges] += bool(disagree)            print(f"{name}, established: {'yes' if checks['established'] else 'no'}\n"                  f"{name}, disagrees with the permutation test: {' and '.join(disagree) or 'neither'}")print()for judges, count in disagreements.items():    print(f"planned comparisons where the t-test or interval disagrees, {judges}: {count}")for prompt in PROMPTS:    differ = [pair for pair in PLANNED if established[(f"{prompt} prompt", *pair)] != established[("people", *pair)]]    print(f"verdicts that differ from people's, {prompt} prompt: {'; '.join(f'{after} minus {before}' for after, before in differ) or 'none'}")
Salidapython planned-comparisons-llm-grades.py
planned comparisons: 3
p-value threshold: 0.0167
interval level: 0.9833

semantic minus bm25, people: 0.105
semantic minus bm25, people, permutation p: 0.001
semantic minus bm25, people, t-test p: 0.003
semantic minus bm25, people, interval: 0.047 to 0.205
semantic minus bm25, people, established: yes
semantic minus bm25, people, disagrees with the permutation test: neither

hybrid minus semantic, people: -0.018
hybrid minus semantic, people, permutation p: 0.125
hybrid minus semantic, people, t-test p: 0.123
hybrid minus semantic, people, interval: -0.048 to 0.006
hybrid minus semantic, people, established: no
hybrid minus semantic, people, disagrees with the permutation test: neither

reranked minus hybrid, people: -0.014
reranked minus hybrid, people, permutation p: 0.382
reranked minus hybrid, people, t-test p: 0.375
reranked minus hybrid, people, interval: -0.053 to 0.020
reranked minus hybrid, people, established: no
reranked minus hybrid, people, disagrees with the permutation test: neither

reranked minus semantic, people: -0.032
reranked minus semantic, people, permutation p: 0.048

semantic minus bm25, short prompt: 0.070
semantic minus bm25, short prompt, permutation p: 0.010
semantic minus bm25, short prompt, t-test p: 0.014
semantic minus bm25, short prompt, interval: 0.016 to 0.146
semantic minus bm25, short prompt, established: yes
semantic minus bm25, short prompt, disagrees with the permutation test: neither

hybrid minus semantic, short prompt: -0.002
hybrid minus semantic, short prompt, permutation p: 0.851
hybrid minus semantic, short prompt, t-test p: 0.861
hybrid minus semantic, short prompt, interval: -0.029 to 0.036
hybrid minus semantic, short prompt, established: no
hybrid minus semantic, short prompt, disagrees with the permutation test: neither

reranked minus hybrid, short prompt: 0.006
reranked minus hybrid, short prompt, permutation p: 0.727
reranked minus hybrid, short prompt, t-test p: 0.714
reranked minus hybrid, short prompt, interval: -0.029 to 0.042
reranked minus hybrid, short prompt, established: no
reranked minus hybrid, short prompt, disagrees with the permutation test: neither

reranked minus semantic, short prompt: 0.003
reranked minus semantic, short prompt, permutation p: 0.847

semantic minus bm25, guidelines prompt: 0.073
semantic minus bm25, guidelines prompt, permutation p: 0.045
semantic minus bm25, guidelines prompt, t-test p: 0.057
semantic minus bm25, guidelines prompt, interval: 0.006 to 0.183
semantic minus bm25, guidelines prompt, established: no
semantic minus bm25, guidelines prompt, disagrees with the permutation test: interval

hybrid minus semantic, guidelines prompt: -0.001
hybrid minus semantic, guidelines prompt, permutation p: 0.929
hybrid minus semantic, guidelines prompt, t-test p: 0.945
hybrid minus semantic, guidelines prompt, interval: -0.045 to 0.037
hybrid minus semantic, guidelines prompt, established: no
hybrid minus semantic, guidelines prompt, disagrees with the permutation test: neither

reranked minus hybrid, guidelines prompt: 0.010
reranked minus hybrid, guidelines prompt, permutation p: 0.657
reranked minus hybrid, guidelines prompt, t-test p: 0.609
reranked minus hybrid, guidelines prompt, interval: -0.024 to 0.076
reranked minus hybrid, guidelines prompt, established: no
reranked minus hybrid, guidelines prompt, disagrees with the permutation test: neither

reranked minus semantic, guidelines prompt: 0.009
reranked minus semantic, guidelines prompt, permutation p: 0.581

planned comparisons where the t-test or interval disagrees, people: 0
planned comparisons where the t-test or interval disagrees, short prompt: 0
planned comparisons where the t-test or interval disagrees, guidelines prompt: 1
verdicts that differ from people's, short prompt: none
verdicts that differ from people's, guidelines prompt: semantic minus bm25
Medida Calificaciones Semántico menos BM25 Híbrido menos semántico Reordenado menos híbrido
Diferencia media Humanas 0.105 -0.018 -0.014
Diferencia media short 0.070 -0.002 0.006
Diferencia media guidelines 0.073 -0.001 0.010
Intervalo Humanas 0.047 to 0.205 -0.048 to 0.006 -0.053 to 0.020
Intervalo short 0.016 to 0.146 -0.029 to 0.036 -0.029 to 0.042
Intervalo guidelines 0.006 to 0.183 -0.045 to 0.037 -0.024 to 0.076
p de permutación Humanas 0.001 0.125 0.382
p de permutación short 0.010 0.851 0.727
p de permutación guidelines 0.045 0.929 0.657
p de la prueba t Humanas 0.003 0.123 0.375
p de la prueba t short 0.014 0.861 0.714
p de la prueba t guidelines 0.057 0.945 0.609
Establecido Humanas yes no no
Establecido short yes no no
Establecido guidelines no no no

Si el único resultado establecido del almacén sobrevive a las calificaciones de LLM depende del prompt. Con guidelines, el veredicto que difiere es semantic minus bm25, el único resultado que el capítulo 3 estableció. Con short, los veredictos que difieren de los humanos son none.

La prueba t o el intervalo discrepan de la prueba de permutación en 0 comparaciones planificadas con calificaciones humanas, en 0 con short y en 1 con guidelines. Para la recuperación semántica menos BM25 con guidelines, la comprobación que discrepa es la interval.

Comparar el orden de los rankers encontró dos pares intercambiados. Uno, el híbrido reordenado frente al híbrido, es una comparación planificada, y la tabla muestra que no se establece con ningún conjunto de calificaciones. El otro, el híbrido reordenado frente a la recuperación semántica, es la comparación exploratoria. Con calificaciones humanas, el híbrido reordenado menos la recuperación semántica es -0.032 (p de permutación 0.048). Con calificaciones de LLM es 0.003 con short y 0.009 con guidelines. El capítulo 3 la eligió después de ver las medias de prueba, así que no establece nada en ningún sentido.

Los jueces LLM también pueden favorecer a los rankers que usan LLM: Balog et al. informan de "la primera evidencia empírica de que los jueces LLM muestran un sesgo significativo hacia los rankers basados en LLM" (Balog et al., 2025). Los rankers del capítulo 1 no usan LLM, así que este capítulo no puede medir ese sesgo. El libro puntúa los rankers basados en LLM del capítulo 8 y del capítulo 9 con calificaciones humanas.

Regla práctica: Nunca publiques un cambio basándote solo en un veredicto de calificaciones de LLM. Usa las calificaciones de LLM para decidir qué candidatos merecen ser juzgados, y decide con calificaciones humanas. Cuando dos prompts dan veredictos distintos, el LLM no puede resolver la comparación, y deben hacerlo las personas.

Corrige las puntuaciones del LLM con una muestra humana

Último cambio en la edición 2026.11.10

Un camino intermedio usa los dos tipos de calificaciones: califica cada consulta con el LLM, pide a personas que juzguen una muestra aleatoria de consultas y usa la muestra para corregir el error del LLM. La inferencia potenciada por predicción corrige con rigor las predicciones de un modelo con una muestra humana, con intervalos de confianza que se sostienen "sin hacer suposiciones sobre el algoritmo de aprendizaje automático que proporciona las predicciones" (Angelopoulos et al., 2023). Una forma sencilla de la idea, para una media, toma la media del LLM sobre todas las consultas y le suma el promedio de la muestra humana de humano menos LLM:

corrected = mean over all queries of the LLM score + mean over the human sample of (human score − LLM score)

En la evaluación de búsqueda, Oosterhuis et al. construyen intervalos de métricas de esta manera, advirtiendo que "las anotaciones de relevancia generadas no están exentas de errores (sistemáticos)" (Oosterhuis et al., 2024). Takehi et al. dejan que el LLM elija qué pares juzgan las personas con un presupuesto limitado, y luego lo calibran con ellos (Takehi et al., 2025).

Supón que la tienda pudiera permitirse juicios humanos para 10 of 30 consultas de prueba. El ejemplo extrae 2,000 conjuntos aleatorios de ese tamaño y, para cada uno, corrige la estimación del LLM, con cada prompt, de dos diferencias entre los rankers del capítulo 1: la recuperación semántica menos BM25 y la híbrida menos la semántica, y compara cada estimación corregida con lo que la muestra humana dice por sí sola. La dispersión es la desviación estándar de una estimación a lo largo de las extracciones. La simulación no elige nada:

correct-llm-scores-with-humans.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Draws random sets of human-judged test queries and corrects the LLM's estimate of two ranker gaps with each set. The prose's point rests on the 'smaller than the human sample's' lines, read with the correlation lines beside them."""import numpy as npimport pandas as pdfrom lib.agreement import PROMPTS, chapter_one_runs, llm_qrelsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsJUDGED, DRAWS = 10, 2000                          # test queries people judge in each draw, and the number of drawsruns = chapter_one_runs(load_products(), load_queries("test"))people = pd.DataFrame({ranker: evaluate(run, qrels("test"))["ndcg@10"] for ranker, run in runs.items()})rng = np.random.default_rng(2026)draws = [rng.choice(people.index, JUDGED, replace=False) for _ in range(DRAWS)]    # which queries people judgeprint(f"queries judged by people in each draw: {JUDGED} of {len(people)}\ndraws: {DRAWS:,}")for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:    gap_people = people[after] - people[before]                        # per-query gaps under people's grades    print(f"\n{after} minus {before}, people, all queries: {gap_people.mean():.3f}")    # the spread: the standard deviation over the draws, with numpy's default divisor    alone = np.std([gap_people[judged].mean() for judged in draws])                # the human sample used alone    print(f"{after} minus {before}, human sample alone, spread: {alone:.3f}")    for prompt in PROMPTS:        llm = {ranker: evaluate(run, llm_qrels(prompt))["ndcg@10"] for ranker, run in runs.items()}        gap_llm, name = llm[after] - llm[before], f"{after} minus {before}, {prompt} prompt"        # the LLM's mean over all queries, plus the human sample's average of human minus LLM        corrected = [gap_llm.mean() + (gap_people[judged] - gap_llm[judged]).mean() for judged in draws]        print(f"{name}, LLM only: {gap_llm.mean():.3f}")        print(f"{name}, corrected, mean over draws: {np.mean(corrected):.3f}")        print(f"{name}, corrected, spread: {np.std(corrected):.3f}")        print(f"{name}, corrected spread smaller than the human sample's: {'yes' if np.std(corrected) < alone else 'no'}")        # corrcoef returns a 2×2 matrix; [0, 1] is the correlation between the two lists        print(f"{name}, correlation of per-query gaps with people's: {np.corrcoef(gap_llm, gap_people)[0, 1]:.3f}")
Salidapython correct-llm-scores-with-humans.py
queries judged by people in each draw: 10 of 30
draws: 2,000

semantic minus bm25, people, all queries: 0.105
semantic minus bm25, human sample alone, spread: 0.045
semantic minus bm25, short prompt, LLM only: 0.070
semantic minus bm25, short prompt, corrected, mean over draws: 0.104
semantic minus bm25, short prompt, corrected, spread: 0.036
semantic minus bm25, short prompt, corrected spread smaller than the human sample's: yes
semantic minus bm25, short prompt, correlation of per-query gaps with people's: 0.641
semantic minus bm25, guidelines prompt, LLM only: 0.073
semantic minus bm25, guidelines prompt, corrected, mean over draws: 0.104
semantic minus bm25, guidelines prompt, corrected, spread: 0.039
semantic minus bm25, guidelines prompt, corrected spread smaller than the human sample's: yes
semantic minus bm25, guidelines prompt, correlation of per-query gaps with people's: 0.692

hybrid minus semantic, people, all queries: -0.018
hybrid minus semantic, human sample alone, spread: 0.016
hybrid minus semantic, short prompt, LLM only: -0.002
hybrid minus semantic, short prompt, corrected, mean over draws: -0.017
hybrid minus semantic, short prompt, corrected, spread: 0.023
hybrid minus semantic, short prompt, corrected spread smaller than the human sample's: no
hybrid minus semantic, short prompt, correlation of per-query gaps with people's: 0.168
hybrid minus semantic, guidelines prompt, LLM only: -0.001
hybrid minus semantic, guidelines prompt, corrected, mean over draws: -0.017
hybrid minus semantic, guidelines prompt, corrected, spread: 0.024
hybrid minus semantic, guidelines prompt, corrected spread smaller than the human sample's: no
hybrid minus semantic, guidelines prompt, correlation of per-query gaps with people's: 0.342

Para la recuperación semántica menos BM25, el LLM por sí solo estima 0.070 con short, frente a 0.105 con calificaciones humanas. Corregida, la estimación promedia 0.104 a lo largo de las extracciones, así que la corrección elimina el sesgo del LLM.

Su dispersión es 0.036, frente a 0.045 para la muestra humana por sí sola. ¿Es la dispersión corregida menor que la de la muestra humana? yes con short y yes con guidelines. Las calificaciones del LLM para las demás consultas aportan información, porque sus diferencias por consulta se correlacionan con las humanas en 0.641.

Para la recuperación híbrida menos la semántica, la dispersión corregida es 0.023 con short y 0.024 con guidelines, frente a 0.016 para la muestra humana por sí sola. ¿Es menor que la de la muestra humana? no con short y no con guidelines. Las diferencias por consulta se correlacionan en 0.168 bajo short.

La corrección fija el nivel de una puntuación, pero solo reduce la incertidumbre allí donde las puntuaciones del LLM por consulta siguen a las de las personas, y aquí las siguen menos en la diferencia más cercana de las dos.

Regla práctica: Siempre que informes una puntuación a partir de calificaciones del LLM, pide a personas que juzguen una muestra aleatoria de consultas e informa la estimación corregida. En esa muestra, comprueba cuánto se correlacionan las diferencias por consulta del LLM con las humanas. Cuando la correlación es débil, destina el presupuesto a juzgar más consultas.

Qué sale mal en producción

Último cambio en la edición 2026.11.8

El juez cambia sin aviso. Una tienda que juzga con un LLM lo ejecuta una y otra vez, así que una versión distinta del modelo, una cuantización (la precisión con la que se almacenan los pesos del modelo) o un prompt reformulado son otro juez. El manifest.json de la grabación fija el digest del modelo y ambos prompts palabra por palabra. El esquema de respuesta y la longitud de contexto están en recordings/llm.py y recordings/llm_judgments.py, así que regístralos también. Vuelve a ejecutar la comprobación de acuerdo sobre la misma muestra humana cada vez que cambie cualquiera de ellos.

Los sistemas ajustados al juez puntúan bien con él. Clarke y Dietz construyeron una ejecución que explota a un juez LLM, y quedó "significativamente más alta con la evaluación automática (5.ª) que con la evaluación manual (28.ª)" (Clarke y Dietz, 2024). Un ranker ajustado con calificaciones de un LLM, o construido sobre el mismo LLM, necesita que su puntuación principal se calcule con calificaciones humanas.

El texto del producto puede dirigir al juez. Alaofi et al. comprobaron que los jueces LLM pueden desviarse por palabras de consulta colocadas en un texto irrelevante, y por instrucciones escritas en él (Alaofi et al., 2024). Un vendedor puede escribir una descripción que se dirija al juez. Mantén una muestra humana en cada evaluación, para que un juez desviado se note en un descenso del acuerdo.

Calibrar con el conjunto de prueba es ajustar con el conjunto de prueba. Reformular un prompt hasta que coincida con las calificaciones humanas en las consultas de prueba hace que el acuerdo allí no signifique nada. Elige los prompts con consultas de entrenamiento e informa del acuerdo sobre las de prueba.

Las calificaciones humanas tampoco son la verdad. En la pista TREC Podcast, donde un LLM y un evaluador de TREC discrepaban con más frecuencia, Mansour et al. comprobaron que los expertos que volvían a juzgar los pares se inclinaban más a menudo por el LLM (Mansour et al., 2026). Considera las calificaciones humanas como la referencia que elegiste, y lee los desacuerdos antes de culpar a uno de los dos lados.

Regla práctica: Fija el juez, mantén una muestra humana en cada evaluación, vuelve a comprobar el acuerdo cuando cambie algo, y nunca puntúes un ranker con el juez con el que lo ajustaste.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.8

El almacén mantiene estas decisiones salvo que un capítulo posterior dé una razón para cambiarlas.

  • Calificaciones humanas para cada puntuación principal. Las calificaciones de los LLM son un diagnóstico: sirven para rellenar huecos, filtrar candidatos y revisar veredictos. Los rankers basados en LLM del capítulo 8 y del capítulo 9 se puntúan con calificaciones humanas.
  • Cada hallazgo sobre el juez nombra su conjunto. La kappa y la kappa ponderada lineal, con el acuerdo observado junto a ellas, los errores graves y la distribución de etiquetas se miden sobre los pares de entrenamiento que juzgaron personas, y también se informan para los pares juzgados del conjunto de prueba. La dirección y el mayor error se leen en cada conjunto, y solo los top 10 de los rankers hablan de las puntuaciones de los rankers.
  • Dos prompts, registrados palabra por palabra. El conjunto de entrenamiento no puede distinguirlos, así que el almacén guarda ambos y solo confía en una conclusión basada en calificaciones de LLM cuando los dos prompts la respaldan.
  • Pares sin juzgar rellenados con calificaciones de LLM como diagnóstico, informados junto a la puntuación solo humana. En las consultas de prueba, el relleno no cambia la posición de ningún ranker ni ningún veredicto.
  • Comparar puntuaciones solo bajo las mismas calificaciones. En el mismo conjunto, las calificaciones de LLM no modifican el nDCG@10 de cada ranker en la misma cantidad ni en la misma dirección, así que una puntuación con calificaciones de LLM nunca se compara con una con calificaciones humanas.
  • Tau con sus pares intercambiados, y luego las comparaciones planificadas con el umbral del capítulo 3. Con cuatro rankers, tau es un indicador grosero, y los veredictos son los que deciden.
  • Una puntuación basada en calificaciones de LLM va acompañada de una muestra humana de consultas que la corrige, junto con la correlación que indica si las calificaciones del LLM redujeron la incertidumbre.
  • Lo que mostró el capítulo: un juez LLM puede rellenar huecos y filtrar candidatos, pero sus calificaciones mueven los rankers de forma desigual, así que un veredicto que importa sigue necesitando calificaciones humanas.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 11 de 11 ejemplos ejemplos de este capítulo

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

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 4 de 11: Juicios de personas y de LLM

  1. Escribir pautas de juicio
  2. Mide el acuerdo más allá del azar con kappa
  3. Dale crédito parcial a los casi aciertos con kappa ponderado
  4. Lee el kappa frente a la mezcla de etiquetas
  5. Lee la dirección de los errores del LLM
  6. Compara lo que vio el LLM con lo que vieron los jueces
  7. Mide cuánto cambian las etiquetas según el prompt
  8. Rellenar los pares sin juzgar con calificaciones de LLM
  9. Comprueba si las calificaciones del LLM ordenan los sistemas de la misma manera
  10. Vuelve a ejecutar las comparaciones planificadas con calificaciones de LLM
  11. Corrige las puntuaciones del LLM con una muestra humana
  12. Qué sale mal en producción
  13. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos