Qué significa la relevancia
Unos 33 minutos de lectura, con 10 ejemplos en 11 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.10. Lee el original
En esta página
- Juzga la relevancia frente a la necesidad del comprador
- Espera que los evaluadores discrepen en algunos pares
- Lee la intención como producto y sus modificadores
- Calificar la relevancia en lugar de sí o no
- Elige las ganancias con intención
- Lee la mezcla de etiquetas de cada consulta
- Trata los clics como evidencia sesgada
- Conoce de dónde provienen los juicios
- Cuenta los productos sin juzgar antes de comparar puntuaciones
- Qué sale mal en producción
- Decisiones que tomó este capítulo
Al terminar este capítulo podrás leer con espíritu crítico un conjunto de juicios de relevancia: explicar qué afirma cada calificación sobre un producto, averiguar de dónde provienen los juicios y dónde tienen huecos, y decidir cuánto confiar en una puntuación calculada a partir de ellos.
Hasta ahora, cada puntuación ha tomado los juicios de la tienda como hechos. El capítulo 1 puntuó dos sistemas de ranking frente a 13,077 juicios, las calificaciones que dieron personas a pares formados por una consulta escrita en la tienda y un producto que esta vende. En las consultas de prueba, BM25 promedia un nDCG@10 de 0.725. La recuperación semántica obtiene 0.830. Cada una de esas cifras descansa en decisiones que los juicios toman en silencio: de quién es la idea de relevancia que registran, cuánto vale un acierto parcial y qué ocurre con los productos que nadie juzgó.
Este capítulo lee con atención los juicios de la tienda. No cambia ningún sistema de ranking, así que lee por igual las consultas de entrenamiento y de prueba: leer juicios no es ajustar, y cada corrección de este libro se sigue eligiendo solo con consultas de entrenamiento. Las pocas pruebas que hace sobre las consultas de prueba son exploratorias, describen los juicios y no establecen ninguna diferencia (la regla del libro). El capítulo 3 contrasta la diferencia entre BM25 y la recuperación semántica como una comparación planificada.
Juzga la relevancia frente a la necesidad del comprador
Un sistema de búsqueda devuelve productos que coinciden con una consulta de la manera en que el sistema define una coincidencia: palabras compartidas para la recuperación léxica, vectores cercanos para la recuperación semántica. La ciencia de la información llama a eso relevancia de sistema. La separa de la relevancia temática, que indica si un producto trata del tema de la consulta, y de la relevancia situacional, que indica si ayuda con la tarea que se tiene entre manos (Saracevic, 2007). Algunos sostienen que la relevancia de sistema siempre es perfecta, porque el sistema recuperó lo que la consulta pedía. La respuesta de Saracevic es "No tanto".
Un juicio es un veredicto, y este capítulo se pregunta qué afirma cada calificación. Los juicios de la tienda provienen de WANDS, un conjunto de datos público de búsqueda de productos, a través de una muestra de sus consultas y productos (Carga los datos de la tienda). Los jueces de WANDS etiquetan cada par como exacto, parcial o irrelevante, que el libro califica con 2, 1 y 0. Exacto significa que el producto es del tipo que pide la consulta y tiene todos los atributos que la consulta nombra. Parcial significa que es del tipo correcto pero le falta algún atributo. Irrelevante significa que no es del tipo pedido (Lee la intención como un producto y sus modificadores). El juez califica el producto frente a la necesidad de información que hay detrás de las palabras de la consulta, lo que el comprador quería, y no frente a las palabras. Manning et al. definen un documento como relevante cuando atiende a la necesidad de información expresada, y no simplemente porque contenga las palabras de la consulta (Manning et al., 2008, capítulo 8). La evaluación entonces hace un pacto. Fija un conjunto de documentos, un conjunto de enunciados de necesidad y sus juicios, y prescinde de los usuarios reales (Voorhees, 2007). Aquí los juicios sustituyen a los compradores, y cada puntuación de este libro hereda ese pacto.
Si coincidir con las palabras fuera lo mismo que la relevancia, un producto cuyo texto contuviera todas las palabras de la consulta sería exacto. Puedes comprobarlo con cada par juzgado de la tienda: para cada par, pregunta si el nombre, la clase, la categoría y la descripción del producto contienen todas las palabras de la consulta, recortando las descripciones de la muestra a unos 400 caracteres.
De los pares juzgados cuyo texto contiene todas las palabras de la consulta, ¿qué proporción calificaron los jueces como exacta? Retén ese número.
1"""Checks whether a full word match makes a judged pair exact, and how many exact pairs have a text that misses a2query word, with and without attributes. The prose's point rests on the `of them exact` line and the3`of them, still missing one with attributes added` line."""4import re56from lib.store import load_labels, load_products, load_queries, product_text789def words(text):10 """Lowercase word tokens: a rough stand-in for what lexical search matches."""11 return set(re.findall(r"\w+", text.lower()))121314products, queries, labels = load_products(), load_queries(), load_labels()15text_words = {product_id: words(text) for product_id, text in product_text(products).items()}16attribute_words = {product_id: words(text) for product_id, text in products["attributes"].items()}17query_words = {query_id: words(query) for query_id, query in queries["query"].items()}18pairs = list(zip(labels["query_id"], labels["product_id"]))19# on sets, <= asks whether every query word is in the product's text20labels["in text"] = [query_words[query_id] <= text_words[product_id] for query_id, product_id in pairs]21# | is set union: the product's text words with its attribute words added22labels["in text or attributes"] = [query_words[query_id] <= text_words[product_id] | attribute_words[product_id]23 for query_id, product_id in pairs]2425matched = labels[labels["in text"]]26print(f"exact share of all judged pairs: {(labels['label'] == 'exact').mean():.3f}")27print(f"judged pairs whose text has every query word: {len(matched):,}")28for label in ["exact", "partial", "irrelevant"]:29 print(f"of them {label}: {(matched['label'] == label).mean():.3f}")3031exact = labels[labels["label"] == "exact"]32print(f"exact pairs: {len(exact):,}")33print(f"exact pairs whose text misses a query word: {(~exact['in text']).sum():,}")34print(f"of them, still missing one with attributes added: {(~exact['in text or attributes']).sum():,}")3536curtains = list(exact.loc[exact["query_id"] == 246, "product_id"]) # query 246: clear shower curtain37unsaid = [product_id for product_id in curtains if "clear" not in text_words[product_id]]38print("exact products for clear shower curtain:", len(curtains))39print("of them without the word clear in their text:", len(unsaid))40print("of those, with clear in their attributes:", sum("clear" in attribute_words[product_id] for product_id in unsaid))
python word-match-versus-judgment.pyexact share of all judged pairs: 0.249
judged pairs whose text has every query word: 1,177
of them exact: 0.777
of them partial: 0.211
of them irrelevant: 0.012
exact pairs: 3,252
exact pairs whose text misses a query word: 2,337
of them, still missing one with attributes added: 2,251
exact products for clear shower curtain: 12
of them without the word clear in their text: 8
of those, with clear in their attributes: 4
Una coincidencia completa de palabras es una señal fuerte, pero no resuelve la cuestión. De los 1,177 pares juzgados cuyo texto contiene todas las palabras de la consulta, 0.777 son exactos, 0.211 parciales y 0.012 irrelevantes, frente a una proporción exacta de 0.249 sobre todos los pares juzgados. Las palabras pueden estar presentes sin que el producto sea lo que el comprador quería, así que deciden los jueces, no las palabras. Una proporción cercana a 1 significaría que coincidir con las palabras es relevancia, y los jueces dicen que no lo es.
La otra dirección es más llamativa. La mayoría de los pares exactos, 2,337 de los 3,252, tienen un texto de producto que omite al menos una palabra de la consulta. Añadir los atributos aún deja 2,251 de ellos sin una palabra, así que los atributos explican pocas omisiones en conjunto.
Algunas omisiones son formas de palabra y ortografía, como chairs frente a chair (capítulo 1) o la consulta ligth bulb. El capítulo 5 y el capítulo 8 se ocupan de ellas. Otras son atributos que el texto no indica. WANDS registra atributos como color, material y tamaño aparte del texto (Chen et al., 2022, tabla 1), y la tienda guarda algunos de ellos en una columna attributes, por ejemplo color: clear; material: vinyl (ficha de datos). El texto que lee la búsqueda de la tienda, lib.store.product_text, deja fuera esa columna.
Para algunas consultas, sin embargo, los atributos guardan la respuesta. Para clear shower curtain, 8 de los 12 productos exactos nunca dicen clear en su texto, y 4 de ellos llevan clear en sus atributos, donde la búsqueda de texto de la tienda nunca mira. El capítulo 5 prueba añadir atributos a la búsqueda léxica. El resto de esas cortinas no dice clear en ningún sitio, ni en su texto ni en sus atributos.
Los jueces tenían más información a su alcance. Las guías de anotación de WANDS les mostraban el nombre de cada producto, su imagen y su página web (guías). La fotografía o la página pudieron ser lo que les sirvió de referencia, pero eso es una suposición nuestra, porque los datos no registran qué evidencia usó cada juez.
Regla práctica: Trata un juicio como el veredicto de una persona sobre una necesidad, no como una propiedad del producto. Antes de culpar a un ranking por no encontrar un producto exacto, comprueba si algún campo que el ranking lee dice lo que vieron los jueces, y mira los campos que no lee, como los atributos. Cuando tus jueces ven más de lo que ve tu ranking, dale al ranking la misma evidencia cuando sea posible, o acepta que algunos productos exactos quedarán mal posicionados por razones que ningún cambio en el ranking puede corregir.
Espera que los evaluadores discrepen en algunos pares
Dos personas pueden llegar a veredictos distintos. Cada etiqueta de WANDS ya es el voto mayoritario de hasta tres anotadores (Chen et al., 2022, sección 5), y los anotadores, que comenzaron con un acuerdo moderado, convergieron con el entrenamiento. El kappa de Cohen, que descuenta el acuerdo por azar, subió de 0.467 en sus primeros dos meses a 0.664 en el tercero y 0.826 en el cuarto (Tabla 2). El capítulo 4 calcula el kappa.
El archivo de WANDS enumera algunos pares de la tienda más de una vez, cada fila un voto mayoritario, y en algunos casos los votos difieren. La muestra de la tienda conserva una fila por par, con calificación 2 para exacto, 1 para parcial y 0 para irrelevante, y cuando las filas difieren conserva la calificación más baja (Carga los datos de la tienda). Estos son los pares cuyas filas difieren, con la calificación que conservó la muestra:
1"""Lists the pairs WANDS labelled two ways, with the label the sample kept, and counts the conflicts by kind. The2prose's point rests on the `conflicts between neighbouring grades` line."""3import pandas as pd45from lib.store import DATA, load_labels, load_products, load_queries67GRADES = {"exact": 2, "partial": 1, "irrelevant": 0}89products, queries, labels = load_products(), load_queries(), load_labels()10conflicts = pd.read_csv(DATA / "label_conflicts.csv") # pairs WANDS lists more than once, with different labels11# the sample's kept label for each pair, which is the lower grade wherever WANDS's rows differ12kept = labels.set_index(["query_id", "product_id"])["label"]1314for row in conflicts.itertuples():15 print(f"{queries.at[row.query_id, 'query']:<32} {products.at[row.product_id, 'name'][:40]:<41} "16 f"{row.labels:<19} kept: {kept[(row.query_id, row.product_id)]}")1718# each conflicting pair's two labels, from the column where "|" separates them19pairs = conflicts["labels"].str.split("|")20# a spread of 1 means neighbouring grades: exact and partial, or partial and irrelevant21spread = pairs.apply(lambda both: max(GRADES[label] for label in both) - min(GRADES[label] for label in both))22print()23print("pairs with conflicting labels:", len(conflicts))24# frozensets ignore which of the two labels comes first25print("exact against partial:", (pairs.apply(frozenset) == frozenset(["exact", "partial"])).sum())26print("partial against irrelevant:", (pairs.apply(frozenset) == frozenset(["partial", "irrelevant"])).sum())27print(f"conflicts between neighbouring grades: {(spread == 1).sum()} of {len(conflicts)}")
python conflicting-judgments.pywhimsical solar lights solar powered led pathway light pack exact|partial kept: partial
indoor multi tiered plant stand taranto multi-tiered plant stand exact|partial kept: partial
clear shower curtain shower curtain hooks irrelevant|partial kept: irrelevant
breakfast bar table counter height dining table exact|partial kept: partial
wood floor protector mat hard floor straight rectangular chair ma exact|partial kept: partial
malachi sled sled coffee table irrelevant|partial kept: irrelevant
kohler purist brushed bronze purist widespread bathroom faucet with d exact|partial kept: partial
pairs with conflicting labels: 7
exact against partial: 5
partial against irrelevant: 2
conflicts between neighbouring grades: 7 of 7
De los pares evaluados, 7 entran en conflicto: 5 son exacto frente a parcial y 2 parcial frente a irrelevante. Cada conflicto se da entre calificaciones vecinas, 7 of 7, así que el punto débil está en la frontera entre dos calificaciones, no en la distancia entre exacto e irrelevante. La fila de breakfast bar table es uno de esos casos: si una mesa de comedor de altura de encimera coincide plenamente con esa consulta es una cuestión razonable sobre un modificador, no una señal de que un voto haya malinterpretado la tarea.
Regla práctica: Conserva una calificación por par y anota la regla que la eligió. Recomendamos la calificación más baja, como hace la muestra: así el error juega en contra del ranker que posiciona el producto, no a su favor. Cuando los evaluadores discrepan entre dos calificaciones, exacto frente a irrelevante, relee las directrices con ellos, porque no comparten una misma definición.
Lee la intención como producto y sus modificadores
Cada juicio parte de una lectura de lo que la consulta pide. La intención de un comprador es lo que quiere hacer. Una taxonomía muy citada de la búsqueda web clasifica la intención en navegacional (llegar a un sitio concreto), informacional (encontrar información) y transaccional (hacer algo en la web), y su autor no supone que la intención pueda deducirse de la consulta con certeza (Broder, 2002). La búsqueda de productos reconfigura esas categorías. Tsagkias et al. describen las consultas navegacionales de productos como aquellas que nombran un número de serie o un producto, y las informacionales como aquellas que suelen corresponder a una hoja de la taxonomía del inventario o preguntan por atributos específicos. Añaden que "no existe una taxonomía única para la intención de los clientes de comercio electrónico", porque depende del negocio de la tienda y de su inventario (Tsagkias et al., 2020, sección 2).
WANDS plasma la intención en sus etiquetas. Una consulta nombra una entidad objetivo, el tipo de producto, y los modificadores de la consulta son los atributos que el comprador pidió. Exacto satisface ambos. Parcial solo coincide con la entidad objetivo y no cumple los modificadores (Chen et al., 2022, sección 3.2). El ejemplo resuelto de las directrices es una consulta de una silla infantil: un producto que es una silla pero no para niños es parcial (directrices). Incluso con esa regla, una consulta amplia puede ser difícil de juzgar. El propio ejemplo de los autores es el de un comprador que quiere una placa de inducción y escribe cooktop (sección 1).
Las consultas de la tienda cubren todo el abanico. ines shag rug w003096809 y kohler whitehaven farmhouse kitchen sink nombran una línea de producto o un modelo, lo que las hace navegacionales. outdoor light fixtures nombra una categoría. clear shower curtain y 48 inch kitchen hood añaden un modificador a una entidad. Las consultas de la tienda también llevan query_class, la clase predicha por WANDS para cada consulta (Tabla 1). Es una estimación de la entidad, no dice nada sobre los modificadores y no es un juicio. Comprueba con qué frecuencia coincide con los productos que los jueces calificaron como exactos:
1"""For each query, measures how many of its exact products carry the predicted class, and lists the queries where none2does. The prose's point rests on the `queries where most exact products have the query_class` line and the3`queries where no exact product has the query_class` line."""4import pandas as pd56from lib.store import load_labels, load_products, load_queries78products, queries, labels = load_products(), load_queries(), load_labels()9exact = labels[labels["label"] == "exact"].join(products["product_class"], on="product_id")1011rows = []12for query_id, group in exact.groupby("query_id"):13 predicted = queries.at[query_id, "query_class"]14 classes = group["product_class"].str.split("|") # a product can have several classes15 # the commonest product_class value, which can join several classes, comes first in value_counts(); a missing class is an empty string, which prints as (none)16 rows.append({"query": queries.at[query_id, "query"], "query_class": predicted,17 "share of exact products in it": classes.apply(lambda names: predicted in names).mean(),18 "commonest class of exact products": group["product_class"].value_counts().index[0] or "(none)"})19check = pd.DataFrame(rows)2021print("queries:", len(check))22print("queries without a query_class:", check["query_class"].isna().sum())23# most means more than half of a query's exact products carry the predicted class24print("queries where most exact products have the query_class:",25 (check["share of exact products in it"] > 0.5).sum())26missed = check[(check["share of exact products in it"] == 0) & check["query_class"].notna()]27print("queries where no exact product has the query_class:", len(missed))28print()29print(missed.drop(columns="share of exact products in it").to_string(index=False))
python predicted-class-check.pyqueries: 80
queries without a query_class: 1
queries where most exact products have the query_class: 63
queries where no exact product has the query_class: 6
query query_class commonest class of exact products
foutains with brick look Wallpaper Fountains
70s inspired furniture Wall Art (none)
7qt slow cooker Crock Pots & Slow Cookers Slow Cookers
sheffield home bath set Bath Rugs & Mats Vanities
luau string lights String Lights Holiday Lighting
rustic twig Faux Plants and Trees Wall & Accent Mirrors
La clase predicha suele coincidir con los productos exactos. Para 63 de las 80 consultas, la mayoría de los productos exactos la tienen, y para 6 consultas, ninguno la tiene, y 1 consulta no tiene clase alguna. Lee cada fila que imprime el ejemplo antes de contarla como error. foutains with brick look está clasificada como Wallpaper, mientras que sus productos exactos son fuentes, así que el clasificador se equivocó. 7qt slow cooker es, en cambio, un desajuste de nombres: las clases de las consultas y las de los productos usan nombres distintos para lo mismo.
Regla práctica: Lee cada consulta como una entidad más modificadores y comprueba que tu ranker acierta con la entidad antes de ajustarlo para los modificadores. Usa query_class como pista, para una característica o un filtro que contrastes con los juicios, y nunca como etiqueta. Cuando la intención sea ambigua, como con cooktop, juzga según la lectura de las directrices y deja esa lectura por escrito.
Calificar la relevancia en lugar de sí o no
Una etiqueta binaria dice relevante o no relevante. Una etiqueta graduada, como exacto, parcial o irrelevante en WANDS, indica cuán relevante es un resultado. Los resultados no son igual de útiles, así que los más relevantes deben encontrarse y colocarse primero. Järvelin y Kekäläinen defendieron las calificaciones graduadas en 2002. En una tienda, una coincidencia cercana suele ser una buena segunda opción. Una cortina de ducha que no es transparente, que WANDS califica como parcial porque es el tipo de producto correcto sin el atributo que se pide (Interpretar la intención como un producto y sus modificadores), está más cerca de lo que buscaba el cliente que un gancho para cortina de ducha. Las etiquetas binarias obligan a trazar una sola línea entre las calificaciones. Si solo cuentas como relevante lo exacto, la coincidencia cercana vale tanto como el gancho. Si cuentas lo exacto y lo parcial como relevantes, vale tanto como la cortina transparente.
La consulta de la tienda clear shower curtain muestra ambos fallos. Construye tres rankings de las diez primeras posiciones con sus juicios: diez productos exactos, diez cortinas de ducha calificadas como parciales y diez ganchos para cortinas de ducha calificados como irrelevantes. Luego puntúa cada uno con nDCG@10 (Puntuar un ranking) con tres etiquetados: binario con exacto como relevante, binario con exacto o parcial como relevantes, y las calificaciones del libro, 2 para exacto, 1 para parcial y 0 para irrelevante, usadas como ganancias. Una ganancia es lo que aporta un resultado en una posición dada a la puntuación, antes del descuento por posición.
1"""Scores three rankings of one query's judged products under three labelings, to show what each labeling counts as2relevant. The prose's point rests on the `grades` lines, since only the grades separate the three rankings."""3from lib.metrics import ndcg_at_k4from lib.store import load_products, qrels56classes = load_products()["product_class"]7judgments = qrels()[246] # clear shower curtain: {product_id: grade}8910def first_ten(grade, product_class=None):11 """Ten products judged with this grade for the query, in product_id order."""12 # sorted(judgments) takes product_id order as the tie-break; None for product_class means any class13 return [product_id for product_id in sorted(judgments) if judgments[product_id] == grade14 and product_class in (None, classes[product_id])][:10]151617rankings = {"clear curtains": first_ten(2), # exact18 "other curtains": first_ten(1, "Shower Curtains"), # partial: not clear19 "hooks": first_ten(0, "Shower Curtain Hooks and Accessories")} # irrelevant20labelings = {"exact only": {2: 1, 1: 0, 0: 0}, # binary: relevant means exact21 "exact or partial": {2: 1, 1: 1, 0: 0}, # binary: relevant means exact or partial22 "grades": {2: 2, 1: 1, 0: 0}} # graded: the book's grades as gains2324print("exact products for this query:", sum(grade == 2 for grade in judgments.values()))25# the ideal top 10 holds the ten highest grades, so counting the 2s counts the exact products in it26print("exact products in the ideal top 10:", sorted(judgments.values(), reverse=True)[:10].count(2))27for labeling, gain in labelings.items():28 gains = {product_id: gain[grade] for product_id, grade in judgments.items()}29 for name, ranking in rankings.items():30 print(f"{name}, {labeling}: {ndcg_at_k(ranking, gains, 10):.3f}")
python binary-labels-hide-partial.pyexact products for this query: 12
exact products in the ideal top 10: 10
clear curtains, exact only: 1.000
other curtains, exact only: 0.000
hooks, exact only: 0.000
clear curtains, exact or partial: 1.000
other curtains, exact or partial: 1.000
hooks, exact or partial: 0.000
clear curtains, grades: 1.000
other curtains, grades: 0.500
hooks, grades: 0.000
Solo las calificaciones separan los tres rankings. Con etiquetas solo exactas, las otras cortinas puntúan igual que los ganchos, 0.000 y 0.000. Con etiquetas exactas o parciales puntúan 1.000, lo mismo que las cortinas transparentes con 1.000. Con calificaciones, las cortinas transparentes puntúan 1.000, las otras cortinas 0.500 y los ganchos 0.000. Cuando el top 10 ideal es todo exacto, como ocurre aquí con 10 productos exactos en él, un ranking de diez productos parciales puntúa el cociente entre la ganancia parcial y la ganancia exacta.
Regla práctica: Recomendamos los juicios graduados para la búsqueda de productos, para que una métrica pueda reconocer una coincidencia cercana sin confundirla con una coincidencia. Recoge calificaciones aunque también informes una métrica binaria: siempre puedes reducir las calificaciones a sí o no, pero no al revés. Usa etiquetas binarias cuando una coincidencia cercana no tenga ningún valor para el usuario, por ejemplo cuando la consulta es un número de modelo y solo ese modelo sirve.
Elige las ganancias con intención
Las calificaciones son etiquetas. Las ganancias son lo que cada etiqueta vale en una métrica, y eso es una elección. Este libro usa cada calificación como su ganancia, así que parcial vale la mitad que exacto. El propio artículo de WANDS pondera exacto, parcial e irrelevante como 1.0, 0.5 y 0 (Chen et al., 2022, Tabla 3), la misma proporción y, por tanto, el mismo nDCG. El Shopping Queries Dataset, conocido como ESCI (Reddy et al., 2022), tiene 2.6 millones de juicios de consulta-producto etiquetados manualmente sobre 130 mil consultas únicas, y califica de otra forma. Distingue un sustituto, un artículo que funciona como sustituto funcional, como un forro polar para una consulta de suéter, de un complemento, un artículo que puede usarse junto con uno exacto. Sus ganancias son 1.0 para exacto, 0.1 para sustituto, 0.01 para complemento y 0.0 para irrelevante (Reddy et al., 2022, sección 3.1). El parcial de WANDS no es igual al sustituto de ESCI, pero es el equivalente más cercano.
Puntúa las dos ejecuciones de prueba de la tienda del capítulo 1, los rankings de BM25 y de la recuperación semántica para cada consulta de prueba, bajo cada uno de estos esquemas: los dos etiquetados binarios de Calificar la relevancia en lugar de sí o no, las calificaciones del libro y una ganancia parcial de 0.1 en el espíritu de ESCI. El ejemplo también ejecuta la prueba de permutación y la prueba t pareada del capítulo 3 sobre la ventaja de la recuperación semántica bajo cada esquema, e imprime ambos valores p. Ambas ventajas son descriptivas, como toda prueba aquí. La ejecución semántica lee los embeddings registrados del modelo abierto Snowflake/snowflake-arctic-embed-m-v1.5 (Buscar por significado).
1"""Scores BM25 and semantic retrieval on the test queries under four gain schemes, with exploratory paired tests on2semantic retrieval's lead. The prose's point rests on the `semantic minus bm25` lines, which keep one sign across the3schemes while their size changes."""4from lib.lexical import LexicalSearch5from lib.metrics import evaluate6from lib.semantic import SemanticSearch7from lib.significance import compare8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("test"), qrels("test")11# each run keeps the top 100 products per query; the scores below read only the top 10 of each12runs = {"bm25": LexicalSearch(load_products()).run(queries, k=100), "semantic": SemanticSearch().run(queries, k=100)}1314for name, run in runs.items():15 # an unjudged product gives None here, which the count of 1 does not include16 grades = [judgments[query_id].get(product_id) for query_id, ranking in run.items() for product_id in ranking[:10]]17 print(f"partial share of the {name} top 10: {grades.count(1) / len(grades):.3f}")1819# each scheme turns a grade into the gain it is worth20schemes = {"exact only": {2: 1, 1: 0, 0: 0},21 "exact or partial": {2: 1, 1: 1, 0: 0},22 "grades 2, 1, 0": {2: 2, 1: 1, 0: 0}, # the book's choice; WANDS's 1, 0.5, 0 gives the same nDCG23 "partial gain 0.1": {2: 1, 1: 0.1, 0: 0}} # close to the gains ESCI chose for its substitutes24leads = 025for scheme, gain in schemes.items():26 gains = {query_id: {product_id: gain[grade] for product_id, grade in per_query.items()}27 for query_id, per_query in judgments.items()}28 scores = {name: evaluate(run, gains)["ndcg@10"] for name, run in runs.items()}29 test = compare(scores["semantic"], scores["bm25"]) # exploratory paired tests (chapter 3): no planned comparisons30 print(f"bm25, {scheme}: {scores['bm25'].mean():.3f}")31 print(f"semantic, {scheme}: {scores['semantic'].mean():.3f}")32 print(f"semantic minus bm25, {scheme}: {test['mean difference']:.3f}")33 print(f"permutation p, {scheme}: {test['permutation p']:.3f}")34 print(f"t-test p, {scheme}: {test['t-test p']:.3f}")35 print(f"tied queries, {scheme}: {test['ties']}")36 # a lead is a positive mean difference, semantic minus BM2537 leads += test["mean difference"] > 038print(f"schemes where semantic leads: {leads} of {len(schemes)}")
python gain-choice-changes-ndcg.pypartial share of the bm25 top 10: 0.403
partial share of the semantic top 10: 0.380
bm25, exact only: 0.519
semantic, exact only: 0.648
semantic minus bm25, exact only: 0.130
permutation p, exact only: 0.000
t-test p, exact only: 0.002
tied queries, exact only: 3
bm25, exact or partial: 0.903
semantic, exact or partial: 0.983
semantic minus bm25, exact or partial: 0.080
permutation p, exact or partial: 0.010
t-test p, exact or partial: 0.026
tied queries, exact or partial: 19
bm25, grades 2, 1, 0: 0.725
semantic, grades 2, 1, 0: 0.830
semantic minus bm25, grades 2, 1, 0: 0.105
permutation p, grades 2, 1, 0: 0.001
t-test p, grades 2, 1, 0: 0.003
tied queries, grades 2, 1, 0: 2
bm25, partial gain 0.1: 0.564
semantic, partial gain 0.1: 0.688
semantic minus bm25, partial gain 0.1: 0.125
permutation p, partial gain 0.1: 0.000
t-test p, partial gain 0.1: 0.002
tied queries, partial gain 0.1: 2
schemes where semantic leads: 4 of 4
La recuperación semántica lidera en 4 of 4 esquemas, pero el tamaño de su ventaja depende de la elección. Los productos parciales ocupan 0.403 de los lugares del top 10 de BM25 y 0.380 de los de la recuperación semántica, así que la ganancia parcial mueve ambas puntuaciones mucho. BM25 obtiene 0.519 con etiquetas solo exactas y 0.903 con etiquetas exactas o parciales. Con la ganancia parcial de 0.1 al estilo de ESCI, BM25 obtiene 0.564 y la recuperación semántica 0.688. La ventaja es de 0.130 con etiquetas solo exactas, de 0.125 con las ganancias al estilo de ESCI, de 0.105 con las calificaciones y de 0.080 con etiquetas exactas o parciales. El ejemplo no comprueba si esas ventajas difieren, así que en 30 consultas de prueba, trata las diferencias entre ellas como posible ruido.
Las etiquetas exactas o parciales también saturan, y separan a los rankers en menos consultas. 19 consultas de prueba empatan con ellas, frente a 2 con las calificaciones.
Regla práctica: Usa ganancias lineales, las calificaciones 2, 1 y 0, como valor por defecto para la búsqueda de productos. Elige una ganancia parcial menor cuando un casi acierto valga poco para tus compradores. Sea cual sea tu elección, fíjala antes de comparar rankers, informa de ella junto con cada puntuación y nunca compares nDCG calculados con ganancias distintas.
Lee la mezcla de etiquetas de cada consulta
Las ganancias fijan lo que vale cada grado, pero no cuántos grados de cada tipo tiene una consulta. Un conjunto de juicios no es una sola población: cada consulta tiene su propio conjunto de productos juzgados y su propia mezcla de grados, y esa mezcla decide cómo luce un ranking perfecto para esa consulta. Una consulta amplia, la que nombra una categoría que satisfacen muchos productos, tiene muchos productos exactos. Una consulta específica, con varios modificadores, puede tener solo unos pocos. Un promedio sobre consultas mezcla problemas distintos, así que lee la mezcla antes de promediar cualquier cosa.
Las consultas de la tienda no son una muestra aleatoria de WANDS. Cada una fue elegida para tener entre 60 y 300 productos juzgados, al menos 3 juicios exactos y 20 parciales, y una clase predicha que ninguna otra consulta elegida tiene (ficha de datos). Los recuentos describen la muestra, no WANDS en su conjunto, porque las consultas fuera de esos límites nunca llegan a la tienda. Cuenta las etiquetas de cada una de las 80 consultas y agrupa las consultas según su proporción de productos exactos:
1"""Counts each query's judgments by label, and groups the queries by their share of exact products. The prose's point2rests on the `queries with an exact share of 0.1 or less` line and on the histogram below it."""3import pandas as pd45from lib.store import load_labels, load_queries67queries, labels = load_queries(), load_labels()8counts = pd.crosstab(labels["query_id"], labels["label"])[["exact", "partial", "irrelevant"]]9shares = counts.div(counts.sum(axis=1), axis=0).join(queries[["query", "split"]])1011print(f"partial share of all judgments: {(labels['label'] == 'partial').mean():.3f}")12print(f"median exact share: {shares['exact'].median():.3f}")13print(f"median irrelevant share: {shares['irrelevant'].median():.3f}")14for label, which in [("exact", "lowest"), ("exact", "highest"), ("irrelevant", "highest")]:15 query_id = shares[label].idxmin() if which == "lowest" else shares[label].idxmax()16 print(f"{which} {label} share: {shares.at[query_id, label]:.3f}")17 print(f"query with the {which} {label} share: {shares.at[query_id, 'query']}")18print("queries with no irrelevant judgment:", (counts["irrelevant"] == 0).sum())19print("fewest exact products for a query:", counts["exact"].min())20print("most exact products for a query:", counts["exact"].max())21# 10 is the size of a top 10: a query with fewer exact products can't fill a perfect top 10 with exact ones22few = counts["exact"] < 1023print("queries with fewer than 10 exact products:", few.sum())24print("test queries with fewer than 10 exact products:", (few & (shares["split"] == "test")).sum())2526print("queries with an exact share of 0.1 or less:", (shares["exact"] <= 0.1).sum())27print()28print("exact share queries")29bins = pd.cut(shares["exact"], [tenth / 10 for tenth in range(11)]) # no share is 0: each query has 3 or more exact30for interval, number in bins.value_counts(sort=False).items():31 print(f"{interval.left:.1f} to {interval.right:.1f} {number:>3} {'#' * number}".rstrip())
python count-labels-per-query.pypartial share of all judgments: 0.610
median exact share: 0.207
median irrelevant share: 0.060
lowest exact share: 0.014
query with the lowest exact share: 48 in entry table with side by side drawer
highest exact share: 0.749
query with the highest exact share: outdoor light fixtures
highest irrelevant share: 0.776
query with the highest irrelevant share: podium with locking cabinet
queries with no irrelevant judgment: 9
fewest exact products for a query: 3
most exact products for a query: 193
queries with fewer than 10 exact products: 23
test queries with fewer than 10 exact products: 7
queries with an exact share of 0.1 or less: 29
exact share queries
0.0 to 0.1 29 #############################
0.1 to 0.2 10 ##########
0.2 to 0.3 12 ############
0.3 to 0.4 11 ###########
0.4 to 0.5 9 #########
0.5 to 0.6 1 #
0.6 to 0.7 7 #######
0.7 to 0.8 1 #
0.8 to 0.9 0
0.9 to 1.0 0
Parcial es la etiqueta más común, con 0.610 de todos los juicios. La razón probable es la forma en que WANDS reunió sus candidatos, lo que cubre Conoce de dónde vienen los juicios. La proporción de exactos varía mucho de una consulta a otra, desde 0.014 para 48 in entry table with side by side drawer hasta 0.749 para outdoor light fixtures, con una mediana de 0.207. El histograma que imprime el ejemplo es más alto en el extremo bajo: 29 consultas tienen una proporción exacta de 0.1 o menos.
Los juicios irrelevantes son raros en la mayoría de las consultas, aunque no en todas: la proporción de irrelevantes tiene una mediana de 0.060, pero llega a 0.776 para podium with locking cabinet, y 9 consultas no tienen ningún juicio irrelevante.
La dispersión cambia lo que mide nDCG@10. Los productos exactos por consulta van desde 3, el mínimo que fija la regla de muestreo, hasta 193, y 23 consultas tienen menos de 10 productos exactos, 7 de ellas consultas de prueba. Para esas, el top 10 ideal incluye productos parciales, así que un ranking puede obtener una puntuación perfecta con productos parciales en su top 10. Para una consulta amplia como outdoor light fixtures, una puntuación perfecta requiere diez productos exactos. El mismo nDCG@10 significa cosas distintas en cada caso.
Regla práctica: Imprime la mezcla de etiquetas por consulta antes de promediar cualquier métrica, y mira ambos extremos. Lee una puntuación baja en una consulta con pocos productos exactos como un problema distinto de una puntuación baja en una consulta amplia. Mantén las puntuaciones por consulta junto a cada media; el capítulo 3 muestra lo que ocultan los promedios.
Trata los clics como evidencia sesgada
Una tienda registra cada click, y los clicks no cuestan nada de recoger, así que parecen juicios gratuitos. No lo son. Un clic indica que una persona decidió mirar un producto. No indica que el producto satisfaga la necesidad, y si una persona hace clic o no depende de dónde y cómo se mostró el producto.
La evidencia sobre cómo los clics engañan proviene de la búsqueda web. Joachims et al. siguieron los ojos y los clics de estudiantes de pregrado de Cornell que respondían diez preguntas fijadas con Google, en dos fases, con 34 estudiantes en la primera fase y 22 en la segunda. En la segunda fase, a algunos se les intercambiaron los dos primeros resultados, o se invirtió toda la lista (Joachims et al., 2005). Concluyeron que los clics son "informativos pero sesgados".
El primer sesgo es el sesgo de posición: las personas hacen clic con más frecuencia en los resultados mejor clasificados, en parte porque confían en la clasificación. Joachims et al. llaman a este efecto "sesgo de confianza", un efecto que atrae los clics hacia los enlaces con mejor posición incluso cuando otros resúmenes que el usuario vio son más relevantes. Los autores también comprobaron que las preferencias relativas, como un resultado clicado frente a uno omitido por encima de él, son razonablemente precisas en promedio.
En un experimento a gran escala en un motor de búsqueda web, Craswell et al. comprobaron que un modelo en cascada explicaba mejor el sesgo de posición en los primeros puestos. En el modelo en cascada, los usuarios leen los resultados de arriba abajo y abandonan en el primer documento que les resulta valioso (Craswell et al., 2008).
El sesgo de presentación va más allá de la posición: los clics dependen de cómo se muestra un resultado, no solo de dónde aparece. En una parte del tráfico de búsqueda web de Google, los resultados con títulos más atractivos, es decir, con más palabras de la consulta en negrita, atrajeron más clics, incluso después de controlar la posición y la relevancia tal como la juzgaban las personas (Yue et al., 2010). En una tienda, las imágenes y los precios son el análogo más cercano de los títulos. Esta es nuestra inferencia, no un resultado medido.
WANDS no tiene datos de clics, así que la tienda no puede medir estos sesgos. Aun así, puedes ver lo que registraría un registro de clics. Toma los juicios de la tienda para clear shower curtain y aplica el modelo en cascada en su forma más estricta: una persona lee desde arriba, hace clic en el primer producto exacto y abandona. Este experimento mental usa una única regla fija, no un modelo de personas reales. El capítulo 11 simula clics con probabilidades. Ejecuta el experimento mental sobre el ranking de BM25 y sobre el de la recuperación semántica, y lee los dos registros de clics uno al lado del otro:
1"""Reads the top 10 of BM25 and of semantic retrieval for `clear shower curtain` as a cascade of clicks, which stops at2the first exact product. The prose's point rests on the `clicked rank` lines and on the `exact products shown below the3click` lines."""4from lib.lexical import LexicalSearch5from lib.semantic import SemanticSearch6from lib.store import load_products, qrels78products = load_products()9judgments = qrels()[246] # clear shower curtain: {product_id: grade}10# search returns scores indexed by product_id, so .index is the ranking; semantic search takes the query's id, 24611rankings = {"bm25": list(LexicalSearch(products).search("clear shower curtain", k=10).index),12 "semantic": list(SemanticSearch().search(246, k=10).index)}1314for name, ranking in rankings.items():15 grades = [judgments.get(product_id, 0) for product_id in ranking] # an unjudged product counts as grade 016 rank = grades.index(2) + 1 # cascade: read from the top, click the first exact product, stop17 print(f"{name} grades, ranks 1 to 10: {' '.join(map(str, grades))}")18 print(f"{name} clicked rank: {rank}")19 # rank counts from 1 and the list from 0, so the clicked product sits at index rank - 120 print(f"{name} clicked product: {products.at[ranking[rank - 1], 'name']}")21 # grades[rank:] starts just after the click, since rank is the clicked product's position counted from 122 print(f"{name} exact products shown below the click: {grades[rank:].count(2)}")
python cascade-clicks.pybm25 grades, ranks 1 to 10: 1 2 2 2 2 1 1 0 0 0
bm25 clicked rank: 2
bm25 clicked product: woolley vinyl single shower curtain
bm25 exact products shown below the click: 3
semantic grades, ranks 1 to 10: 2 2 1 1 2 1 2 2 1 1
semantic clicked rank: 1
semantic clicked product: woolley vinyl solid color single shower curtain
semantic exact products shown below the click: 4
Un registro de clics recoge tanto lo que el ranqueador mostró primero como lo que quería la persona. Con el ranking de BM25, la persona hace clic en el puesto 2, woolley vinyl single shower curtain, y nunca llega a los 3 productos exactos que hay debajo. En el registro de clics, esos productos exactos parecen iguales que los puestos 8 a 10 de BM25, ganchos para cortinas de ducha juzgados como irrelevantes (Ordena productos con BM25), que tampoco recibieron clics.
Con el ranking de la recuperación semántica, el clic cae en el puesto 1, sobre woolley vinyl solid color single shower curtain. Dos rankings del mismo catálogo producen dos registros de clics que atribuyen el mérito a productos distintos.
Los autores de WANDS dan la misma razón, el sesgo de posición, para no construir su conjunto de datos a partir de registros de clics (Verifica los resultados con los juicios). Aun así, los clics transmiten información. En WANDS, el 62.47 % de los candidatos tomados de registros de clics se juzgaron exactos, frente al 30.95 % de los tomados de sistemas de ranking de código abierto (Chen et al., 2022, Tabla 4).
Corregir los clics por sesgo es un campo propio, el aprendizaje de ranking sin sesgo. En un gran conjunto de datos de búsqueda publicado por Baidu, esos métodos mejoraron la predicción de clics, pero "les cuesta mejorar de forma consistente el rendimiento del ranking" según el juicio de expertos (Hager et al., 2024).
Regla práctica: Usa los juicios, no los clics, como referencia para la evaluación sin conexión. Usa los clics como evidencia relativa, un producto clicado frente a uno omitido que estaba clasificado por encima, y nunca interpretes la ausencia de clic como señal de que un producto es irrelevante. Si entrenas con clics, verifica el resultado contra los juicios.
Conoce de dónde provienen los juicios
Nadie juzga cada producto para cada consulta, así que las colecciones de prueba juzgan un conjunto de candidatos en su lugar, un grupo de candidatos reunido para cada consulta. En TREC, las evaluaciones compartidas de Text REtrieval Conference, el conjunto de candidatos de un tema es la unión de los documentos mejor clasificados que recuperó cada participante, normalmente los 100 primeros, y todo documento fuera de ese conjunto cuenta como no relevante. Voorhees sostiene que los sistemas aún pueden compararse de forma justa cuando cada documento sin juzgar cuenta como no relevante, porque los conjuntos contienen suficientes documentos relevantes. El mismo artículo señala que la agrupación de candidatos no puede producir colecciones de prueba reutilizables para conjuntos de documentos arbitrariamente grandes (Voorhees, 2007). Zobel puso a prueba la afirmación de equidad. Con juicios sobre conjuntos de candidatos, el rendimiento relativo de los sistemas parece fiable, pero la exhaustividad se sobrestima, ya que probablemente nunca se han encontrado muchos documentos relevantes (Zobel, 1998).
WANDS construyó su conjunto de candidatos en dos pasos (Chen et al., 2022, secciones 4.2 y 4.3). El primero tomó los productos que los compradores habían pulsado o añadido a sus carritos, además de los resultados de un motor de búsqueda léxica de código abierto, Solr, y de un sistema de recuperación neuronal. El segundo volvió a explorar todo el catálogo con esos mismos dos sistemas, y añadió cada producto de la clase que un modelo de clasificación de consultas predijo para la consulta. Ese segundo paso produjo la mayoría de las etiquetas de WANDS, y en su mayor parte coincidencias aproximadas: el 4.12 % de sus etiquetas fueron exactas y el 63.99 % parciales (Tabla 5). Parcial es también la etiqueta más común en la muestra de la tienda (Lee la distribución de etiquetas de cada consulta). Los autores sostienen que la completitud importa en la búsqueda de productos, porque «la incompletitud en el conjunto de datos de búsqueda de productos afecta negativamente al poder discriminativo de la evaluación» (sección 3.1).
Un conjunto de candidatos pertenece a una consulta. Un producto sin juicio para una consulta está sin juzgar para ella, y un producto juzgado para una consulta puede estar sin juzgar para una similar. Dos consultas de la tienda muestran esto: la consulta de entrenamiento trundle daybed y la consulta de prueba full bed with trundle. Cuenta los productos juzgados exactos para la primera que no tienen juicio para la segunda, y observa cómo calificaron los jueces los que sí lo tienen:
1"""Counts the products judged exact for the train query `trundle daybed` that have no judgment for the test query `full2bed with trundle`, and grades the ones that do. The prose's point rests on the `of them unjudged for full bed with3trundle` line and the `judged partial` line."""4from collections import Counter56from lib.store import load_products, load_queries, qrels78products, queries, judgments = load_products(), load_queries(), qrels()9LABELS = {2: "exact", 1: "partial", 0: "irrelevant"}1011# 433 is the train query trundle daybed, and its exact products come out in product_id order12daybeds = sorted(product_id for product_id, grade in judgments[433].items() if grade == 2)13full_bed = judgments[436] # {product_id: grade} for "full bed with trundle"14print(f"433: {queries.at[433, 'query']} ({queries.at[433, 'split']})")15print(f"436: {queries.at[436, 'query']} ({queries.at[436, 'split']})")16print("exact for trundle daybed:", len(daybeds))1718unjudged = [product_id for product_id in daybeds if product_id not in full_bed]19print("of them unjudged for full bed with trundle:", len(unjudged))20print("of them judged for full bed with trundle:", len(daybeds) - len(unjudged))21judged = Counter(LABELS[full_bed[product_id]] for product_id in daybeds if product_id in full_bed)22for label in LABELS.values():23 print(f"judged {label}: {judged[label]}")2425# daybeds is in product_id order, so the first two unjudged are the two lowest product_ids among them26print("first unjudged daybed:", products.at[unjudged[0], "name"])27print("second unjudged daybed:", products.at[unjudged[1], "name"])
python trundle-daybeds-unjudged.py433: trundle daybed (train)
436: full bed with trundle (test)
exact for trundle daybed: 113
of them unjudged for full bed with trundle: 77
of them judged for full bed with trundle: 36
judged exact: 5
judged partial: 31
judged irrelevant: 0
first unjudged daybed: daybed with trundle
second unjudged daybed: pattonsburg daybed with trundle
Una métrica que puntúa con 0 un producto sin juzgar está adivinando, y aquí la suposición importa. Según nuestra lectura de la regla de las directrices, un daybed con cama nido suele ser el tipo de cama correcto sin el tamaño que pide la consulta. De los 113 productos juzgados exactos para trundle daybed, 77 no tienen juicio para full bed with trundle, entre ellas las dos de menor número de producto, daybed with trundle y pattonsburg daybed with trundle. De las 36 que sí lo tienen, los jueces calificaron 5 como exactas, 31 como parciales y 0 como irrelevantes. Si los daybeds sin juzgar se parecen a los juzgados, la mayoría serían también parciales, pero una métrica asigna a cada una la calificación 0.
Zobel advierte que los juicios sobre conjuntos de candidatos pueden subestimar a los sistemas que no contribuyeron al conjunto (Zobel, 1998). Eso hace que los juicios sean más justos con los rankers parecidos a los sistemas que construyeron el conjunto: en WANDS, los clics de los compradores, un motor léxico, un recuperador neuronal y un clasificador de consultas. Es una tendencia, no una ley. Aquí BM25, el ranker más parecido al motor léxico de WANDS, tiene el judged@10 más bajo de los dos rankers (Cuenta los productos sin juzgar). Nuestra suposición es que el BM25 de la tienda lee campos distintos de los que leyó el motor del conjunto, así que sitúa arriba productos distintos.
Regla práctica: Averigua de dónde proviene tu conjunto de candidatos antes de confiar en una comparación. Cuando evalúes un ranker distinto de los sistemas que lo construyeron, espera que muestre productos que nadie juzgó, y planea juzgarlos.
Cuenta los productos sin juzgar antes de comparar puntuaciones
Un producto que nadie juzgó para una consulta está sin juzgar: su calificación es desconocida, no 0. Las métricas estándar no distinguen entre ambos casos. Puntúan un producto sin juzgar exactamente igual que uno juzgado como irrelevante, y Buckley y Voorhees advierten de que tales métricas se vuelven poco fiables cuando los juicios están muy incompletos (Buckley y Voorhees, 2004). Dos diagnósticos son estándar en las herramientas de evaluación (ir-measures). Judged@k es la proporción del top k que tiene un juicio de cualquier calificación:
judged@k = (number of the top k products that have a judgment for the query) / k
El segundo diagnóstico es la lista condensada, un ranking al que se le eliminan los productos sin juzgar antes de puntuar, de modo que los juzgados suben. ir-measures la ofrece como la opción judged_only. La medida bpref de Buckley y Voorhees sigue el mismo espíritu: usa solo los documentos juzgados, y ellos comprobaron que es más robusta ante juicios incompletos.
En el capítulo 1, el judged@10 medio de BM25 en las consultas de prueba es 0.927. La media para la recuperación semántica es 0.990. Una propiedad de los datos de la tienda mantiene esos números altos. Su catálogo está casi completamente juzgado: 11,917 de 12,000 productos tienen un juicio para al menos una consulta (Carga los datos de la tienda). Espera que un catálogo completo ponga más productos sin juzgar en los top 10.
Calcula judged@10 a mano, compáralo con lib.metrics y enumera dónde están los productos sin juzgar de BM25:
1"""Builds judged@10 by hand for BM25's test rankings, checks it against lib.metrics, and lists where BM25's unjudged2products sit in the top 10s. The prose's point rests on the `unjudged products in the top 10s` line and on the3`irrelevant judgments` line for pull out sleeper loveseat."""4import pandas as pd56from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.store import load_products, load_queries, qrels910products, queries, judgments = load_products(), load_queries("test"), qrels("test")11# 100 products per query are kept; this example reads only the top 10 of each12run = LexicalSearch(products).run(queries, k=100)131415def judged_at_k(ranking, judged, k):16 """The share of the top k that has a judgment of any grade."""17 return sum(product_id in judged for product_id in ranking[:k]) / k181920rows = []21for query_id, ranking in run.items():22 unjudged = [product_id for product_id in ranking[:10] if product_id not in judgments[query_id]]23 # the name is cut to 45 characters so that the table fits on the page24 rows.append({"query": queries.at[query_id, "query"], "judged@10": judged_at_k(ranking, judgments[query_id], 10),25 "unjudged": len(unjudged), "first unjudged product": products.at[unjudged[0], "name"][:45] if unjudged else ""})26table = pd.DataFrame(rows)2728print(f"mean judged@10: {table['judged@10'].mean():.3f}")29# lib.metrics' judged@10 per query, indexed by query_id30library = evaluate(run, judgments)["judged@10"]31# 1e-12 allows for floating-point rounding when the two judged@10 values are compared32agree = sum(abs(row["judged@10"] - library[query_id]) < 1e-12 for query_id, row in zip(run, rows))33print(f"queries where the hand-built judged@10 equals lib.metrics: {agree} of {len(rows)}")34print("unjudged products in the top 10s:", table["unjudged"].sum())35print("test queries with an unjudged product in the top 10:", (table["judged@10"] < 1).sum())36sleeper = list(judgments[244].values()) # pull out sleeper loveseat37print("judgments for pull out sleeper loveseat:", len(sleeper))38print("irrelevant judgments for pull out sleeper loveseat:", sleeper.count(0)) # grade 0 is irrelevant39print()40# judged@10 below 1 means the query has at least one unjudged product in its top 1041print(table[table["judged@10"] < 1].sort_values("judged@10").to_string(index=False))
python unjudged-in-bm25-top-10.pymean judged@10: 0.927
queries where the hand-built judged@10 equals lib.metrics: 30 of 30
unjudged products in the top 10s: 22
test queries with an unjudged product in the top 10: 7
judgments for pull out sleeper loveseat: 143
irrelevant judgments for pull out sleeper loveseat: 0
query judged@10 unjudged first unjudged product
outdoor light fixtures 0.2 8 60 watt equivalent e12 led candle light bulb
beach blue headboard 0.5 5 lemon frosting indoor/outdoor , removable cov
pull out sleeper loveseat 0.6 4 country oxford 87.75 '' rolled arm sleeper
full bed with trundle 0.8 2 abel staircase twin over full bunk bed with t
whimsical solar lights 0.9 1 luciole 0.12-watt led solar power dusk to daw
bistro table and chairs 0.9 1 drayton patio 5 piece bistro set
wooden chair outdoor 0.9 1 osterley 31.5 '' w writing desk and chair set
El judged@10 calculado a mano es igual a lib.metrics en 30 of 30 consultas de prueba, con una media de 0.927. Los productos sin juzgar ocupan 22 de los puestos del top 10 de BM25, repartidos en 7 consultas. Según nuestra lectura, algunos son claramente irrelevantes: bombillas para outdoor light fixtures, una almohada de exterior para beach blue headboard. Otros parecen casos límite o coincidencias: una cama litera con cajón para full bed with trundle, un juego de bistró para bistro table and chairs, un sofá cama para pull out sleeper loveseat, que según la regla de entidad y modificador probablemente es un caso límite: los jueces calificaron como irrelevantes 0 de los 143 productos juzgados de esa consulta.
Puntúa ambos sistemas de ranking con listas condensadas, que eliminan los productos sin juzgar, para ver cuánto cambian las puntuaciones:
1"""Scores BM25 and semantic retrieval on the test queries with standard and condensed nDCG@10, and runs exploratory2tests on the change in the lead. The prose's point rests on the `semantic minus bm25` lines and the `share of bm25's3gain` line."""4from lib.lexical import LexicalSearch5from lib.metrics import evaluate6from lib.semantic import SemanticSearch7from lib.significance import compare8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("test"), qrels("test")11runs = {"bm25": LexicalSearch(load_products()).run(queries, k=100), "semantic": SemanticSearch().run(queries, k=100)}1213standard, condensed = {}, {}14for name, run in runs.items():15 # condensed: drop every unjudged product, so the judged ones move up into the top 1016 judged_only = {query_id: [product_id for product_id in ranking if product_id in judgments[query_id]]17 for query_id, ranking in run.items()}18 standard[name] = evaluate(run, judgments)["ndcg@10"]19 condensed[name] = evaluate(judged_only, judgments)["ndcg@10"]20 print(f"{name} ndcg@10: {standard[name].mean():.3f}")21 print(f"{name} condensed ndcg@10: {condensed[name].mean():.3f}")2223gain = condensed["bm25"] - standard["bm25"] # bm25's change, per test query24# the scores are indexed by query_id: 133 is outdoor light fixtures, and 46 is beach blue headboard25print(f"bm25 ndcg@10 for outdoor light fixtures: {standard['bm25'][133]:.3f}")26print(f"bm25 condensed ndcg@10 for outdoor light fixtures: {condensed['bm25'][133]:.3f}")27print(f"share of bm25's gain from outdoor light fixtures and beach blue headboard: {gain[[133, 46]].sum() / gain.sum():.3f}")2829lead, condensed_lead = standard["semantic"] - standard["bm25"], condensed["semantic"] - condensed["bm25"]30change = compare(condensed_lead, lead) # is the change in the lead more than noise? (exploratory)31print(f"semantic minus bm25: {lead.mean():.3f}")32print(f"semantic minus bm25, condensed: {condensed_lead.mean():.3f}")33print(f"change in the lead: {change['mean difference']:.3f}")34print(f"95% interval for the change: {change['ci low']:.3f} to {change['ci high']:.3f}")35print(f"t-test p for the change: {change['t-test p']:.3f}")36print(f"permutation p for the change: {change['permutation p']:.3f}")37condensed_test = compare(condensed["semantic"], condensed["bm25"]) # the condensed lead itself (exploratory)38print(f"t-test p for the condensed lead: {condensed_test['t-test p']:.3f}")39print(f"permutation p for the condensed lead: {condensed_test['permutation p']:.3f}")
python condensed-ndcg.pybm25 ndcg@10: 0.725
bm25 condensed ndcg@10: 0.778
semantic ndcg@10: 0.830
semantic condensed ndcg@10: 0.834
bm25 ndcg@10 for outdoor light fixtures: 0.286
bm25 condensed ndcg@10 for outdoor light fixtures: 1.000
share of bm25's gain from outdoor light fixtures and beach blue headboard: 0.612
semantic minus bm25: 0.105
semantic minus bm25, condensed: 0.056
change in the lead: -0.049
95% interval for the change: -0.138 to -0.015
t-test p for the change: 0.073
permutation p for the change: 0.036
t-test p for the condensed lead: 0.011
permutation p for the condensed lead: 0.009
Condensar mejora a BM25 sobre todo perdonando resultados malos, no deshaciendo una penalización sobre los buenos. BM25 pasa de 0.725 a 0.778, y la recuperación semántica de 0.830 a 0.834. De la ganancia de BM25, una proporción de 0.612 proviene de outdoor light fixtures y beach blue headboard, las dos consultas cuyos productos sin juzgar son claramente irrelevantes. Para outdoor light fixtures, BM25 pasa de 0.286 a 1.000: una vez que salen las bombillas, las luces juzgadas que estaban debajo suben.
La ventaja de la recuperación semántica baja de 0.105 a 0.056 una vez condensadas las listas. Aún no está claro si ese cambio es más que ruido. La prueba t pareada del capítulo 3 da p = 0.073 para el cambio, y su prueba de permutación da 0.036. El intervalo de bootstrap del 95% va de -0.138 to -0.015. Ambas comprobaciones son exploratorias. Como el cambio lo sostienen unas pocas consultas, considéralo posiblemente ruido.
La ventaja condensada en sí obtiene p = 0.009 con la prueba de permutación y 0.011 con la prueba t. Ni la puntuación estándar ni la condensada son la verdad. La puntuación estándar penaliza productos sin juzgar que quizá sean buenos, y la condensada oculta productos sin juzgar que son malos.
Regla práctica: Reporta judged@10 junto a cada nDCG@10, y calcula las puntuaciones condensadas como diagnóstico, nunca como resultado principal. Cuando el judged@10 de dos rankings difiera, haz juzgar los productos sin juzgar de sus top 10 antes de compararlos. Esa es la solución fiable, y en esta muestra es una tarea pequeña: 22 juicios para la prueba de BM25. En un catálogo completo, espera más.
Qué sale mal en producción
Los juicios envejecen. El catálogo de una tienda y sus compradores cambian sin parar, y la relevancia depende de más que la consulta. Tsagkias et al. nombran al usuario, el momento, la consulta y el contexto, y dan un ejemplo: una consulta por chaquetas tiene productos relevantes distintos en invierno que en verano (Tsagkias et al., 2020, sección 3.1.1). Los productos entran al catálogo sin juzgar, y los que salen de él permanecen en el conjunto de juicios. Haz un seguimiento de judged@10 para tu ranker en producción a lo largo del tiempo, y vuelve a juzgar cuando baje.
Las etiquetas de click confirman el ranking que ya tienes. Un ranker entrenado con clics registrados bajo el ranking actual aprende el orden de ese ranking junto con las preferencias de los compradores. Conserva los juicios humanos como referencia contra la que se contrastan los clics (Trata los clics como evidencia sesgada).
Las directrices dan forma a los juicios. Los anotadores de WANDS necesitaron cuatro meses para llegar a un acuerdo casi perfecto (Chen et al., 2022, Tabla 2). Las pequeñas decisiones en las directrices dan forma a todo el conjunto. WANDS pidió a los anotadores que ignoraran las erratas y juzgaran el ejemplo tal como estaba escrito (directrices), así que sus juicios suponen un lector que entiende ligth bulb. Un ranker que no lo entienda puntuará bajo en esas consultas, lo cual es justo para el comprador. El capítulo 8 construye un corrector ortográfico y muestra lo que todavía falla.
Tu ranker ve menos de lo que ven tus jueces. Los jueces vieron imágenes y páginas de producto, mientras que los rankers de la tienda leen texto sin los atributos (el capítulo 5 prueba añadirlos). Cualquier modelo de lenguaje de gran tamaño (LLM) al que se le pida juzgar a partir del mismo texto ve lo que ve el ranker. Parte del desacuerdo entre ese sistema y los juicios humanos procede de esa brecha, no del sistema. Comprueba qué campos contienen los atributos que tus jueces premiaron antes de culpar al ranker.
Rellenar huecos con un modelo sigue necesitando juicios humanos. Gienapp et al. ajustan finamente un clasificador pequeño para cada consulta con los juicios humanos de esa consulta, y lo usan para juzgar los productos sin juzgar. En TREC Robust04 y en las colecciones TREC Deep Learning de 2019 y 2020, informan de que tan solo 128 juicios humanos iniciales por tema mejoran la comparabilidad de los modelos, y de que el enfoque es más fiable que los jueces LLM con indicaciones (Gienapp et al., 2025). El consejo de Soboroff sobre los LLM es más tajante: «no uses LLM para crear juicios de relevancia en evaluaciones al estilo TREC» (Soboroff, 2025). El capítulo 4 mide los juicios de los LLM frente a los humanos de la tienda antes de confiar en ellos.
Regla práctica: Fecha tus juicios, haz seguimiento de judged@10 en producción y prevé presupuesto para volver a juzgar.
Decisiones que tomó este capítulo
Los capítulos posteriores mantienen estas decisiones, salvo que una medición sobre las consultas de entrenamiento indique lo contrario.
- Los juicios humanos son la referencia. Cada puntuación principal de este libro se calcula sobre ellos, incluidas las de los rankers construidos con LLM. Los clics son evidencia sobre los compradores, sesgada por la posición y la presentación, y nunca sirven como etiquetas.
- Las calificaciones 2, 1 y 0 son las ganancias, de modo que parcial vale la mitad que exacto, la misma proporción que el 1.0, 0.5 y 0 propios de WANDS. Las métricas binarias cuentan solo lo exacto.
- Una calificación por par. Cuando WANDS enumera un par más de una vez con etiquetas distintas, la muestra conserva la calificación más baja, lo que se equivoca en contra del ranker.
query_classes una pista, nunca una etiqueta ni una medida de la intención. Algunos de sus valores son erróneos.- Lo no juzgado cuenta como calificación 0, con judged@10 junto a cada nDCG@10. Las puntuaciones condensadas son solo un diagnóstico. La solución para los productos no juzgados en un top 10 es juzgarlos.
- Los rankers leen el texto del producto, no los atributos. El capítulo 5 prueba añadirlos como campo y los mantiene fuera del texto de BM25. Los evaluadores también vieron imágenes y páginas de producto, así que algunos productos exactos dan a un ranker solo de texto muy poco con qué coincidir.
- Lee cualquier juicio, ajusta con el conjunto de entrenamiento. Leer los juicios del conjunto de prueba no cambia ningún ranker; elegir una corrección a partir de ellos, sí.
- Lo que mostró el capítulo: una puntuación solo es tan buena como sus juicios.
Este capítulo, en esta edición
Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 10 de 10 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.10.