Ranking
Unos 39 minutos de lectura, con 14 ejemplos en 12 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
- Describe cada candidato con características
- Aprende un ranking a partir de pares de productos
- Entrena LambdaMART con LightGBM
- Informar LambdaMART sobre las consultas de prueba
- Reordena la recuperación semántica con un cross-encoder
- Puntúa cada producto con un LLM
- Ordena los 20 productos con un prompt de LLM
- Invierte la entrada para medir el sesgo posicional
- Establece la profundidad de reordenamiento a partir de un presupuesto
- Destila el cross-encoder en un ranker pequeño
- Qué sale mal en producción
- Decisiones que tomó este capítulo
Al final de este capítulo podrás describir cada producto que devuelve la recuperación con sus características, entrenar un modelo de aprendizaje para ordenar con lightgbm a partir de tus propios juicios, reordenar la parte superior de la lista con un cross-encoder o con un LLM, medir el sesgo posicional de un reordenador basado en LLM, fijar la profundidad de reordenamiento contando sus costes y destilar un reordenador lento en uno rápido. También podrás decidir, mediante una comparación planificada sobre las consultas de prueba, si alguno de ellos supera a tu recuperación.
La recuperación semántica por sí sola sigue siendo el ordenador que hay que superar en la tienda, donde cada búsqueda se ordena con una sola puntuación de embeddings y nada más. Ordena los productos mediante embeddings de Snowflake/snowflake-arctic-embed-m-v1.5, y obtiene 0.830 en nDCG@10 sobre las 30 consultas de prueba. Ningún cambio de los capítulos 5 a 8 ha superado esa cifra con un margen establecido. Este capítulo se pregunta si una segunda etapa puede hacerlo: un modelo entrenado con los juicios propios de la tienda, un reordenador que lee la consulta y el producto juntos, o un LLM. El cross-encoder del capítulo 1 reordenó la recuperación híbrida, no la recuperación semántica, y nunca vio los juicios de la tienda.
Por eso este capítulo prueba los tres sobre los mejores resultados de la recuperación semántica, y cada uno se puntúa contra los juicios de la tienda. El reordenamiento reordena la parte superior de la lista de la recuperación con un modelo más lento. Los reordenadores de la tienda están registrados: cada uno se ejecutó una vez y guardó sus resultados, que los ejemplos leen.
El LLM de la tienda es el modelo abierto gemma4:12b-it-q4_K_M, con licencia Apache-2.0. Se ejecutó de forma local con la configuración del capítulo 4, que hace que siempre elija la palabra siguiente más probable, con el razonamiento desactivado, de modo que responde sin escribir su razonamiento, y con un esquema JSON, una descripción legible por máquina de la forma de la respuesta. recordings/llm_rerank.py reordenó los 20 primeros resultados de la recuperación semántica solo para las consultas de prueba, así que nada de los reordenadores basados en LLM puede ajustarse. Todas las puntuaciones usan los juicios humanos, porque en un estudio los jueces LLM valoraron demasiado alto a los reordenadores LLM (Qué sale mal en producción). Estos resultados describen un modelo y dos instrucciones, así que tómalos como lo que son para la tienda, no como un veredicto sobre los reordenadores basados en LLM.
El capítulo fijó sus 5 comparaciones planificadas sobre las consultas de prueba antes de leer ningún resultado de prueba. Cada una enfrenta un método con la ejecución de la recuperación semántica según nDCG@10:
- LambdaMART, un ordenador aprendido entrenado con los juicios de las consultas de entrenamiento, que ordena los productos candidatos de cada consulta
- el cross-encoder reordenando los 20 primeros de la recuperación semántica
- el LLM puntuando cada uno de los 20 primeros por separado
- el LLM ordenando los 20 primeros en una sola instrucción
- un ordenador destilado pequeño entrenado con las puntuaciones del cross-encoder
El criterio es la regla del libro: 5 comparaciones planificadas dividen su 0.05, así que cada una necesita un p-valor de la prueba de permutación pareada por debajo de 0.01. Junto a ella se sitúan la prueba t pareada y un intervalo bootstrap del 99 %.
Describe cada candidato con características
La primera de las comparaciones planificadas del capítulo es un ranker aprendido, que no lee texto. Un ranker aprendido puntúa cada par de consulta y producto a partir de una lista de números, sus características, y aprende a partir de los juicios cómo ponderarlas. Una característica dependiente de la consulta describe la consulta y el producto juntos, como una puntuación BM25. Una característica independiente de la consulta describe solo el producto, como cuántos compradores lo valoraron. Los conjuntos de características para búsqueda web mezclan ambos tipos: LETOR 4.0, un benchmark para aprendizaje para ordenar, tiene 46 características, entre ellas "BM25 del título", "PageRank" y "Número de barras en la URL" (Qin y Liu, 2013). Un ranker puntúa solo los candidatos, los productos que devuelve una etapa de recuperación más barata, así que sus características pueden ser costosas.
Los candidatos de cada consulta de la tienda son los productos que puntuó la grabación del cross-encoder: la unión de los 100 primeros de BM25 y los 100 primeros de recuperación semántica. lib.ranking.feature_table da a cada candidato 8 características:
bm25: la puntuación BM25 delib.lexical, la línea base sin stemming del libro, y 0 para un producto que no comparte ningún término con la consultasimilarity: la similitud coseno entre los embeddings de la consulta y del productocross_encoder: la puntuación registrada del cross-encodername_matchyattribute_match: la proporción de los términos de la consulta, tokenizados como lo hace el capítulo 5, que aparecen en el nombre del producto y en sus atributosrating_count,average_ratingyreview_count, que los datos de la tienda asignan a cada producto
2632 de los productos del catálogo no tienen valoración, y sus tres características de valoración quedan ausentes. La tabla también recoge la calificación humana de cada candidato, o un hueco cuando nadie lo juzgó. Construye la tabla para las consultas de entrenamiento, observa una consulta y luego compara cada característica entre las calificaciones:
1"""Builds the feature table for the train queries, shows one query's candidates, and compares each feature's mean across2the human grades. The prose's point rests on the mean cross_encoder line for each grade and the mean of each feature by grade."""3import pandas as pd45from lib.ranking import FEATURES, feature_table6from lib.store import load_products, load_queries78products, queries = load_products(), load_queries("train") # train queries: features are design work9table = feature_table(products, queries)10print(f"features: {len(FEATURES)}")11print(f"train candidates: {len(table)}")12print(f"train candidates per query, median: {table.groupby('query_id').size().median():.0f}")13print(f"share of train candidates nobody judged: {table['grade'].isna().mean():.3f}")1415query_id = queries.index[queries["query"] == "laundry basket with wheels"][0]16one = table[table["query_id"] == query_id].sort_values("cross_encoder", ascending=False)17one = one.assign(name=products.loc[one["product_id"], "name"].str[:38].to_numpy())18pd.set_option("display.width", 200)19print(f"\ncandidates for laundry basket with wheels: {len(one)}")20print(one[["name", "bm25", "similarity", "cross_encoder", "name_match", "attribute_match", "rating_count", "grade"]]21 .head(6).round(3).to_string(index=False))22print(f"top 6 by cross-encoder, exact: {(one['grade'].head(6) == 2).sum()}")2324# grades 2, 1 and 0 are exact, partial and irrelevant; a missing grade means nobody judged the pair25label = table["grade"].map({2: "exact", 1: "partial", 0: "irrelevant"}).fillna("unjudged")26means = table[FEATURES].groupby(label).mean().loc[["exact", "partial", "irrelevant", "unjudged"]]27print("\nmean of each feature by grade, train candidates:")28print(means.round(3).to_string())29for grade in means.index:30 print(f"mean cross_encoder, {grade}: {means.at[grade, 'cross_encoder']:.3f}")31relevance = ["bm25", "similarity", "cross_encoder", "name_match"]32nearer = [name for name in relevance if abs(means.at["unjudged", name] - means.at["irrelevant", name])33 < abs(means.at["unjudged", name] - means.at["partial", name])]34print(f"relevance features where unjudged sits nearer irrelevant than partial: {len(nearer)} of {len(relevance)}")35medians = table[["rating_count", "review_count"]].groupby(label).median().loc[means.index] # counts are skewed36for grade in ["exact", "partial", "irrelevant"]:37 print(f"rating_count, {grade}, mean: {means.at[grade, 'rating_count']:.3f}")38 print(f"rating_count, {grade}, median: {medians.at[grade, 'rating_count']:.1f}")39print(f"products with no rating: {products['rating_count'].isna().sum()}")
python ranking-features-by-grade.pyfeatures: 8
train candidates: 6896
train candidates per query, median: 131
share of train candidates nobody judged: 0.286
candidates for laundry basket with wheels: 125
name bm25 similarity cross_encoder name_match attribute_match rating_count grade
laundry sorter basket on wheels 8.229 0.597 3.433 1.000 0.0 NaN 2.0
vintage laundry basket 6.270 0.572 2.995 0.667 0.0 638.0 2.0
rolling wicker laundry basket 5.494 0.588 2.974 0.667 0.0 110.0 2.0
aluminum frame laundry basket can be f 4.739 0.524 2.941 0.667 0.0 14.0 2.0
rebrilliant rolling laundry hamper 5.537 0.558 2.804 0.333 0.0 17.0 2.0
4-bag laundry hamper sorter cart baske 6.012 0.543 2.739 0.667 0.0 NaN 2.0
top 6 by cross-encoder, exact: 6
mean of each feature by grade, train candidates:
bm25 similarity cross_encoder name_match attribute_match rating_count average_rating review_count
grade
exact 4.317 0.517 2.191 0.562 0.024 466.879 4.537 333.589
partial 3.936 0.454 1.513 0.461 0.030 385.454 4.539 288.779
irrelevant 2.760 0.360 1.159 0.404 0.006 246.781 4.552 159.052
unjudged 2.323 0.369 1.050 0.140 0.018 339.904 4.520 237.027
mean cross_encoder, exact: 2.191
mean cross_encoder, partial: 1.513
mean cross_encoder, irrelevant: 1.159
mean cross_encoder, unjudged: 1.050
relevance features where unjudged sits nearer irrelevant than partial: 4 of 4
rating_count, exact, mean: 466.879
rating_count, exact, median: 43.0
rating_count, partial, mean: 385.454
rating_count, partial, median: 31.0
rating_count, irrelevant, mean: 246.781
rating_count, irrelevant, median: 35.5
products with no rating: 2632
Las consultas de entrenamiento tienen 6896 candidatos, una mediana de 131 por consulta, y nadie juzgó una proporción de 0.286 de ellos.
laundry basket with wheels tiene 125 candidatos. Los seis primeros según la puntuación del cross-encoder incluyen 6 productos exactos. Su attribute_match es 0, porque los atributos contienen colores, materiales y tamaños, no palabras como wheels.
En los candidatos de entrenamiento, la media de la puntuación del cross-encoder baja de 2.191 en los productos exactos a 1.513 en los parciales y 1.159 en los irrelevantes, y bm25, similarity y name_match bajan de la misma forma. average_rating y attribute_match apenas se mueven.
Las medias de rating_count bajan con la calificación, pero las medianas no: unos pocos productos con muchas valoraciones elevan las medias.
| Calificación | Media de número de valoraciones | Mediana de número de valoraciones |
|---|---|---|
| exact | 466.879 | 43.0 |
| partial | 385.454 | 31.0 |
| irrelevant | 246.781 | 35.5 |
Los candidatos sin juzgar tienen una puntuación media de cross-encoder de 1.050, y en 4 of 4 características que bajan con la calificación, su media está más cerca de la de los productos irrelevantes que de la de los parciales. Eso importa para lo que un candidato sin juzgar debe enseñar a un modelo.
Regla práctica: Empieza por las características que ya calculas: la puntuación de cada recuperador, la puntuación de un reranker si tienes uno, las coincidencias en campos como el nombre y las señales de popularidad. Compara cada característica por calificación en las consultas de entrenamiento antes de entrenar, con medias para las puntuaciones y medianas para los conteos asimétricos. Una característica que no se mueve con la calificación enseña poco al modelo. Calcula las características con el mismo código al entrenar y al servir.
Aprende un ranking a partir de pares de productos
Learning to rank (aprendizaje para ordenar) entrena un modelo con consultas juzgadas para ordenar los candidatos según sus características. Sus métodos se dividen en tres familias: puntual, por pares y por lista (Liu, 2009). Un modelo puntual predice la calificación de cada producto por separado, como una regresión. Un modelo por pares aprende cuál de dos productos debe ir más arriba. Un modelo por lista puntúa un ranking completo. La comparación de Liu de 2009 sobre el benchmark LETOR favoreció el enfoque por lista, aunque de forma tentativa. El obstáculo para las tres es la métrica: nDCG solo cambia cuando dos productos intercambian posiciones, así que, según las métricas de ranking, "are everywhere either discontinuous or flat, so gradient descent appears to be problematic" (Burges, 2010).
RankNet, un método por pares, lo resuelve con una pérdida suave sobre los pares. Para dos productos en los que i debe ir por encima de j, su gradiente es grande cuando el modelo los puntúa al revés o casi igual, y pequeño cuando ya los tiene bien separados. LambdaRank conserva ese gradiente y lo multiplica por cuánto cambiaría nDCG si los dos productos intercambiaran posiciones (Burges, 2010, sección 4.1). Burges escribe el gradiente con signo menos, como la pendiente de un coste; aquí una λ positiva empuja i hacia arriba:
λ_ij = σ / (1 + exp(σ · (s_i − s_j))) · |ΔnDCG_ij| s: the model's scores, σ = 1
ΔnDCG_ij = (g_i − g_j) · (1 / log2(1 + r_i) − 1 / log2(1 + r_j)) / ideal DCG g: grades, r: positions
El total de un producto es la suma de su λ sobre los pares en los que debe ir más arriba, menos la suma de las λ de aquellos en los que debe ir más abajo. Burges (2010) también interpreta las λ como fuerzas que empujan los productos arriba y abajo en la lista.
LambdaMART usa la λ de LambdaRank como gradientes para los árboles con boosting de gradiente, que añaden pequeños árboles de decisión uno a uno, cada uno ajustado a los gradientes de los árboles anteriores: "LambdaMART is the boosted tree version of LambdaRank, which is based on RankNet". Un conjunto de rankers LambdaMART ganó la Pista 1 del Learning to Rank Challenge que Yahoo organizó en 2010 (Burges, 2010).
Una consulta de entrenamiento, outdoor waterproof chest, muestra la aritmética. Sea la similitud semántica las puntuaciones del modelo hasta ahora; calcula a mano la λ de cada par en sus 10 primeros, comprueba cada |ΔnDCG| intercambiando el par y recalculando nDCG con lib.metrics, y suma las fuerzas:
1"""Works out LambdaRank's λ for every pair in one train query's top 10 by hand, and checks each pair's |ΔnDCG| against2swapping the pair in the metric. The prose's point rests on the strongest push up and down, and on the count of pairs3whose formula matches swapping."""4import math5from itertools import combinations67from lib.metrics import dcg_at_k, ndcg_at_k8from lib.semantic import SemanticSearch9from lib.store import load_queries, qrels1011queries, judgments = load_queries("train"), qrels("train")12query_id = queries.index[queries["query"] == "outdoor waterproof chest"][0]13judged = judgments[query_id]14scores = SemanticSearch().search(query_id, k=10) # the model so far: semantic similarity15ranking, similarity = list(scores.index), scores.to_numpy()16# an unjudged product counts as grade 0, as it does in the metric17grades = [judged.get(product_id, 0) for product_id in ranking]18# the ideal DCG takes every judged product, as lib.metrics does; sigma is 1, LightGBM's default sigmoid19ideal, sigma = dcg_at_k(sorted(judged.values(), reverse=True), 10), 1.020print("grades from the top:", " ".join(map(str, grades)))2122force, checks, pulls = [0.0] * len(ranking), [], []23for i, j in combinations(range(len(ranking)), 2): # i is above j24 if grades[i] == grades[j]:25 continue26 better, worse = (i, j) if grades[i] > grades[j] else (j, i)27 ranknet = 1 / (1 + math.exp(sigma * (similarity[better] - similarity[worse]))) # RankNet's pull28 # i and j count from 0, so position p is i + 1 and its discount is 1 / log2(p + 1), which is 1 / log2(i + 2)29 delta = abs((grades[i] - grades[j]) * (1 / math.log2(i + 2) - 1 / math.log2(j + 2))) / ideal30 swapped = ranking.copy()31 swapped[i], swapped[j] = swapped[j], swapped[i]32 checks.append(math.isclose(delta, abs(ndcg_at_k(swapped, judged, 10) - ndcg_at_k(ranking, judged, 10))))33 pulls.append(ranknet)34 pair_lambda = sigma * ranknet * delta # LambdaRank: scaled by |delta nDCG|35 force[better], force[worse] = force[better] + pair_lambda, force[worse] - pair_lambda3637print(f"pairs with different grades: {len(checks)}")38print(f"pairs where delta ndcg by formula matches swapping the pair: {sum(checks)}")39for position, push in enumerate(force, start=1):40 print(f"force at position {position}: {push:+.3f}")41# list indexes count from 0 and positions from 1, hence the + 142print(f"strongest push up, position: {force.index(max(force)) + 1}")43print(f"strongest push down, position: {force.index(min(force)) + 1}")44print(f"ranknet's pull, lowest: {min(pulls):.3f}\nranknet's pull, highest: {max(pulls):.3f}")
python lambdas-for-one-query.pygrades from the top: 1 2 2 0 1 2 0 2 0 0
pairs with different grades: 32
pairs where delta ndcg by formula matches swapping the pair: 32
force at position 1: +0.013
force at position 2: +0.159
force at position 3: +0.104
force at position 4: -0.083
force at position 5: -0.010
force at position 6: +0.063
force at position 7: -0.092
force at position 8: +0.063
force at position 9: -0.105
force at position 10: -0.111
strongest push up, position: 2
strongest push down, position: 10
ranknet's pull, lowest: 0.472
ranknet's pull, highest: 0.525
El |ΔnDCG| de la fórmula coincide con el cambio al intercambiar el par en 32 de los 32 pares de los 10 primeros con calificaciones distintas. Las calificaciones de los 10 primeros, desde arriba, son 1 2 2 0 1 2 0 2 0 0; un producto sin juzgar cuenta como 0, como ocurre en la métrica.
El empuje hacia arriba más fuerte va a la posición 2, un producto exacto, con +0.159; el empuje hacia abajo más fuerte va a la posición 10, un producto irrelevante, con -0.111. El producto parcial en la posición 1 recibe un empuje neto de +0.013: los productos irrelevantes situados debajo lo empujan hacia arriba, y los exactos lo empujan hacia abajo.
El factor de RankNet en λ se mantiene entre 0.472 y 0.525, porque las similitudes están muy juntas, así que |ΔnDCG| decide casi todo.
Ese ejemplo es una simplificación. Toma el DCG ideal de todos los productos juzgados, como hace lib.metrics, y mira solo diez productos. LightGBM toma el ideal de las filas de entrenamiento de la consulta, y con 4.7.0 dos valores por defecto cambian la λ. lambdarank_truncation_level vale 30, lo que limita el entrenamiento a los 30 primeros resultados: solo los pares con un producto en el top 30 actual reciben una λ. lambdarank_norm vale true, lo que normaliza las lambdas entre consultas; ponlo en false para obtener el algoritmo lambdarank original (Parameters). La normalización, tal como la hace el código fuente de LightGBM, divide el |ΔnDCG| de cada par entre la distancia entre sus puntuaciones más 0.01, y luego reescala la λ de cada consulta (rank_objective.hpp). Para comprobar la fórmula contra la biblioteca, escríbela como un objetivo personalizado de LightGBM, haz crecer cinco árboles pequeños sobre los candidatos de esta consulta, y hazlos crecer de nuevo con lambdarank de LightGBM, con y sin esos valores por defecto:
1"""Writes LambdaRank's gradients by hand as a custom LightGBM objective, then checks them against LightGBM's own lambdarank2on one query, with and without its defaults. The prose's point rests on the two printed differences: a rounding-sized gap3without the defaults, and a large one at them."""4import numpy as np5from lightgbm import LGBMRanker67from lib.ranking import DETERMINISTIC, FEATURES, feature_table8from lib.store import load_products, load_queries910queries = load_queries("train")11one = queries[queries["query"] == "outdoor waterproof chest"]12rows = feature_table(load_products(), one) # one query's candidates, in product_id order13# unjudged candidates count as grade 0, as in the metric14grades = rows["grade"].fillna(0).astype(int).to_numpy()15SIGMA = 1.0 # LightGBM's default sigmoid161718def lambdas(y_true, y_pred, weight, group):19 """The chapter's lambda for every pair with different grades, as gradients and second derivatives."""20 rank = np.empty(len(y_pred), dtype=int)21 rank[np.argsort(-y_pred, kind="stable")] = np.arange(len(y_pred)) # LightGBM's stable sort on score22 # rank counts from 0, so the product at position rank + 1 has the discount 1 / log2(rank + 2)23 discount, ideal = 1 / np.log2(rank + 2), np.sum(np.sort(y_true)[::-1] / np.log2(np.arange(len(y_true)) + 2))24 gradient, hessian = np.zeros(len(y_pred)), np.zeros(len(y_pred))25 for i in range(len(y_true)):26 for j in np.flatnonzero(y_true < y_true[i]): # i should rank above j27 delta = (y_true[i] - y_true[j]) * abs(discount[i] - discount[j]) / ideal28 pull = 1 / (1 + np.exp(SIGMA * (y_pred[i] - y_pred[j])))29 gradient[i], gradient[j] = gradient[i] - SIGMA * pull * delta, gradient[j] + SIGMA * pull * delta30 hessian[[i, j]] += SIGMA ** 2 * pull * (1 - pull) * delta31 return gradient, hessian323334# five small trees; min_child_samples is 5 where LightGBM's default is 20, so the trees can split this query's candidates35tree = {"n_estimators": 5, "num_leaves": 3, "min_child_samples": 5, **DETERMINISTIC}36# turns off normalization and sets truncation to every candidate, so every pair gets a λ, as the formula has it37plain = {"lambdarank_norm": False, "lambdarank_truncation_level": len(rows)} # LightGBM's lambdas, untouched38models = {"by hand": LGBMRanker(objective=lambdas, **tree),39 "lightgbm, no normalization or truncation": LGBMRanker(objective="lambdarank", label_gain=[0, 1, 2], **plain, **tree),40 "lightgbm at its defaults": LGBMRanker(objective="lambdarank", label_gain=[0, 1, 2], **tree)}41# raw scores: the values the gradients act on, before any sigmoid42scores = {name: model.fit(rows[FEATURES], grades, group=[len(rows)]).predict(rows[FEATURES], raw_score=True)43 for name, model in models.items()}44print(f"candidates: {len(rows)}")45for name in list(models)[1:]:46 difference = np.abs(scores[name] - scores["by hand"]).max()47 print(f"{name}, largest difference from the lambdas by hand after 5 trees: {difference:.6f}")
python lambdas-match-lightgbm.pycandidates: 180
lightgbm, no normalization or truncation, largest difference from the lambdas by hand after 5 trees: 0.000006
lightgbm at its defaults, largest difference from the lambdas by hand after 5 trees: 0.595667
Sobre los 180 candidatos de la consulta, LightGBM sin normalización ni truncamiento puntúa cada producto a menos de 0.000006 de las puntuaciones del objetivo personalizado. La diferencia es de redondeo, ya que LightGBM toma su sigmoide de una tabla precalculada (rank_objective.hpp). Con sus valores por defecto, las puntuaciones difieren hasta en 0.595667.
Regla práctica: Entrena rankers con un gradiente que pondere cada par según la métrica que reportas, como hace LambdaMART, en lugar de hacer regresión sobre las calificaciones. Conoce qué valores por defecto de tu biblioteca cambian ese gradiente, y comprueba en consultas de entrenamiento que supera a un modelo puntual con tus datos, porque el orden de las familias en un benchmark no se traslada por sí solo.
Entrena LambdaMART con LightGBM
LightGBM entrena LambdaMART con LGBMRanker y objective="lambdarank". Cuatro ajustes requieren cuidado, y cada uno está documentado para 4.7.0:
- Las filas se agrupan por consulta. "data should be ordered by the query", y
groupcontiene el número de filas de cada consulta en ese orden, no los identificadores de consulta, de modo que sus tamaños suman el número de filas (sum(group) = n_samples; Parameters;LGBMRanker). - Las ganancias son exponenciales por defecto.
label_gaintoma por defecto0,1,3,7,15,31,63,..., así que "the gain of label2is3", y cada etiqueta debe ser menor que el número de ganancias (Parameters). Esa es la DCG de Burges, con ganancia 2^grado − 1. El nDCG del libro usa ganancias lineales, así que establecelabel_gain=[0, 1, 2]. - El nDCG se evalúa en las posiciones 1 a 5 por defecto. Establece
eval_at=[10]para detenerse en nDCG@10 e informa la puntuación final conlib.metricsde todas formas. - Los datos de validación van en
eval_Xyeval_y. En 4.7.0,eval_setes "Deprecated since version 4.7.0", yeval_Xyeval_ylo reemplazan (LGBMRanker; notas de la versión). Los ejemplos pasaneval_X,eval_yyeval_group.
La parada temprana puntúa las consultas de entrenamiento reservadas después de cada árbol, y conserva los árboles hasta la mejor puntuación cuando otros 30 no aportan ninguna mejora. Para que el entrenamiento se repita exactamente, los ejemplos usan un solo hilo, una semilla fija y deterministic=True, que "should ensure the stable results when using the same data" (Parameters), junto con force_row_wise=True, que la misma entrada recomienda, para evitar posibles inestabilidades por problemas numéricos. lib.ranking contiene estos ajustes, y su fit aplica la agrupación y la parada temprana.
El orden de las filas también importa. Antes del primer árbol todas las puntuaciones son 0, así que LightGBM toma el orden de las filas como el ranking inicial para la primera λ, y las puntuaciones iguales necesitan un criterio de desempate. El registro del codificador cruzado enumera los candidatos de cada consulta del mejor al peor, lo que entregaría al modelo el ranking del codificador cruzado antes de que aprendiera nada. Por eso feature_table ordena los candidatos por product_id, y lib.ranking.ranked rompe los empates por product_id.
Elige el tamaño de los árboles mediante validación cruzada en las consultas de entrenamiento: divídelas en cinco particiones, ordena cada partición con un modelo ajustado en otras tres y detenido temprano en la quinta, y puntúe cada consulta una vez. Prueba ocho ajustes, de 3 a 31 hojas con dos tasas de aprendizaje, contando los candidatos sin juzgar como grado 0, como lo hace la métrica:
1"""Cross-validates LambdaMART on the train queries over eight tree sizes and learning rates, and names the best. The prose's2point rests on the best setting's score, and on the score beside it for LightGBM's default of 31 leaves at 0.1."""3from lightgbm import LGBMRanker45from lib.metrics import evaluate6from lib.ranking import DETERMINISTIC, FEATURES, LAMBDARANK, TREE_GRID, TREES, cross_validate, feature_table7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("train"), qrels("train") # tuning: train queries only11candidates = feature_table(load_products(), queries)12candidates["grade or 0"] = candidates["grade"].fillna(0).astype(int) # unjudged counts as irrelevant, as in nDCG13print(f"train queries: {len(queries)}")14print(f"semantic, train ndcg@10: {evaluate(SemanticSearch().run(queries, k=100), judgments)['ndcg@10'].mean():.3f}")1516results = {}17for setting in TREE_GRID: # LightGBM's default is 31 leaves at 0.118 name = f"{setting['num_leaves']} leaves, learning rate {setting['learning_rate']}"19 # up to 500 trees; early stopping inside cross_validate keeps fewer20 model = lambda: LGBMRanker(**LAMBDARANK, n_estimators=500, **setting, **DETERMINISTIC)21 # one nDCG@10 per train query, each ranked by a model that never saw that query22 results[name] = cross_validate(model, candidates, candidates, "grade or 0", FEATURES, judgments)23 print(f"{name}, cross-validated ndcg@10: {results[name].mean():.3f}")24 # the trees early stopping kept in each fold25 print(f"{name}, trees kept per fold: {', '.join(map(str, results[name].attrs['trees']))}")26best = max(results, key=lambda name: results[name].mean())27print(f"settings tried: {len(results)}")28print(f"best setting: {best}")29print(f"lib.ranking.TREES holds it: {'yes' if best == f'{TREES['num_leaves']} leaves, learning rate {TREES['learning_rate']}' else 'no'}")
python lambdamart-tree-size-on-train.pytrain queries: 50
semantic, train ndcg@10: 0.772
3 leaves, learning rate 0.05, cross-validated ndcg@10: 0.780
3 leaves, learning rate 0.05, trees kept per fold: 18, 27, 52, 20, 85
3 leaves, learning rate 0.1, cross-validated ndcg@10: 0.798
3 leaves, learning rate 0.1, trees kept per fold: 99, 20, 8, 43, 38
7 leaves, learning rate 0.05, cross-validated ndcg@10: 0.744
7 leaves, learning rate 0.05, trees kept per fold: 2, 28, 30, 39, 55
7 leaves, learning rate 0.1, cross-validated ndcg@10: 0.772
7 leaves, learning rate 0.1, trees kept per fold: 80, 12, 13, 7, 20
15 leaves, learning rate 0.05, cross-validated ndcg@10: 0.720
15 leaves, learning rate 0.05, trees kept per fold: 4, 37, 175, 44, 120
15 leaves, learning rate 0.1, cross-validated ndcg@10: 0.728
15 leaves, learning rate 0.1, trees kept per fold: 19, 68, 136, 48, 53
31 leaves, learning rate 0.05, cross-validated ndcg@10: 0.679
31 leaves, learning rate 0.05, trees kept per fold: 15, 8, 91, 8, 22
31 leaves, learning rate 0.1, cross-validated ndcg@10: 0.737
31 leaves, learning rate 0.1, trees kept per fold: 11, 75, 166, 96, 58
settings tried: 8
best setting: 3 leaves, learning rate 0.1
lib.ranking.TREES holds it: yes
De 8 ajustes, el mejor es 3 leaves, learning rate 0.1, con 0.798; el valor por defecto de LightGBM de 31 hojas con 0.1 (LGBMRanker) obtiene 0.737. El mejor de todos los ajustes se favorece a sí mismo, así que espera menos en consultas reservadas.
Una elección depende de los juicios de la tienda. Nadie juzgó una proporción de 0.286 de los candidatos de entrenamiento. Un modelo puede contarlos como grado 0, o aprender solo de los candidatos juzgados; sin juzgar no significa irrelevante, pero el modelo los ordenará en tiempo de consulta de todos modos. Compara ambos por validación cruzada al tamaño de árbol elegido, junto con una regresión puntual sobre los grados:
1"""Compares three ways of training on the train queries, each by cross-validation: LambdaRank with unjudged candidates as 0,2LambdaRank on judged candidates only, and pointwise regression. The prose's point rests on the differences and the3permutation p-values printed under each setup."""4from lightgbm import LGBMRanker, LGBMRegressor56from lib.metrics import evaluate7from lib.ranking import DETERMINISTIC, FEATURES, LAMBDARANK, TREES, cross_validate, feature_table8from lib.semantic import SemanticSearch9from lib.significance import compare10from lib.store import load_products, load_queries, qrels1112queries, judgments = load_queries("train"), qrels("train") # tuning: train queries only13candidates = feature_table(load_products(), queries)14candidates["grade or 0"] = candidates["grade"].fillna(0).astype(int) # unjudged counts as irrelevant15# the rows the model learns from when unjudged candidates are left out; it still ranks every candidate at query time16judged_only = candidates.dropna(subset=["grade"]).astype({"grade": int})1718setups = { # (model, rows it learns from, label)19 "lambdarank, unjudged as 0": (lambda: LGBMRanker(**LAMBDARANK, **TREES, **DETERMINISTIC), candidates, "grade or 0"),20 "lambdarank, unjudged left out": (lambda: LGBMRanker(**LAMBDARANK, **TREES, **DETERMINISTIC), judged_only, "grade"),21 "pointwise regression, unjudged as 0": (lambda: LGBMRegressor(**TREES, **DETERMINISTIC), candidates, "grade or 0"),22}23semantic = evaluate(SemanticSearch().run(queries, k=100), judgments)["ndcg@10"]24print(f"semantic, train ndcg@10: {semantic.mean():.3f}")25scores = {name: cross_validate(model, rows, candidates, label, FEATURES, judgments)26 for name, (model, rows, label) in setups.items()}27chosen = scores["lambdarank, unjudged as 0"]28for name, per_query in scores.items():29 print(f"{name}, cross-validated ndcg@10: {per_query.mean():.3f}")30 if name != "lambdarank, unjudged as 0":31 # the mean difference is the first argument minus the second, tested by permutation over the queries32 result = compare(per_query, chosen)33 print(f"{name}, minus the first: {result['mean difference']:.3f}")34 print(f"{name}, minus the first, permutation p: {result['permutation p']:.3f}")35result = compare(chosen, semantic)36print(f"first setup minus semantic: {result['mean difference']:.3f}")37print(f"first setup minus semantic, permutation p: {result['permutation p']:.3f}")
python lambdamart-choices-on-train.pysemantic, train ndcg@10: 0.772
lambdarank, unjudged as 0, cross-validated ndcg@10: 0.798
lambdarank, unjudged left out, cross-validated ndcg@10: 0.733
lambdarank, unjudged left out, minus the first: -0.064
lambdarank, unjudged left out, minus the first, permutation p: 0.005
pointwise regression, unjudged as 0, cross-validated ndcg@10: 0.769
pointwise regression, unjudged as 0, minus the first: -0.029
pointwise regression, unjudged as 0, minus the first, permutation p: 0.007
first setup minus semantic: 0.026
first setup minus semantic, permutation p: 0.242
Contar los candidatos sin juzgar como 0 puntúa más que excluirlos, 0.798 frente a 0.733, una diferencia de -0.064 con un valor p de permutación de 0.005. Un modelo que nunca ve un candidato sin juzgar en el entrenamiento aún debe ordenarlo, y las características indican que parecen productos irrelevantes.
La regresión puntual puntúa 0.769, una diferencia de -0.029 (p = 0.007), así que en las consultas de entrenamiento de la tienda una comprobación de ajuste frente a un modelo puntual favorece a LambdaMART.
Frente al 0.772 de la recuperación semántica, la configuración elegida difiere en 0.026, con un valor p de permutación de 0.242: incluso en las consultas que la eligieron, no muestra una mejora que las consultas de entrenamiento puedan distinguir del azar.
Regla práctica: Ordena las filas por consulta y pasa group, establece label_gain con las ganancias que use tu métrica, detén el entrenamiento antes de tiempo en las consultas de entrenamiento reservadas mediante eval_X y eval_y, y fija la semilla y el número de hilos. Ordena los candidatos de cada consulta por identificador de producto, como aconseja el capítulo 3, y rompe los empates de puntuación de la misma forma. Cuenta los candidatos sin juzgar como grado 0, salvo que la validación cruzada en las consultas de entrenamiento indique lo contrario. Con pocas consultas juzgadas, prueba árboles pequeños.
Informar LambdaMART sobre las consultas de prueba
Un modelo ajustado con consultas de entrenamiento se informa una sola vez sobre las consultas de prueba, mediante una comparación planificada antes de mirar los resultados. La importancia de las variables muestra lo que aprendió un modelo: la importancia de "gain" en LightGBM es la "ganancia total de las divisiones que usan la variable" (Booster), así que una variable sin ganancia no participa en la puntuación.
La primera comparación planificada usa la configuración elegida con las consultas de entrenamiento: LambdaMART con todas las variables, con 3 hojas y una tasa de aprendizaje de 0.1, los candidatos no juzgados como grado 0, y los candidatos en orden product_id. Se ajusta con 40 consultas de entrenamiento, se detiene pronto con 10 otras, y ordena los candidatos de cada consulta de prueba. Para que haya una ganancia, el valor p de la permutación debe estar por debajo de 0.01:
1"""Fits LambdaMART on the train queries with the chosen setup, reports its early stopping and gain shares, then reports its2planned comparison on the test queries against semantic retrieval. The prose's point rests on that comparison's permutation3p-value, printed last, against the threshold printed first."""4from lightgbm import LGBMRanker56from lib.metrics import evaluate7from lib.ranking import (DETERMINISTIC, FEATURES, LAMBDARANK, PLANNED_TEST_COMPARISONS, THRESHOLD, TREES, feature_table,8 fit, ranked, report_planned, stopping_split)9from lib.semantic import SemanticSearch10from lib.store import load_products, load_queries, qrels1112products, train, test = load_products(), load_queries("train"), load_queries("test")13print(f"planned test comparisons: {len(PLANNED_TEST_COMPARISONS)}")14print(f"p-value threshold: {THRESHOLD:.2f}")1516table = feature_table(products, train)17table["grade or 0"] = table["grade"].fillna(0).astype(int) # the setup chosen on train18# 10 train queries are held out, at random with a fixed seed, to stop on19fit_ids, stop_ids = stopping_split(train.index)20model = fit(LGBMRanker(**LAMBDARANK, **TREES, **DETERMINISTIC), table, "grade or 0", FEATURES, fit_ids, stop_ids)21print(f"queries fitted: {len(fit_ids)}\nqueries held out for stopping: {len(stop_ids)}")22curve = model.evals_result_["valid_0"]["ndcg@10"] # LightGBM's nDCG@10, one value per tree23print(f"trees tried: {len(curve)}\ntrees kept by early stopping: {model.best_iteration_}")24print(f"stopping queries' ndcg@10, first tree: {curve[0]:.3f}")25# best_iteration_ counts trees from 1 and the curve from 0, so the last tree kept is at index best_iteration_ - 126print(f"stopping queries' ndcg@10, trees kept: {curve[model.best_iteration_ - 1]:.3f}")27gain = model.booster_.feature_importance(importance_type="gain") # total gain of the splits on each feature28# a feature with no gain was never split on, so it plays no part in the score29print(f"features the trees use: {(gain > 0).sum()} of {len(FEATURES)}")30for name, share in sorted(zip(FEATURES, gain / gain.sum()), key=lambda pair: -pair[1]):31 print(f"share of gain, {name}: {share:.3f}")3233candidates, judgments = feature_table(products, test), qrels("test") # test queries: read once, to report34after = evaluate(ranked(candidates, model.predict(candidates[FEATURES])), judgments)35before = evaluate(SemanticSearch().run(test, k=100), judgments)36for name, frame in [("semantic", before), ("lambdamart", after)]:37 print(f"{name}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")38 print(f"{name}, test judged@10: {frame['judged@10'].mean():.3f}")39 # each query's top 10 is 10 places, so (1 - judged@10) times 10 counts its unjudged places40 print(f"{name}, unjudged places in the test top 10s: {round((1 - frame['judged@10']).sum() * 10)}")41report_planned("lambdamart", after["ndcg@10"], before["ndcg@10"])
python lambdamart-on-test.pyplanned test comparisons: 5
p-value threshold: 0.01
queries fitted: 40
queries held out for stopping: 10
trees tried: 243
trees kept by early stopping: 213
stopping queries' ndcg@10, first tree: 0.568
stopping queries' ndcg@10, trees kept: 0.794
features the trees use: 8 of 8
share of gain, cross_encoder: 0.641
share of gain, similarity: 0.172
share of gain, name_match: 0.097
share of gain, bm25: 0.043
share of gain, review_count: 0.021
share of gain, rating_count: 0.021
share of gain, attribute_match: 0.002
share of gain, average_rating: 0.001
semantic, test ndcg@10: 0.830
semantic, test judged@10: 0.990
semantic, unjudged places in the test top 10s: 3
lambdamart, test ndcg@10: 0.817
lambdamart, test judged@10: 0.990
lambdamart, unjudged places in the test top 10s: 3
lambdamart, mean difference: -0.012
lambdamart, wins, losses, ties: 14, 12, 4
lambdamart, permutation p: 0.260
lambdamart, established at 0.01: no
lambdamart, t-test p: 0.278
lambdamart, t-test agrees: yes
lambdamart, 99% interval: -0.044 to 0.011
lambdamart, interval agrees: yes
De 243 árboles probados, la detención temprana conserva 213. En las consultas reservadas para la detención, el nDCG@10 propio de LightGBM, cuyo ideal proviene solo de sus candidatos, sube de 0.568 tras el primer árbol a 0.794 con los árboles conservados.
Los árboles usan 8 of 8 variables, pero dependen del codificador cruzado, que aporta una proporción de 0.641 de la ganancia, por delante de similarity con 0.172, name_match con 0.097 y bm25 con 0.043. Por tanto, poner el modelo en funcionamiento exige una llamada al codificador cruzado por cada candidato.
LambdaMART no establece una ganancia en las consultas de prueba: obtiene 0.817 de nDCG@10, frente al 0.830 de la recuperación semántica, con un valor p de permutación de 0.260 (las cinco comparaciones). Judged@10 es 0.990 para LambdaMART y 0.990 para la recuperación semántica.
Regla práctica: adopta un ranker aprendido solo cuando su comparación de prueba planificada esté establecida. Lee su importancia por ganancia antes de confiar en él, porque las variables en las que se apoya son las que pagarás en el momento de la consulta. La detención temprana con unas pocas consultas reservadas hace que división a división se conserven números de árboles muy distintos, desde 99, 20, 8, 43, 38 entre los pliegues de validación cruzada hasta 213 aquí. Una regla práctica, no una medición: con tan pocas consultas, juzga más consultas antes de seguir ajustando, y trata cualquier punto de detención concreto como ruido.
Reordena la recuperación semántica con un cross-encoder
La recuperación semántica usa un modelo de embeddings, también llamado bi-encoder, que lee la consulta y cada producto por separado, de modo que los embeddings de los productos se calculan de antemano. Un cross-encoder lee la consulta y un producto juntos y devuelve una sola puntuación (Nogueira y Cho, 2019). Puede relacionar cada palabra de la consulta con cada palabra del producto, y eso tiene un coste. Suele ser más lento que un modelo de Sentence Transformers, porque calcula para cada par y no para cada texto, por lo que "los Cross Encoders se usan a menudo para reordenar los resultados top-k" (Sentence Transformers). El cross-encoder de la tienda (ver la introducción) es pequeño para un modelo de lenguaje, con 149M de parámetros (ficha del modelo). Es el modelo abierto Alibaba-NLP/gte-reranker-modernbert-base, cuyo manifiesto, el archivo guardado junto con su grabación, indica que su licencia es Apache-2.0. Lo elegimos porque cualquiera puede descargarlo y volver a ejecutar la grabación. recordings/cross_encoder.py puntuó la unión de los 100 primeros resultados de BM25 y de la recuperación semántica para cada consulta (en dos consultas, su lista semántica difiere de la de lib.semantic por un casi empate en el puesto 100).
El capítulo 1 reordenó la ejecución híbrida. Aquí el cross-encoder reordena el ranker que hay que superar, los primeros 20 resultados de la recuperación semántica: los mismos productos que leen los rerankers basados en LLM, de modo que los tres rerankers del capítulo parten de listas idénticas. El capítulo fijó esa profundidad antes de ver ningún resultado de prueba, y no la ajusta. Reordena los 20 primeros según las puntuaciones registradas y deja el resto en su lugar. Esa es la segunda comparación planificada, que requiere un p-valor inferior a 0.01:
1"""Reranks semantic retrieval's top 20 with the recorded cross-encoder scores, and compares the two on the test queries.2The prose's point rests on the planned comparison's permutation p-value, and on the judged@10 lines, which show what the3rerank does to the judgments it can score."""4from lib.metrics import evaluate5from lib.ranking import DEPTH, rerank, report_planned6from lib.recorded import cross_encoder_scores, llm_listwise, manifest7from lib.semantic import SemanticSearch8from lib.store import load_queries, qrels910queries, judgments = load_queries("test"), qrels("test") # scored on the human judgments11semantic = SemanticSearch().run(queries, k=100)12recorded = cross_encoder_scores()13# the recorded score of each (query, product) pair14score = dict(zip(zip(recorded["query_id"], recorded["product_id"]), recorded["score"]))15print("cross-encoder model:", manifest("cross-encoder")["model"])16print("licence in the manifest:", manifest("cross-encoder")["model_licence"])1718# the set of products the LLM was shown for each query, from the listwise recording19shown = llm_listwise().groupby("query_id")["product_id"].apply(set) # what the LLM rerankers saw20same = sum(set(semantic[query_id][:DEPTH]) == shown[query_id] for query_id in queries.index)21print(f"rerank depth: {DEPTH}")22print(f"queries whose top {DEPTH} holds the products the llm rerankers saw: {same} of {len(queries)}")2324reranked = rerank(semantic, score, DEPTH) # top 20 reordered, the rest in place25before, after = evaluate(semantic, judgments), evaluate(reranked, judgments)26for name, frame in [("semantic", before), ("cross-encoder", after)]:27 print(f"{name}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")28 print(f"{name}, test judged@10: {frame['judged@10'].mean():.3f}")29 print(f"{name}, unjudged places in the test top 10s: {round((1 - frame['judged@10']).sum() * 10)}")30# index 0 is the first place31moved = sum(reranked[query_id][0] != semantic[query_id][0] for query_id in queries.index)32print(f"queries whose first product changes: {moved}")33report_planned("cross-encoder", after["ndcg@10"], before["ndcg@10"])
python cross-encoder-on-semantic.pycross-encoder model: Alibaba-NLP/gte-reranker-modernbert-base
licence in the manifest: Apache-2.0
rerank depth: 20
queries whose top 20 holds the products the llm rerankers saw: 30 of 30
semantic, test ndcg@10: 0.830
semantic, test judged@10: 0.990
semantic, unjudged places in the test top 10s: 3
cross-encoder, test ndcg@10: 0.813
cross-encoder, test judged@10: 0.983
cross-encoder, unjudged places in the test top 10s: 5
queries whose first product changes: 23
cross-encoder, mean difference: -0.016
cross-encoder, wins, losses, ties: 11, 12, 7
cross-encoder, permutation p: 0.178
cross-encoder, established at 0.01: no
cross-encoder, t-test p: 0.171
cross-encoder, t-test agrees: yes
cross-encoder, 99% interval: -0.058 to 0.006
cross-encoder, interval agrees: yes
Reordenar los 20 primeros no demuestra una mejora: el reordenamiento con cross-encoder obtiene 0.813 frente a 0.830, con un p-valor de permutación de 0.178 (ver la tabla de decisiones). Los 20 primeros contienen los productos que vieron los rerankers basados en LLM para 30 of 30 consultas de prueba, y el reranker cambia el primer producto en 23 de ellas.
Judged@10 baja de 0.990 a 0.983, y los puestos no juzgados en los 10 primeros de la prueba pasan de 3 a 5.
En las consultas de entrenamiento, el mismo reordenamiento obtiene 0.802 frente a los 0.772 de la recuperación semántica (barrido de profundidad). Las consultas de entrenamiento son otra muestra, y su veredicto repite lo que el capítulo 3 encontró: el orden de dos rankers parecidos puede invertirse entre conjuntos de consultas.
Regla práctica: Reordena tu recuperación más sólida, a una profundidad fijada antes de ver los resultados de prueba, y adopta el reranker solo si hay una mejora comprobada en consultas reservadas. El cross-encoder de uso general de la tienda queda fuera del pipeline.
Puntúa cada producto con un LLM
Un LLM también puede reordenar resultados, de tres maneras. Puntual (pointwise): un LLM juzga cada producto por separado y devuelve una etiqueta o una puntuación. Por pares (pairwise): un LLM indica cuál de dos productos encaja mejor con la consulta. Por lista (listwise): un LLM ordena una lista completa en una sola respuesta (Qin et al., 2024). En un estudio, sobre ocho conjuntos de datos de BEIR, una colección de bancos de pruebas de recuperación usados para evaluar modelos con datos con los que no fueron entrenados, las indicaciones puntuales dieron mejores resultados con respuestas graduadas que con sí o no, porque «la falta de opciones de relevancia intermedias puede llevar al LLM a dar respuestas ruidosas o sesgadas» (Zhuang et al., 2024a).
El LLM de la tienda, el modelo abierto que se nombra en la apertura del capítulo, veía la consulta y un solo producto a la vez: nombre, clase, categoría, descripción y atributos (lo que veía el LLM). La indicación pide una etiqueta, exact, partial o irrelevant, y «una puntuación de 0 a 100 de lo bien que encaja». Reordena los 20 primeros de la recuperación semántica según esa puntuación; cuando dos productos empatan, conservan el orden de la recuperación semántica, una regla fijada junto con la grabación. Ese reordenamiento es la tercera comparación planificada, con un valor p inferior a 0.01:
1"""Reads the pointwise LLM's answers for the test queries, one call per product, and reranks semantic retrieval's top 20 by2their scores. The prose's point rests on the distinct-scores line, which shows how coarse the scores are, and on the3planned comparison's p-value."""4from lib.metrics import evaluate5from lib.ranking import DEPTH, rerank, report_planned6from lib.recorded import llm_pointwise, manifest7from lib.semantic import SemanticSearch8from lib.store import load_queries, qrels910queries, judgments = load_queries("test"), qrels("test") # scored on the human judgments, not the LLM's11semantic = SemanticSearch().run(queries, k=100)12answers = llm_pointwise() # one call per product: a label and a score13print("llm:", manifest("llm-rerank")["model"])14print("licence in the manifest:", manifest("llm-rerank")["model_licence"])15print(f"calls per query: {len(answers) // answers['query_id'].nunique()}")16print(f"answers without a score: {answers['score'].isna().sum()}")17print(f"distinct scores per query, median: {answers.groupby('query_id')['score'].nunique().median():.0f}")18print(f"share of products scored 100: {(answers['score'] == 100).mean():.3f}")19# each answered product's human grade, or missing when nobody judged it20people = answers.apply(lambda row: judgments[row["query_id"]].get(row["product_id"]), axis=1)21# grades 2, 1 and 0 are exact, partial and irrelevant, the labels the LLM was asked for22for label, grade in [("exact", 2), ("partial", 1), ("irrelevant", 0)]:23 print(f"products the llm labels {label}: {(answers['label'] == label).sum()}")24 print(f"products people judged {label}: {(people == grade).sum()}")25print(f"products nobody judged: {people.isna().sum()}")2627score = dict(zip(zip(answers["query_id"], answers["product_id"]), answers["score"]))28reranked = rerank(semantic, score, DEPTH) # equal scores keep semantic retrieval's order29counts = answers.groupby("query_id")["score"].value_counts() # products per score, for each query30shared = {query_id: sum(counts[(query_id, score[(query_id, product_id)])] > 1 for product_id in reranked[query_id][:10])31 for query_id in queries.index} # top-10 products that share their score32# more than 5 of the top 10 share a score: most of the list is decided by the tie-break33print(f"queries where most of the reranked top 10 shares its score: {sum(n > 5 for n in shared.values())}")34before, after = evaluate(semantic, judgments), evaluate(reranked, judgments)35for name, frame in [("semantic", before), ("llm pointwise", after)]:36 print(f"{name}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")37 print(f"{name}, test judged@10: {frame['judged@10'].mean():.3f}")38 print(f"{name}, unjudged places in the test top 10s: {round((1 - frame['judged@10']).sum() * 10)}")39report_planned("llm pointwise", after["ndcg@10"], before["ndcg@10"])
python llm-pointwise-rerank.pyllm: gemma4:12b-it-q4_K_M
licence in the manifest: Apache-2.0
calls per query: 20
answers without a score: 0
distinct scores per query, median: 4
share of products scored 100: 0.390
products the llm labels exact: 251
products people judged exact: 310
products the llm labels partial: 345
products people judged partial: 265
products the llm labels irrelevant: 4
products people judged irrelevant: 7
products nobody judged: 18
queries where most of the reranked top 10 shares its score: 30
semantic, test ndcg@10: 0.830
semantic, test judged@10: 0.990
semantic, unjudged places in the test top 10s: 3
llm pointwise, test ndcg@10: 0.837
llm pointwise, test judged@10: 0.983
llm pointwise, unjudged places in the test top 10s: 5
llm pointwise, mean difference: 0.008
llm pointwise, wins, losses, ties: 11, 8, 11
llm pointwise, permutation p: 0.241
llm pointwise, established at 0.01: no
llm pointwise, t-test p: 0.244
llm pointwise, t-test agrees: yes
llm pointwise, 99% interval: -0.007 to 0.026
llm pointwise, interval agrees: yes
La grabación hizo 20 llamadas por consulta, y 0 respuestas llegaron sin puntuación. Las puntuaciones son gruesas. La consulta mediana obtiene 4 puntuaciones distintas para sus 20 productos, y una proporción de 0.390 de todos los productos recibe 100. En 30 consultas, la mayoría de los 10 primeros reordenados comparte puntuación con otro producto, así que el desempate, es decir, el orden de la recuperación semántica, decide buena parte de la lista.
Con esta indicación, sobre estas listas, el LLM califica como exactos menos productos que las personas:
| Etiqueta | LLM | Personas |
|---|---|---|
| exact | 251 | 310 |
| partial | 345 | 265 |
| irrelevant | 4 | 7 |
| nobody judged | – | 18 |
En estas listas eso se cumple, pero el capítulo 4 muestra que la dirección del desacuerdo de un LLM con las personas cambia según los pares juzgados y la indicación, así que no traslades esto a otros casos.
El reordenamiento puntual tampoco demuestra una mejora: obtiene 0.837 frente a 0.830, con un valor p de permutación de 0.241 (véase la tabla de decisiones).
El orden del LLM mete más productos sin juzgar en los 10 primeros: 5 posiciones en lugar de 3, y judged@10 baja de 0.990 a 0.983.
Regla práctica: si reordenas de forma puntual con un LLM, pide una etiqueta graduada o una puntuación, cuenta las puntuaciones distintas que da por consulta y decide el desempate de antemano: el orden de la recuperación es un valor por defecto seguro. Evalúa el resultado con juicios humanos, nunca con las mismas calificaciones del LLM.
Ordena los 20 productos con un prompt de LLM
La tercera vía, un prompt listwise, numera los candidatos y pide al LLM que devuelva los números en orden de relevancia. RankGPT lo introdujo como generación de permutaciones (Sun et al., 2023). Un prompt solo puede contener cierta cantidad de productos, así que una lista larga se reordena con una ventana deslizante: RankGPT reordena los 100 primeros de BM25 con "un tamaño de ventana de 20 y un tamaño de paso de 10", de abajo hacia arriba de la lista (secciones 3.2 y 6.1). La respuesta tiene que ser un orden válido, y eso puede fallar: con LLMs moderados de 2023, como Flan-UL2 de 20 000 millones de parámetros, los prompts listwise casi siempre fallan, por rankings incompletos, repetidos o rechazados (Qin et al., 2024).
El LLM de la tienda vio 20 productos por prompt, una ventana. El prompt muestra cada producto como una línea breve: nombre, clase, atributos y los primeros 160 caracteres de la descripción. Su última instrucción dice: "Order all 20 products from the best match for the query to the worst. Return the product numbers, each exactly once, in JSON." El esquema JSON exige exactamente 20 números, pero no 20 distintos, así que la grabación repara cualquier respuesta con un número repetido o faltante y la marca. Se reordenan los 20 primeros de recuperación semántica según la respuesta que dio el LLM cuando los vio en orden semántico. Ese reordenamiento es la cuarta comparación planificada, con un valor p inferior a 0.01:
1"""Reads the listwise LLM's answers for the test queries, in both orders, and reranks semantic retrieval's top 20 by the2answer given in semantic order. The prose's point rests on the planned comparison's p-value, and on the repair count,3which shows how many answers needed a fix."""4from lib.metrics import evaluate5from lib.ranking import DEPTH, report_planned6from lib.recorded import llm_listwise, manifest7from lib.semantic import SemanticSearch8from lib.store import load_queries, qrels910queries, judgments = load_queries("test"), qrels("test") # scored on the human judgments, not the LLM's11semantic = SemanticSearch().run(queries, k=100)12answers = llm_listwise() # one call per query and order shown13# the answers hold one row per product, so keep one row per call: one call per query and order14calls = answers.drop_duplicates(["query_id", "order"])15print(f"listwise calls, both orders: {len(calls)}")16# valid is false where the recording repaired a repeated or missing number17print(f"answers that needed repair: {(~calls['valid']).sum()}")18print(f"products per call: {answers.groupby(['query_id', 'order']).size().max()}")19print("prompt asks for:", manifest("llm-rerank")["prompts"]["listwise"].splitlines()[-1].replace("{n}", str(DEPTH)))2021shown_in_semantic_order = answers[answers["order"] == "semantic"].sort_values(["query_id", "position"])22order = shown_in_semantic_order.groupby("query_id")["product_id"].apply(list)23# the reranked top 20, then the rest of semantic retrieval's list in place: ranking[DEPTH:] starts at the 21st product24reranked = {query_id: order[query_id] + ranking[DEPTH:] for query_id, ranking in semantic.items()}25before, after = evaluate(semantic, judgments), evaluate(reranked, judgments)26for name, frame in [("semantic", before), ("llm listwise", after)]:27 print(f"{name}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")28 print(f"{name}, test judged@10: {frame['judged@10'].mean():.3f}")29 print(f"{name}, unjudged places in the test top 10s: {round((1 - frame['judged@10']).sum() * 10)}")30moved = sum(reranked[query_id][0] != semantic[query_id][0] for query_id in queries.index)31print(f"queries whose first product changes: {moved}")32report_planned("llm listwise", after["ndcg@10"], before["ndcg@10"])
python llm-listwise-rerank.pylistwise calls, both orders: 60
answers that needed repair: 0
products per call: 20
prompt asks for: Order all 20 products from the best match for the query to the worst. Return the product numbers, each exactly once, in JSON.
semantic, test ndcg@10: 0.830
semantic, test judged@10: 0.990
semantic, unjudged places in the test top 10s: 3
llm listwise, test ndcg@10: 0.819
llm listwise, test judged@10: 0.983
llm listwise, unjudged places in the test top 10s: 5
queries whose first product changes: 19
llm listwise, mean difference: -0.010
llm listwise, wins, losses, ties: 12, 12, 6
llm listwise, permutation p: 0.580
llm listwise, established at 0.01: no
llm listwise, t-test p: 0.498
llm listwise, t-test agrees: yes
llm listwise, 99% interval: -0.070 to 0.016
llm listwise, interval agrees: yes
La grabación hizo 60 llamadas listwise, dos por consulta de prueba, y 0 respuestas necesitaron reparación. El reordenamiento cambia el primer producto en 19 consultas.
La ganancia del reordenamiento listwise no está establecida: obtiene 0.819 frente a 0.830, con un valor p de permutación de 0.580 (las cinco comparaciones).
Judged@10 también baja aquí, de 0.990 a 0.983, con 5 posiciones no juzgadas, donde la recuperación semántica tiene 3.
Regla práctica: Revisa cada respuesta listwise antes de usarla: cuenta los números faltantes, repetidos y desconocidos, y registra cuántas respuestas necesitaron reparación. Limita la forma de la respuesta con un esquema cuando tu entorno de ejecución lo permita. Fija la ventana, el paso y el orden en que muestras los productos antes de medir, porque el orden cambia la respuesta, como muestra la siguiente comprobación.
Invierte la entrada para medir el sesgo posicional
Una respuesta listwise puede sufrir sesgo posicional: la tendencia de un LLM a dejar que el lugar de un producto en el prompt afecte su posición en el ranking, en lugar del sesgo de posición de los click de los compradores. "Los modelos de lenguaje grandes (LLM) presentan sesgo posicional en el uso que hacen del contexto, lo que complica especialmente el ranking listwise" (Tang et al., 2024). En TREC DL19, las consultas de 2019 de la pista Deep Learning de TREC, un benchmark de ranking de pasajes, gpt-3.5-turbo reordenó el top 100 de BM25 hasta un nDCG@10 de 65.80 cuando se le mostró el orden de BM25, de 32.77 cuando se le mostró invertido y de 25.17 cuando se le mostró un orden aleatorio (Sun et al., 2023, Tabla 5). La comprobación directa consiste en mostrar los mismos productos en dos órdenes y comparar las respuestas. La tau de Kendall mide cuánto se parecen dos ordenaciones, desde 1 para el mismo orden hasta −1 para el inverso, contando los pares que ponen en el mismo sentido (capítulo 4).
La grabación envió el prompt listwise de cada consulta de prueba al mismo LLM dos veces. El primer prompt mostró el top 20 de la recuperación semántica en orden semántico, como lo usó el reranking listwise; el segundo lo mostró invertido. De las 30 consultas de prueba, ¿con qué frecuencia pondrá el LLM el mismo producto primero en ambas ocasiones? Anota tu número.
1"""Shows the listwise LLM the same test products in two orders, and measures how far its answers agree and how far each2answer follows the order it was shown. The prose's point rests on the mean tau between the two answers, and on the two3taus between each answer and its own input order."""4import numpy as np5from scipy.stats import kendalltau67from lib.metrics import evaluate8from lib.ranking import DEPTH9from lib.recorded import llm_listwise10from lib.semantic import SemanticSearch11from lib.store import load_queries, qrels1213queries, judgments = load_queries("test"), qrels("test")14semantic = SemanticSearch().run(queries, k=DEPTH) # the order the first prompt showed15answers = llm_listwise().sort_values(["query_id", "order", "position"])16# the products in the order the LLM returned them, for each query and each order shown17answer = {key: list(group["product_id"]) for key, group in answers.groupby(["query_id", "order"])}1819def tau(first: list, second: list) -> float:20 """Kendall's tau between two orderings of the same products."""21 place = {product_id: rank for rank, product_id in enumerate(second)} # each product's place in the second ordering22 # the first ordering's positions, against where the second ordering puts each product23 return kendalltau(range(len(first)), [place[product_id] for product_id in first]).statistic2425between, shown_semantic, shown_reversed, overlap, same_first = [], [], [], [], 026for query_id, shown in semantic.items():27 forward, backward = answer[(query_id, "semantic")], answer[(query_id, "reversed")]28 between.append(tau(forward, backward))29 shown_semantic.append(tau(forward, shown))30 shown_reversed.append(tau(backward, shown[::-1])) # the reversed input, as the second prompt showed it31 overlap.append(len(set(forward[:10]) & set(backward[:10])))32 same_first += forward[0] == backward[0] # index 0 is the first place33print(f"test queries: {len(semantic)}")34print(f"tau between the two answers, mean: {np.mean(between):.3f}")35print(f"tau between the two answers, lowest: {min(between):.3f}\ntau between the two answers, highest: {max(between):.3f}")36print(f"top-10 products in common, mean: {np.mean(overlap):.3f}")37print(f"top-10 products in common, fewest: {min(overlap)}")38print(f"queries with the same first product: {same_first}")39print(f"share of queries with the same first product: {same_first / len(semantic):.3f}")40print(f"tau between the order shown and the answer, semantic order: {np.mean(shown_semantic):.3f}")41print(f"tau between the order shown and the answer, reversed order: {np.mean(shown_reversed):.3f}")42# an answer that ignored the order would repeat itself, so its tau with the reversed input is minus its tau with the semantic order43print(f"the same, if the order shown made no difference: {-np.mean(shown_semantic):.3f}")44reversed_run = {query_id: answer[(query_id, "reversed")] for query_id in semantic}45print(f"reversed answer, test ndcg@10, not a planned comparison: {evaluate(reversed_run, judgments)['ndcg@10'].mean():.3f}")
python listwise-position-bias.pytest queries: 30
tau between the two answers, mean: 0.311
tau between the two answers, lowest: -0.484
tau between the two answers, highest: 0.811
top-10 products in common, mean: 6.967
top-10 products in common, fewest: 3
queries with the same first product: 13
share of queries with the same first product: 0.433
tau between the order shown and the answer, semantic order: 0.414
tau between the order shown and the answer, reversed order: 0.045
the same, if the order shown made no difference: -0.414
reversed answer, test ndcg@10, not a planned comparison: 0.826
El mismo producto aparece primero en 13 de las 30 consultas, así que la expectativa de que un modelo capaz encuentre la misma mejor coincidencia sin importar cómo llegue la lista se cumple solo para una proporción de 0.433 de las consultas.
Las dos respuestas concuerdan con una tau media de 0.311, y por consulta la tau va de -0.484 a 0.811. Sus top 10 comparten 6.967 productos de media, hasta un mínimo de 3.
Las respuestas también se inclinan hacia el orden mostrado. La tau de cada respuesta frente a su propio orden de entrada es 0.414 para el orden semántico y 0.045 para el invertido. Un LLM que ignorara el orden daría la misma respuesta en ambas ocasiones, así que su respuesta invertida tendría una tau de -0.414 frente a la entrada invertida. La respuesta invertida está mucho más cerca de su propio orden de entrada que eso: sesgo posicional, para este modelo, este prompt y estas consultas. La respuesta invertida obtiene 0.826 de nDCG@10; no es una comparación planificada, así que el capítulo no la evalúa.
Existen tres remedios. El prompting de ranking por pares pregunta al LLM sobre cada par dos veces, una en cada orden, y cuenta un desacuerdo como empate (Qin et al., 2024). La autoconsistencia por permutaciones reordena varios órdenes barajados y agrega las respuestas, lo que elevó las puntuaciones hasta entre un 7 y un 18 % para GPT-3.5 y entre un 8 y un 16 % para LLaMA v2 (70B) (Tang et al., 2024). Y los rerankers ajustados finamente para el ranking listwise, como el abierto RankZephyr, se describen como "resistentes a las variaciones en el orden inicial de los documentos" (Pradeep et al., 2023); la tienda no registró ninguno.
Regla práctica: Antes de confiar en un reranker listwise basado en LLM, ejecuta cada consulta en al menos dos órdenes distintos e informa de cuánto coinciden las respuestas. Cuando la coincidencia sea baja, agrega varios órdenes o pregunta por cada par en ambos sentidos, y cuenta esas llamadas contra tu presupuesto. En producción, muestra los productos siempre en el orden de la recuperación, para que la misma lista al menos reciba la misma respuesta.
Establece la profundidad de reordenamiento a partir de un presupuesto
Una canalización de búsqueda se ejecuta en etapas, cada una más lenta y con menos candidatos que la anterior, y cada reordenador de este capítulo añade una. Los rankers de varias etapas ofrecen "la capacidad de equilibrar calidad y latencia controlando la admisión de candidatos en cada etapa de la canalización" (Nogueira et al., 2019). Por eso la profundidad de reordenamiento, es decir, cuántos productos lee el reordenador por consulta, es una decisión de presupuesto. Los tiempos varían según el hardware y las opciones de ejecución (Peng et al., 2025), así que esta sección cuenta lo que los determina: las llamadas al modelo y el texto que leen, por consulta, multiplicados por el tamaño del modelo. El cross-encoder de la tienda tiene 149M de parámetros (model card), y su LLM unos 12 000 millones (model card), unas 80 veces más.
A profundidad 20, cuenta las llamadas al modelo y los caracteres que lee cada reordenador por consulta de prueba, a partir del texto de los productos y de los prompts registrados, más las llamadas que necesitarían dos diseños que la tienda no registró:
1"""Counts the characters each reranker reads per test query at depth 20, from the products' text and the recorded prompts,2and the model calls each design makes. The prose's point rests on the characters and calls lines, and on the two designs3the store didn't record."""4import numpy as np56from lib.agreement import as_the_llm_saw7from lib.ranking import DEPTH, listwise_line8from lib.recorded import manifest9from lib.semantic import SemanticSearch10from lib.store import load_products, load_queries, product_text1112products, queries = load_products(), load_queries("test")13semantic = SemanticSearch().run(queries, k=DEPTH) # the 20 products each reranker reads14prompts, text = manifest("llm-rerank")["prompts"], product_text(products)1516cross_encoder, pointwise, listwise = [], [], [] # characters read per query17for query_id, query in queries["query"].items():18 shown = products.loc[semantic[query_id]]19 # one call per product, each reading the query and that product's text together20 cross_encoder.append(sum(len(query) + len(text[product_id]) for product_id in semantic[query_id]))21 # the pointwise prompt, filled in with the query and the product as the LLM saw it22 pointwise.append(sum(len(prompts["pointwise"].format(query=query, product=as_the_llm_saw(product)))23 for _, product in shown.iterrows()))24 # products numbered from 1, as the listwise prompt shows them25 lines = "\n".join(f"[{number}] {listwise_line(product)}" for number, (_, product) in enumerate(shown.iterrows(), 1))26 listwise.append(len(prompts["listwise"].format(query=query, products=lines, n=DEPTH)))2728# the cross-encoder and the pointwise LLM make one call per product; the listwise LLM makes one call per query29for name, calls, characters in [("cross-encoder", DEPTH, cross_encoder), ("llm pointwise", DEPTH, pointwise),30 ("llm listwise", 1, listwise)]:31 print(f"{name}, model calls per query: {calls}")32 print(f"{name}, characters read per query, mean: {np.mean(characters):,.0f}")33print(f"llm pairwise, every pair in both orders, calls per query: {DEPTH * (DEPTH - 1)}")34# a sliding window of 20 products, moved 10 at a time: its starts are list positions 0, 10, ..., 8035window, step, depth = 20, 10, 100 # a sliding window over a deeper list36print(f"llm listwise over the top {depth}, window {window}, step {step}, calls per query: {(depth - window) // step + 1}")
python reranker-prompt-sizes.pycross-encoder, model calls per query: 20
cross-encoder, characters read per query, mean: 9,911
llm pointwise, model calls per query: 20
llm pointwise, characters read per query, mean: 17,864
llm listwise, model calls per query: 1
llm listwise, characters read per query, mean: 5,973
llm pairwise, every pair in both orders, calls per query: 380
llm listwise over the top 100, window 20, step 10, calls per query: 9
| Reordenador, top 20 | Llamadas al modelo por consulta | Caracteres leídos por consulta |
|---|---|---|
| Cross-encoder | 20 | 9,911 |
| LLM, puntual | 20 | 17,864 |
| LLM, por lista | 1 | 5,973 |
El método puntual repite las instrucciones y muestra cada producto completo, así que lee la mayor cantidad de texto, en llamadas independientes. El método por lista lee la menor cantidad, en una sola llamada, pero debe escribir 20 números en orden. La comparación por pares sobre todos los pares en ambos órdenes requeriría 380 llamadas por consulta, y la ventana deslizante de RankGPT sobre un top 100 requeriría 9. En una medición publicada sobre TREC DL19, al reordenar el top 100 de BM25 con Flan-T5-XL en una sola GPU RTX A6000, el método puntual con indicaciones de sí o no obtuvo 0.650 de nDCG@10 con 1.5 segundos por consulta, y la comparación por pares sobre todos los pares obtuvo 0.713 con 254.9 segundos, con 9,900 llamadas al LLM (Zhuang et al., 2024b). LambdaMART con el cross-encoder como característica necesita una puntuación del cross-encoder para cada candidato, una mediana de 131 pares por consulta.
Para el cross-encoder, el coste crece a la par de la profundidad, así que la pregunta es dónde deja de crecer la calidad. Recorre la profundidad sobre las consultas de entrenamiento:
1"""Reranks semantic retrieval's top 5 to 75 with the recorded cross-encoder scores, on the train queries, and prints nDCG@102at each depth. The prose's point rests on the change from the depth before, which shows where the gain flattens and then3falls."""4from lib.metrics import evaluate5from lib.ranking import rerank6from lib.recorded import cross_encoder_scores7from lib.semantic import SemanticSearch8from lib.store import load_queries, qrels910queries, judgments = load_queries("train"), qrels("train") # choosing a depth is tuning: train queries11semantic = SemanticSearch().run(queries, k=100)12recorded = cross_encoder_scores()13# the recorded cross-encoder score of each (query, product) pair14score = dict(zip(zip(recorded["query_id"], recorded["product_id"]), recorded["score"]))15train_pairs = recorded[recorded["query_id"].isin(queries.index)]1617print(f"depth 0 (semantic alone), train ndcg@10: {evaluate(semantic, judgments)['ndcg@10'].mean():.3f}")18previous = round(evaluate(semantic, judgments)["ndcg@10"].mean(), 3) # changes between the printed values19for depth in [5, 10, 20, 30, 50, 75]:20 mean = round(evaluate(rerank(semantic, score, depth), judgments)["ndcg@10"].mean(), 3)21 print(f"depth {depth}, train ndcg@10: {mean:.3f}")22 print(f"depth {depth}, change from the depth before: {mean - previous:+.3f}")23 previous = mean24# every candidate needs its own cross-encoder score, so this counts the recorded pairs per query25print(f"pairs per query to score every candidate, median: {train_pairs.groupby('query_id').size().median():.0f}")
python rerank-depth-on-train.pydepth 0 (semantic alone), train ndcg@10: 0.772
depth 5, train ndcg@10: 0.782
depth 5, change from the depth before: +0.010
depth 10, train ndcg@10: 0.784
depth 10, change from the depth before: +0.002
depth 20, train ndcg@10: 0.802
depth 20, change from the depth before: +0.018
depth 30, train ndcg@10: 0.804
depth 30, change from the depth before: +0.002
depth 50, train ndcg@10: 0.793
depth 50, change from the depth before: -0.011
depth 75, train ndcg@10: 0.788
depth 75, change from the depth before: -0.005
pairs per query to score every candidate, median: 131
La ganancia del cross-encoder se aplana entre 20 y 30, cerca de la profundidad fijada para igualar la grabación del LLM. Desde el 0.772 de la recuperación semántica, reordenar el top 5 da 0.782 y el top 20 0.802. El top 30 añade +0.002 por otro 50 % más de pares. Más allá, baja: 0.793 a 50 y 0.788 a 75.
En prueba, el reordenamiento de profundidad 20 no demostró una ganancia, así que para la tienda el reordenador más barato, ninguno, es también el que conviene mantener.
Regla práctica: Para cada reordenador que consideres, cuenta llamadas y caracteres por consulta a cada profundidad, y fija la profundidad con las consultas de entrenamiento. Una regla orientativa, no una medición: reordena solo hasta la profundidad en la que el nDCG@10 de entrenamiento deja de mejorar, porque cada producto más allá cuesta lo mismo y no aporta nada. Luego mide esa configuración en tu propio hardware y tráfico, y conserva la etapa solo si cabe en el presupuesto de latencia.
Destila el cross-encoder en un ranker pequeño
Un reranker demasiado lento para el presupuesto puede enseñar a uno rápido. La destilación entrena un modelo pequeño, el estudiante, para imitar a un modelo grande, el profesor. Hinton et al. la describen como la destilación del conocimiento de un conjunto de modelos en un único modelo (Hinton et al., 2015). En ranking, las puntuaciones del profesor se convierten en las etiquetas del estudiante. Cuando las puntuaciones de los dos modelos difieren en escala, como suele ocurrir con las puntuaciones de arquitecturas distintas, el estudiante puede aprender el margen entre las puntuaciones de dos productos, con una pérdida llamada Margin-MSE (Hofstätter et al., 2020). La destilación también va de los LLM hacia abajo. RankGPT informa de que un modelo destilado de 440M supera a un modelo supervisado de 3B en el benchmark BEIR (Sun et al., 2023; BEIR). En un estudio de búsqueda de productos con consultas de superlativos, modelos ligeros asumieron las interpretaciones de un LLM, donde reordenar directamente con el LLM tiene una latencia prohibitiva (Zhu et al., 2025). El profesor no necesita etiquetas humanas y etiqueta cada candidato.
El profesor es el cross-encoder. El estudiante es una regresión LightGBM sobre las 7 características que no necesitan ninguna llamada a un modelo más allá de la que ya hace la recuperación: todo menos cross_encoder. Su etiqueta es la puntuación bruta del profesor, que una regresión de árboles puede igualar en la escala propia del profesor. Ordena los mismos candidatos, en orden de product_id, con árboles del tamaño elegido para LambdaMART. Primero, compara el estudiante con un modelo LambdaMART entrenado con calificaciones humanas y las mismas características, mediante validación cruzada sobre las consultas de entrenamiento:
1"""Trains a student LightGBM regression on the cross-encoder's scores, and a LambdaMART model on human grades with the same2features, both by cross-validation on the train queries. The prose's point rests on the student's score, and on its3difference from the human-graded ranker."""4from lightgbm import LGBMRanker, LGBMRegressor56from lib.metrics import evaluate7from lib.ranking import CHEAP_FEATURES, DETERMINISTIC, LAMBDARANK, TREES, cross_validate, feature_table, ranked8from lib.semantic import SemanticSearch9from lib.significance import compare10from lib.store import load_products, load_queries, qrels1112queries, judgments = load_queries("train"), qrels("train") # design work: train queries only13candidates = feature_table(load_products(), queries)14# unjudged candidates count as grade 0, as in the metric15candidates["grade or 0"] = candidates["grade"].fillna(0).astype(int)1617student = cross_validate(lambda: LGBMRegressor(**TREES, **DETERMINISTIC), candidates, candidates,18 "cross_encoder", CHEAP_FEATURES, judgments) # labels from the teacher19human = cross_validate(lambda: LGBMRanker(**LAMBDARANK, **TREES, **DETERMINISTIC), candidates, candidates,20 "grade or 0", CHEAP_FEATURES, judgments) # labels from people21# the teacher's own order of the candidates, ties broken by product_id22teacher = evaluate(ranked(candidates, candidates["cross_encoder"]), judgments)["ndcg@10"]23semantic = evaluate(SemanticSearch().run(queries, k=100), judgments)["ndcg@10"]24for name, scores in [("semantic", semantic), ("teacher", teacher), ("student, teacher's labels", student),25 ("lambdarank, human grades, same features", human)]:26 print(f"{name}, train ndcg@10: {scores.mean():.3f}")27# the student's score minus the human-graded ranker's, per query, tested by permutation28result = compare(student, human)29print(f"student minus the human-graded ranker: {result['mean difference']:.3f}")30print(f"student minus the human-graded ranker, permutation p: {result['permutation p']:.3f}")
python distillation-on-train.pysemantic, train ndcg@10: 0.772
teacher, train ndcg@10: 0.785
student, teacher's labels, train ndcg@10: 0.791
lambdarank, human grades, same features, train ndcg@10: 0.747
student minus the human-graded ranker: 0.044
student minus the human-graded ranker, permutation p: 0.002
En estas consultas de entrenamiento, con estas características, las etiquetas del profesor sobre cada candidato entrenaron un mejor ranker que las calificaciones de las personas, contando los candidatos no juzgados como 0. El estudiante obtiene 0.791, y el propio orden de los candidatos por parte del profesor 0.785.
El modelo entrenado con calificaciones humanas obtiene 0.747, por debajo de los 0.772 de la recuperación semántica, y la diferencia del estudiante respecto a él es 0.044, con un valor p de permutación de 0.002. Es una comprobación de ajuste sobre consultas de entrenamiento, no una evidencia.
Después, ajusta el estudiante sobre las consultas de entrenamiento, con parada temprana sobre las mismas consultas de entrenamiento reservadas que LambdaMART, y realiza la última comparación planificada, con el mismo umbral de 0.01:
1"""Fits a student LightGBM regression on the teacher's scores for the train queries, then reports its gain shares, how2closely its order follows similarity and the teacher, and its planned comparison on the test queries. The prose's point3rests on that comparison and on the taus printed for each ranking."""4import numpy as np5from lightgbm import LGBMRegressor6from scipy.stats import kendalltau78from lib.metrics import evaluate9from lib.ranking import CHEAP_FEATURES, DETERMINISTIC, TREES, feature_table, fit, ranked, report_planned, stopping_split10from lib.semantic import SemanticSearch11from lib.store import load_products, load_queries, qrels1213products, train, test = load_products(), load_queries("train"), load_queries("test")14table = feature_table(products, train) # the teacher's score is the label: no human grades15print(f"train candidates the teacher labels: {len(table)}")16print(f"of them, judged by nobody: {table['grade'].isna().sum()}")17print(f"student features: {len(CHEAP_FEATURES)}")18# early stopping on the same 10 held-out train queries that LambdaMART stops on19student = fit(LGBMRegressor(**TREES, **DETERMINISTIC), table, "cross_encoder", CHEAP_FEATURES, *stopping_split(train.index))20print(f"trees kept by early stopping: {student.best_iteration_}")2122candidates, judgments = feature_table(products, test), qrels("test") # test queries: read once, to report23predicted = student.predict(candidates[CHEAP_FEATURES])24gain = student.booster_.feature_importance(importance_type="gain")25# the three features with the most gain26for name, share in sorted(zip(CHEAP_FEATURES, gain / gain.sum()), key=lambda pair: -pair[1])[:3]:27 print(f"student's share of gain, {name}: {share:.3f}")28for name in ["cross_encoder", "similarity"]: # whose order does the student follow?29 # candidates has a default index, so group.index picks this query's rows out of predicted30 tau = [kendalltau(group[name], predicted[group.index]).statistic for _, group in candidates.groupby("query_id")]31 print(f"tau between student and {name}, mean over test queries: {np.mean(tau):.3f}")32teacher = evaluate(ranked(candidates, candidates["cross_encoder"]), judgments)33print(f"teacher's own order of the candidates, test ndcg@10, not a planned comparison: {teacher['ndcg@10'].mean():.3f}")34after = evaluate(ranked(candidates, predicted), judgments)35before = evaluate(SemanticSearch().run(test, k=100), judgments)36for name, frame in [("semantic", before), ("distilled", after)]:37 print(f"{name}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")38 print(f"{name}, test judged@10: {frame['judged@10'].mean():.3f}")39 # each query's top 10 is 10 places, so (1 - judged@10) times 10 counts its unjudged places40 print(f"{name}, unjudged places in the test top 10s: {round((1 - frame['judged@10']).sum() * 10)}")41report_planned("distilled", after["ndcg@10"], before["ndcg@10"])
python distilled-ranker-on-test.pytrain candidates the teacher labels: 6896
of them, judged by nobody: 1975
student features: 7
trees kept by early stopping: 202
student's share of gain, similarity: 0.812
student's share of gain, name_match: 0.126
student's share of gain, bm25: 0.055
tau between student and cross_encoder, mean over test queries: 0.466
tau between student and similarity, mean over test queries: 0.753
teacher's own order of the candidates, test ndcg@10, not a planned comparison: 0.782
semantic, test ndcg@10: 0.830
semantic, test judged@10: 0.990
semantic, unjudged places in the test top 10s: 3
distilled, test ndcg@10: 0.826
distilled, test judged@10: 0.987
distilled, unjudged places in the test top 10s: 4
distilled, mean difference: -0.004
distilled, wins, losses, ties: 10, 13, 7
distilled, permutation p: 0.720
distilled, established at 0.01: no
distilled, t-test p: 0.694
distilled, t-test agrees: yes
distilled, 99% interval: -0.034 to 0.017
distilled, interval agrees: yes
El profesor etiqueta los 6896 candidatos de entrenamiento, de los cuales 1975 no los juzga nadie, y la parada temprana conserva 202 árboles.
El estudiante depende de similarity, que aporta una proporción de 0.812 de la ganancia, por delante de name_match con 0.126 y de bm25 con 0.055. En los candidatos de prueba, sus puntuaciones coinciden con la similitud semántica con una tau media de 0.753 por consulta, y con las del profesor con 0.466. Así que el estudiante aprendió sobre todo el orden de la recuperación semántica, desplazado hacia el del profesor por las coincidencias de nombre y de BM25.
El estudiante no establece una mejora: el ranker destilado obtiene 0.826 de nDCG@10 frente a los 0.830 de la recuperación semántica, con un valor p de permutación de 0.720 (véase la tabla de decisiones). El propio orden de los candidatos de prueba por parte del profesor, que el capítulo no planeó evaluar, obtiene 0.782.
Judged@10 es 0.987 para el estudiante frente a 0.990 para la recuperación semántica, y los primeros 10 del estudiante contienen 4 posiciones no juzgadas, mientras que la recuperación semántica tiene 3.
Regla práctica: Destila cuando un reranker obtiene una mejora establecida pero cuesta demasiado por consulta: etiqueta cada candidato de tus consultas de entrenamiento con el profesor, entrena el estudiante con características que puedas calcular sin el profesor, y prueba el estudiante frente a tu recuperación en consultas reservadas. Lee la importancia de ganancia del estudiante: cuando la propia puntuación de la recuperación la domina, el estudiante es sobre todo tu recuperación. Usa márgenes entre pares cuando el estudiante no pueda igualar la escala del profesor. La tienda todavía no tiene un profesor que supere a la recuperación semántica, así que conserva el código y no publica el estudiante.
Qué sale mal en producción
Un ranker en vivo calcula características y llama a modelos mientras el comprador espera, con versiones de código y de modelos que pueden desviarse de las que se usaron para entrenar y probar.
Las características se desvían entre el entrenamiento y el servicio. Si el sistema en vivo tokeniza de otra manera, reescala BM25 o actualiza el modelo de embeddings, los pesos aprendidos se encuentran con números distintos, y nada lanza un error. Calcula las características con una única ruta de código compartida, y regístralas con cada ranking servido.
El orden de las filas se filtra al entrenamiento. El lambdarank de LightGBM parte del orden de sus filas de entrada, y un ranking rompe los empates de algún modo. Un archivo ordenado por la puntuación de un reranker entrega al modelo el ranking de ese reranker. Ordena los candidatos por un ID, o mézclalos con una semilla fija, antes de cada ajuste y de cada puntuación.
Los juicios provienen de un conjunto. WANDS juzgó solo los productos que sus propios sistemas propusieron (capítulo 2). Contar los candidatos sin juzgar como irrelevantes enseña a un modelo a relegar lo que esos sistemas no encontraron. Revisa judged@10 para cada ranker que añadas, y haz que se juzguen los productos sin juicio antes de confiar en una ganancia.
Los jueces LLM favorecen a los rerankers LLM. En un estudio, los rankings construidos con evaluadores LLM sitúan a los rerankers basados en LLM entre 9 y 17 posiciones más arriba de lo debido en promedio (Fröbe et al., 2025), y usar LLM tanto para ordenar como para juzgar es circular, "ilustrando cómo depender de evaluaciones basadas en LLM puede distorsionar los rankings de los sistemas" (Clarke y Dietz, 2024). Evalúa los rerankers LLM con juicios humanos, como hace este capítulo.
Un reranker LLM pertenece a una versión de modelo y a un prompt. Un digest distinto (el hash que identifica los pesos exactos), una cuantización distinta (la precisión con la que se almacenan los pesos) o una redacción de prompt distinta pueden cambiar cada respuesta, y con el sesgo posicional también puede hacerlo un cambio en el orden que devuelve la recuperación. El manifiesto de la grabación del LLM registra el digest y ambos prompts textualmente; vuelve a medir cada vez que cambie cualquiera de los dos.
Las consultas poco familiares pueden salir peor. Una comparación de 22 métodos de reranking encontró que los rerankers LLM funcionan mejor en consultas familiares, mientras que "su capacidad de generalización a consultas nuevas varía" (Abdallah et al., 2025). Vigila las consultas sobre productos y estilos más recientes que los datos de entrenamiento del modelo.
Cada reranker añade una llamada en el camino del comprador. Cuenta las llamadas y el texto por consulta, como en el presupuesto, fija un tiempo límite y recurre al orden de la recuperación cuando el reranker no responde a tiempo.
Regla práctica: Registra las características y las versiones de los modelos con cada ranking, ordena los candidatos de forma que no lleven información, puntúa con juicios humanos, revisa judged@10, y da a cada etapa de reranking un tiempo límite y una alternativa.
Decisiones que tomó este capítulo
El capítulo tomó cada decisión de la lista siguiente con las consultas de entrenamiento, y solo una comparación planificada establecida sobre las consultas de prueba podía cambiar la búsqueda de la tienda.
Las 5 comparaciones planificadas, cada una sobre nDCG@10 frente a los 0.830 de la recuperación semántica, establecidas por debajo de 0.01:
| Medida | LambdaMART | Cross-encoder | LLM pointwise | LLM listwise | Destilado |
|---|---|---|---|---|---|
| nDCG@10 | 0.817 | 0.813 | 0.837 | 0.819 | 0.826 |
| Diferencia media | -0.012 | -0.016 | 0.008 | -0.010 | -0.004 |
| Victorias / derrotas / empates | 14, 12, 4 | 11, 12, 7 | 11, 8, 11 | 12, 12, 6 | 10, 13, 7 |
| Permutación p | 0.260 | 0.178 | 0.241 | 0.580 | 0.720 |
| Establecida | no | no | no | no | no |
| p de la prueba t | 0.278 | 0.171 | 0.244 | 0.498 | 0.694 |
| Intervalo del 99 % | -0.044 to 0.011 | -0.058 to 0.006 | -0.007 to 0.026 | -0.070 to 0.016 | -0.034 to 0.017 |
| La prueba t coincide | yes | yes | yes | yes | yes |
| El intervalo coincide | yes | yes | yes | yes | yes |
- 5 comparaciones planificadas frente a la recuperación semántica, con juicios humanos, establecidas por debajo de 0.01.
- Candidatos: la unión de los 100 primeros de BM25 y de la recuperación semántica, en orden de
product_id, con los empates de puntuación resueltos porproduct_id. - LambdaMART:
label_gain=[0, 1, 2], los candidatos sin juzgar como grado 0, 3 hojas con una tasa de aprendizaje de 0.1, elegido por validación cruzada en el entrenamiento, con parada temprana en las consultas de entrenamiento reservadas a través deeval_Xyeval_y. Su ganancia no está establecida en la prueba, así que no se usa. - Profundidad de reordenación: los 20 primeros de la recuperación semántica, fijada para coincidir con el registro de los LLM; en el entrenamiento, la curva del cross-encoder se aplana entre 20 y 30. Ninguna ganancia de reordenador está establecida en la prueba, así que no se usa ninguna.
- Los reordenadores basados en LLM se puntúan solo con juicios humanos, y el listwise se verifica en dos órdenes de entrada. Su respuesta depende del orden mostrado.
- Los costes se cuentan, no se miden en tiempo: llamadas y caracteres por consulta.
- Destilación: un alumno LightGBM sobre las puntuaciones del cross-encoder, sin más llamadas al modelo que las de la recuperación. Aprende sobre todo el orden de la recuperación semántica, no muestra ganancia establecida y no se usa.
- El ranker que hay que superar sigue siendo la recuperación semántica sola, con BM25, sin stemming, como línea base.
- Lo que mostró el capítulo: ninguna segunda etapa se ganó su lugar; ninguna muestra una ganancia establecida.
Este capítulo, en esta edición
Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 14 de 14 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.10.