O que relevância significa
Cerca de 39 minutos min de leitura, com 10 exemplos em 11 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.10. Leia o original
Nesta página
- Julgue a relevância pela necessidade do comprador
- Espere que os avaliadores discordem em alguns pares
- Ler a intenção como um produto e seus modificadores
- Relevância em graus em vez de sim ou não
- Escolha os ganhos com intenção
- Leia a composição de rótulos de cada consulta
- Trate os clicks como evidência enviesada
- Saiba de onde vieram os julgamentos
- Conte os produtos sem julgamento antes de comparar as pontuações
- O que dá errado em produção
- Decisões tomadas neste capítulo
Ao final deste capítulo, você será capaz de ler um conjunto de julgamentos de relevância de forma crítica: dizer o que cada nota afirma sobre um produto, descobrir de onde vieram os julgamentos e onde eles têm lacunas, e decidir o quanto confiar em uma pontuação calculada a partir deles.
Todas as pontuações até agora trataram os julgamentos da loja como fato. O Capítulo 1 avaliou dois rankers com 13,077 julgamentos, as notas que pessoas deram a pares formados por uma consulta digitada na loja e um produto que ela vende. Nas consultas de teste, o BM25 obtém um nDCG@10 médio de 0.725. A recuperação semântica obtém 0.830. Cada um desses números repousa sobre escolhas que os julgamentos fazem silenciosamente: de quem é a ideia de relevância que eles registram, quanto vale um quase acerto e o que acontece com os produtos que ninguém julgou.
Este capítulo lê com atenção os julgamentos da loja. Ele não altera nenhum ranker, por isso lê as consultas de treino e de teste da mesma forma: ler julgamentos não é ajuste, e toda correção deste livro continua sendo escolhida apenas com consultas de treino. Os poucos testes que ele executa nas consultas de teste são exploratórios, ou seja, descrevem os julgamentos e não estabelecem nenhuma diferença (a regra do livro). O Capítulo 3 testa a diferença entre o BM25 e a recuperação semântica como uma comparação planejada.
Julgue a relevância pela necessidade do comprador
Um sistema de busca devolve produtos que correspondem a uma consulta do jeito que o próprio sistema define uma correspondência: palavras em comum na recuperação lexical, vetores próximos na recuperação semântica. A ciência da informação chama isso de relevância de sistema. Ela a separa da relevância temática, que indica se um produto trata do assunto da consulta, e da relevância situacional, que indica se ele ajuda na tarefa em mãos (Saracevic, 2007). Alguns argumentam que a relevância de sistema é sempre perfeita, porque o sistema recuperou o que a consulta pedia. A resposta de Saracevic é "Não é bem assim."
Um julgamento é um veredito, e este capítulo pergunta o que cada grau afirma. Os julgamentos da loja vêm do WANDS, um conjunto público de dados de busca de produtos, por meio de uma amostra de suas consultas e produtos (Carregue os dados da loja). Os juízes do WANDS rotulam cada par como exato, parcial ou irrelevante, que o livro registra como 2, 1 e 0. Exato significa que o produto é do tipo pedido pela consulta e tem todos os atributos que a consulta nomeia. Parcial significa que ele é do tipo certo, mas deixa de lado um atributo. Irrelevante significa que ele não é do tipo pedido (Leia a intenção como um produto e seus modificadores). O juiz avalia o produto contra a necessidade de informação por trás das palavras da consulta, isto é, aquilo que o comprador queria, e não contra as palavras. Manning et al. definem um documento como relevante quando ele atende à necessidade de informação declarada, e não apenas porque contém as palavras da consulta (Manning et al., 2008, capítulo 8). A avaliação, então, faz um acordo. Ela fixa um conjunto de documentos, um conjunto de declarações de necessidade e seus julgamentos, e abstrai os usuários reais (Voorhees, 2007). Aqui, os julgamentos ocupam o lugar dos compradores, e cada pontuação deste livro herda esse acordo.
Se coincidência de palavras fosse o mesmo que relevância, um produto cujo texto contivesse todas as palavras da consulta seria exato. Você pode testar isso em cada par julgado da loja: para cada par, pergunte se o nome, a classe, a categoria e a descrição do produto contêm todas as palavras da consulta, com as descrições da amostra cortadas em cerca de 400 caracteres.
Dos pares julgados cujo texto contém todas as palavras da consulta, qual fração os juízes classificaram como exatos? Guarde um número em mente.
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
Uma coincidência completa de palavras é um sinal forte, mas não resolve a questão. Dos 1,177 pares julgados cujo texto contém todas as palavras da consulta, 0.777 são exatos, 0.211 parciais e 0.012 irrelevantes, contra uma fração exata de 0.249 sobre todos os pares julgados. As palavras podem estar presentes sem que o produto seja o que o comprador queria, e por isso quem decide são os juízes, e não as palavras. Uma fração próxima de 1 significaria que a coincidência de palavras é relevância, e os juízes dizem que não é.
A outra direção é mais impressionante. A maioria dos pares exatos, 2,337 dos 3,252, tem um texto de produto que deixa de fora ao menos uma palavra da consulta. Mesmo acrescentando os atributos, 2,251 deles ainda continuam sem uma palavra, de modo que os atributos explicam poucas falhas no geral.
Algumas falhas são formas de palavras e grafia, como chairs em vez de chair (capítulo 1) ou a consulta ligth bulb. O capítulo 5 e o capítulo 8 tratam disso. Outras são atributos que o texto não declara. O WANDS registra atributos como cor, material e tamanho separadamente do texto (Chen et al., 2022, Tabela 1), e a loja mantém alguns deles em uma coluna attributes, por exemplo color: clear; material: vinyl (ficha de dados). O texto que a busca da loja lê, lib.store.product_text, deixa essa coluna de fora.
Para algumas consultas, porém, os atributos guardam a resposta. Para clear shower curtain, 8 dos 12 produtos exatos nunca dizem clear no texto, e 4 deles trazem clear nos atributos, onde a busca de texto da loja nunca procura. O Capítulo 5 testa acrescentar atributos à busca lexical. As demais cortinas desse grupo não dizem clear em lugar nenhum, nem no texto nem nos atributos.
Os juízes tinham mais em que se basear. As diretrizes de anotação do WANDS mostram a eles o nome, a imagem e a página web de cada produto (diretrizes). A foto ou a página podem ter sido o que os orientou, mas isso é um palpite nosso, porque os dados não registram qual evidência cada juiz usou.
Regra prática: Trate um julgamento como o veredito de uma pessoa sobre uma necessidade, e não como uma propriedade do produto. Antes de culpar um ranqueador por deixar de fora um produto exato, verifique se algum campo que ele lê diz o que os juízes viram, e observe os campos que ele não lê, como os atributos. Quando seus juízes veem mais do que seu ranqueador, dê ao ranqueador a mesma evidência onde for possível, ou aceite que alguns produtos exatos ficarão mal posicionados por motivos que nenhuma mudança no ranqueamento consegue corrigir.
Espere que os avaliadores discordem em alguns pares
Duas pessoas podem chegar a vereditos diferentes. Cada rótulo do WANDS já é o voto da maioria de até três anotadores (Chen et al., 2022, seção 5), e os anotadores, que começaram em concordância moderada, convergiram com o treinamento. O kappa de Cohen, que desconta a concordância por acaso, subiu de 0.467 nos dois primeiros meses para 0.664 no terceiro e 0.826 no quarto (Tabela 2). O Capítulo 4 calcula o kappa.
O arquivo do WANDS lista alguns pares da loja mais de uma vez, cada linha um voto da maioria, e, em alguns casos, os votos diferem. A amostra da loja mantém uma linha por par, com graus 2 para exato, 1 para parcial e 0 para irrelevante, e, quando as linhas diferem, mantém o grau mais baixo (Carregue os dados da loja). A seguir, os pares cujas linhas diferem, com o grau mantido pela amostra:
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
Dos pares avaliados, 7 apresentam conflito: 5 são exato contra parcial e 2 parcial contra irrelevante. Todo conflito fica entre graus vizinhos, 7 of 7, de modo que o ponto frágil é a linha entre dois graus, não a distância entre exato e irrelevante. A linha breakfast bar table é um desses casos: saber se uma mesa de jantar com altura de balcão corresponde plenamente àquela consulta é uma questão legítima sobre um modificador, e não um sinal de que um voto interpretou mal a tarefa.
Regra prática: Mantenha um grau por par e registre a regra que o escolheu. Recomendamos o grau mais baixo, como faz a amostra: ele erra contra o ranqueador que ranqueia o produto, e não a favor dele. Quando os avaliadores discordam entre dois graus, exato contra irrelevante, releia as diretrizes com eles, pois não compartilham uma mesma definição.
Ler a intenção como um produto e seus modificadores
Todo julgamento começa por uma leitura do que a consulta pede. A intenção do comprador é o que ele quer fazer. Uma taxonomia amplamente citada da busca na web classifica a intenção em navegacional (chegar a um site específico), informacional (encontrar informação) e transacional (realizar algo na web), e seu autor não supõe que a intenção possa ser inferida da consulta com qualquer certeza (Broder, 2002). A busca de produtos remodela essas categorias. Tsagkias et al. descrevem as consultas navegacionais de produtos como aquelas que citam um número de série ou um produto, e as informacionais como geralmente correspondendo a uma folha da taxonomia de inventário ou perguntando sobre atributos específicos. Eles acrescentam que "não existe uma taxonomia única para a intenção do cliente em comércio eletrônico", pois ela depende do negócio e do inventário da loja (Tsagkias et al., 2020, seção 2).
WANDS registra a intenção em seus rótulos. Uma consulta nomeia uma entidade-alvo, o tipo de produto, e os modificadores da consulta são os atributos que o comprador pediu. Um resultado exato satisfaz ambos. Um resultado parcial corresponde apenas à entidade-alvo e falha nos modificadores (Chen et al., 2022, seção 3.2). O exemplo trabalhado das diretrizes é uma consulta por uma cadeira infantil: um produto que é uma cadeira, mas não para crianças, é parcial (diretrizes). Mesmo com essa regra, uma consulta ampla pode ser difícil de avaliar. O exemplo dos próprios autores é um comprador que quer um cooktop de indução e digita cooktop (seção 1).
As consultas da loja cobrem toda essa faixa. ines shag rug w003096809 e kohler whitehaven farmhouse kitchen sink nomeiam uma linha de produtos ou um modelo, o que as torna navegacionais. outdoor light fixtures nomeia uma categoria. clear shower curtain e 48 inch kitchen hood acrescentam um modificador a uma entidade. As consultas da loja também trazem query_class, a classe prevista pelo WANDS para cada consulta (Tabela 1). Trata-se de um palpite sobre a entidade, que nada diz sobre os modificadores e não é um julgamento. Verifique com que frequência ela concorda com os produtos que os avaliadores consideraram exatos:
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
A classe prevista geralmente concorda com os produtos exatos. Para 63 das 80 consultas, a maioria dos produtos exatos possui a classe; para 6 consultas, nenhum possui; e 1 consulta não tem classe alguma. Leia cada linha que o exemplo imprime antes de contá-la como erro. foutains with brick look está classificada como Wallpaper, mas seus produtos exatos são chafarizes, então o classificador errou. 7qt slow cooker é, em vez disso, uma divergência de nomenclatura: as classes da consulta e as classes dos produtos usam nomes diferentes para a mesma coisa.
Regra prática: Leia cada consulta como uma entidade mais modificadores, e verifique se o seu ranqueador acerta a entidade antes de ajustá-lo para os modificadores. Use query_class como uma dica, para uma variável ou um filtro que você confere com os julgamentos, e nunca como rótulo. Quando a intenção for ambígua, como em cooktop, julgue segundo a leitura das diretrizes e registre por escrito essa leitura.
Relevância em graus em vez de sim ou não
Um rótulo binário diz relevante ou não relevante. Um rótulo graduado, como exact, partial ou irrelevant do WANDS, diz quão relevante é. Os resultados diferem em utilidade, então os mais relevantes devem ser encontrados e ranqueados primeiro. Järvelin and Kekäläinen defenderam os graus em 2002. Em uma loja, um quase acerto costuma ser uma boa segunda escolha. Uma cortina de box que não é transparente, que o WANDS classifica como partial porque é o tipo certo de produto sem o atributo pedido (Interpretar a intenção como um produto e seus modificadores), está mais próxima do que o cliente queria do que um gancho para cortina de box. Rótulos binários forçam uma única linha sobre os graus. Se você contar apenas exact como relevante, o quase acerto vale tanto quanto o gancho. Se contar exact e partial, ele vale tanto quanto a cortina transparente.
A consulta da loja clear shower curtain mostra as duas falhas. Monte três rankings de top 10 a partir dos seus julgamentos: dez produtos exact, dez cortinas de box julgadas partial e dez ganchos para cortina de box julgados irrelevant. Em seguida, pontue cada um com nDCG@10 (Pontuar um ranking) sob três rotulagens: binária com exact como relevante, binária com exact ou partial como relevantes, e os graus do livro, 2 para exact, 1 para partial e 0 para irrelevant, usados como ganhos. Um ganho é o que um resultado em determinada posição acrescenta à pontuação antes do desconto pela posição.
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
Somente os graus separam os três rankings. Com rótulos apenas exact, as outras cortinas pontuam igual aos ganchos, 0.000 e 0.000. Com rótulos exact ou partial, elas pontuam 1.000, igual às cortinas transparentes com 1.000. Com graus, as cortinas transparentes pontuam 1.000, as outras cortinas 0.500 e os ganchos 0.000. Quando o top 10 ideal é todo exact, como acontece aqui com 10 produtos exact no top 10 ideal, um ranking de dez produtos partial pontua a razão entre o ganho de partial e o ganho de exact.
Regra prática: Recomendamos julgamentos graduados para busca de produtos, para que uma métrica possa creditar um quase acerto sem confundi-lo com uma correspondência. Colete graus mesmo que você também relate uma métrica binária: você sempre pode reduzir os graus a sim ou não, mas não o contrário. Use rótulos binários quando um quase acerto não tiver valor algum para o usuário, como quando a consulta é um número de modelo e só aquele modelo serve.
Escolha os ganhos com intenção
Graus são rótulos. Ganhos são o que cada rótulo vale em uma métrica, e essa é uma escolha. Este livro usa cada grau como seu ganho, de modo que parcial vale a metade de exato. O próprio artigo do WANDS atribui pesos 1.0, 0.5 e 0 a exato, parcial e irrelevante (Chen et al., 2022, Tabela 3), a mesma razão e, portanto, o mesmo nDCG. O Shopping Queries Dataset, conhecido como ESCI (Reddy et al., 2022), tem 2.6 milhões de julgamentos de pares consulta-produto rotulados manualmente, sobre 130 mil consultas únicas, e atribui graus de forma diferente. Ele separa um substituto, um item que funciona como substituto funcional, como um casaco de lã polar para uma consulta de suéter, de um complemento, um item que pode ser usado junto com um item exato. Seus ganhos são 1.0 para exato, 0.1 para substituto, 0.01 para complemento e 0.0 para irrelevante (Reddy et al., 2022, seção 3.1). O parcial do WANDS não é o mesmo que o substituto do ESCI, mas é o equivalente mais próximo.
Pontue as duas execuções de teste da loja do capítulo 1, os rankings do BM25 e da recuperação semântica para cada consulta de teste, sob cada um destes esquemas: as duas rotulagens binárias de Atribuir graus de relevância em vez de sim ou não, os graus do livro e um ganho parcial de 0.1 no espírito do ESCI. O exemplo também executa o teste de permutação e o teste t pareado do capítulo 3 sobre a vantagem da recuperação semântica sob cada esquema, e imprime os dois valores-p. Ambas as vantagens são descritivas, como todos os testes aqui. A execução semântica lê os embeddings registrados do modelo aberto Snowflake/snowflake-arctic-embed-m-v1.5 (Busca 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
A recuperação semântica lidera em 4 of 4 dos esquemas, mas o tamanho de sua vantagem depende da escolha. Produtos parciais ocupam 0.403 das posições do top 10 do BM25 e 0.380 das posições do top 10 da recuperação semântica, de modo que o ganho parcial move as duas pontuações bastante. O BM25 pontua 0.519 com rótulos somente exatos e 0.903 com rótulos exatos ou parciais. Com o ganho parcial de 0.1, semelhante ao ESCI, o BM25 pontua 0.564 e a recuperação semântica 0.688. A vantagem é 0.130 com rótulos somente exatos, 0.125 com ganhos semelhantes ao ESCI, 0.105 com os graus e 0.080 com rótulos exatos ou parciais. O exemplo não testa se essas vantagens diferem, então, em 30 consultas de teste, trate as diferenças entre elas como possivelmente ruído.
Os rótulos exatos ou parciais também saturam, separando os rankeadores em menos consultas. 19 consultas de teste empatam sob eles, contra 2 sob os graus.
Regra prática: Use ganhos lineares, os graus 2, 1 e 0, como padrão para busca de produtos. Escolha um ganho parcial menor quando um quase acerto valer pouco para seus compradores. Qualquer que seja a escolha, fixe-a antes de comparar os rankeadores, informe-a junto de cada pontuação e nunca compare nDCG calculados com ganhos diferentes.
Leia a composição de rótulos de cada consulta
Os ganhos definem quanto vale cada grau, mas não quantos graus de cada tipo uma consulta tem. Um conjunto de julgamentos não é uma única população: cada consulta tem seu próprio conjunto de produtos julgados e sua própria composição de graus, e essa composição determina como seria um ranqueamento perfeito para aquela consulta. Uma consulta ampla, que nomeia uma categoria que muitos produtos satisfazem, tem muitos produtos exatos. Uma consulta específica, com vários modificadores, pode ter apenas alguns. Uma média sobre as consultas mistura esses problemas diferentes, por isso leia a composição antes de calcular qualquer média.
As consultas da loja não são uma amostra aleatória do WANDS. Cada uma foi escolhida para ter de 60 a 300 produtos julgados, pelo menos 3 julgamentos exatos e 20 parciais, e uma classe prevista que nenhuma outra consulta escolhida tenha (cartão de dados). As contagens descrevem a amostra, não o WANDS como um todo, porque consultas fora desses limites nunca chegam à loja. Conte os rótulos de cada uma das 80 consultas e agrupe as consultas pela proporção de produtos exatos:
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 é o rótulo mais comum, com 0.610 de todos os julgamentos. A provável razão está em como o WANDS coletou os candidatos, tema que Saiba de onde vieram os julgamentos aborda. A proporção de exatos varia muito de uma consulta para outra, de 0.014 para 48 in entry table with side by side drawer a 0.749 para outdoor light fixtures, com mediana de 0.207. O histograma que o exemplo imprime é mais alto na extremidade baixa: 29 consultas têm proporção de exatos igual ou inferior a 0.1.
Julgamentos irrelevantes são raros para a maioria das consultas, mas não para todas: a proporção de irrelevantes tem mediana de 0.060, porém chega a 0.776 para podium with locking cabinet, e 9 consultas não têm nenhum julgamento irrelevante.
A dispersão muda o que nDCG@10 mede. Os produtos exatos por consulta vão de 3, o piso da regra de amostragem, a 193, e 23 consultas têm menos de 10 produtos exatos, 7 delas consultas de teste. Para essas, o top 10 ideal inclui produtos parciais, de modo que um ranqueamento pode obter pontuação perfeita com produtos parciais em seu top 10. Para uma consulta ampla, como outdoor light fixtures, uma pontuação perfeita exige dez produtos exatos. O mesmo nDCG@10 significa coisas diferentes em cada caso.
Regra prática: Imprima a composição de rótulos por consulta antes de calcular a média de qualquer métrica, e observe as duas extremidades. Trate uma pontuação baixa em uma consulta com poucos produtos exatos como um problema diferente de uma pontuação baixa em uma consulta ampla. Mantenha as pontuações por consulta ao lado de cada média; o capítulo 3 mostra o que as médias escondem.
Trate os clicks como evidência enviesada
Uma loja registra todo click, e clicks não custam nada para coletar, então parecem julgamentos gratuitos. Não são. Um click indica que um comprador escolheu olhar um produto. Ele não indica que o produto atendeu à necessidade, e se o comprador clica ou não depende de onde e de como o produto foi mostrado.
A evidência sobre como os clicks induzem ao erro vem da busca na web. Joachims et al. acompanharam os olhares e os clicks de estudantes de graduação da Cornell que responderam dez perguntas definidas com o Google, em duas fases, com 34 estudantes na primeira fase e 22 na segunda. Na segunda fase, alguns viam os dois primeiros resultados trocados, ou a lista inteira invertida (Joachims et al., 2005). Os autores concluíram que os clicks são "informativos, mas enviesados".
O primeiro viés é o viés de posição: as pessoas clicam mais nos resultados mais bem posicionados, em parte porque confiam no ranqueamento. Joachims et al. chamam o efeito de "viés de confiança", que atrai clicks para links bem posicionados mesmo quando outros resumos que o usuário viu são mais relevantes. Os autores também constataram que as preferências relativas, como um resultado clicado em detrimento de outro ignorado acima dele, são razoavelmente precisas em média.
Em um grande experimento em um motor de busca na web, Craswell et al. constataram que um modelo em cascata explicava melhor o viés de posição nas primeiras posições. No modelo em cascata, os usuários leem os resultados de cima para baixo e saem no primeiro documento que vale a pena (Craswell et al., 2008).
O viés de apresentação vai além da posição: os clicks dependem de como um resultado é mostrado, e não apenas de onde ele está. Em uma parte do tráfego de busca na web do Google, resultados com títulos mais atraentes, ou seja, com mais palavras da consulta em negrito, receberam mais clicks, mesmo após controlar a posição e a relevância conforme avaliada pelas pessoas (Yue et al., 2010). Em uma loja, as imagens e os preços são o análogo mais próximo dos títulos. Essa é uma inferência nossa, não um resultado medido.
O WANDS não tem dados de click, então a loja não consegue medir esses vieses. Ainda assim, você pode ver o que um registro de clicks registraria. Tome os julgamentos da loja para clear shower curtain e aplique o modelo em cascata em sua forma mais estrita: um comprador lê de cima para baixo, clica no primeiro produto exato e sai. Este experimento mental usa uma regra fixa, não um modelo de compradores reais. O Capítulo 11 simula clicks com probabilidades. Execute o experimento mental sobre o ranqueamento do BM25 e sobre o da recuperação semântica, e leia os dois registros de clicks lado a lado:
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
Um registro de clicks registra tanto o que o ranqueador mostrou primeiro quanto o que o comprador queria. No ranqueamento do BM25, o comprador clica no rank 2, woolley vinyl single shower curtain, e nunca chega aos 3 produtos exatos abaixo dele. No registro de clicks, esses produtos exatos parecem iguais aos dos ranks 8 a 10 do BM25, ganchos para cortina de chuveiro julgados irrelevantes (Ranquear produtos com BM25), que ninguém clicou, também.
No ranqueamento da recuperação semântica, o click cai no rank 1, sobre woolley vinyl solid color single shower curtain. Dois ranqueamentos do mesmo catálogo produzem dois registros de clicks que creditam produtos diferentes.
Os autores do WANDS dão o mesmo motivo, o viés de posição, para não construir o conjunto de dados a partir de registros de clicks (Verifique os resultados contra os julgamentos). Os clicks, ainda assim, carregam informação. No WANDS, 62.47% dos candidatos extraídos de registros de clicks foram julgados exatos, contra 30.95% dos extraídos de sistemas de ranqueamento de código aberto (Chen et al., 2022, Tabela 4).
Corrigir os clicks para o viés é um campo próprio, o aprendizado de ranqueamento sem viés. Em um grande conjunto de dados de busca divulgado pelo Baidu, esses métodos melhoraram a previsão de clicks, mas "têm dificuldade para melhorar de forma consistente o desempenho do ranqueamento" conforme julgado por especialistas (Hager et al., 2024).
Regra prática: Use julgamentos, não clicks, como referência para a avaliação offline. Use clicks como evidência relativa, um produto clicado em detrimento de outro ignorado posicionado acima dele, e nunca leia a ausência de click como sinal de que um produto é irrelevante. Se você treinar com clicks, verifique o resultado contra os julgamentos.
Saiba de onde vieram os julgamentos
Ninguém julga todos os produtos para cada consulta, por isso as coleções de teste julgam um pool, um conjunto de candidatos reunido para cada consulta. No TREC, as avaliações compartilhadas da Text REtrieval Conference, o pool de um tópico é a união dos documentos mais bem ranqueados que cada participante recuperou, geralmente os 100 primeiros, e todo documento fora do pool conta como não relevante. Voorhees argumenta que os sistemas ainda podem ser comparados de forma justa quando todo documento não julgado conta como não relevante, porque os pools contêm documentos relevantes em quantidade suficiente. O mesmo artigo observa que o pooling não consegue produzir coleções de teste reutilizáveis para conjuntos de documentos arbitrariamente grandes (Voorhees, 2007). Zobel testou a afirmação de justiça. Com julgamentos em pool, o desempenho relativo dos sistemas parece confiável, mas a revocação é superestimada, pois muitos documentos relevantes provavelmente nunca foram encontrados (Zobel, 1998).
O WANDS montou seu pool em duas etapas (Chen et al., 2022, seções 4.2 e 4.3). A primeira reuniu os produtos que os compradores tinham clicado ou adicionado aos carrinhos, além dos resultados de um mecanismo de busca lexical de código aberto, o Solr, e de um sistema de recuperação neural. A segunda varreu novamente todo o catálogo com esses mesmos dois sistemas e acrescentou cada produto da classe que um modelo de classificação de consultas previa para a consulta. Essa segunda etapa produziu a maior parte dos rótulos do WANDS, e em sua maioria quase acertos: 4.12% dos rótulos foram exatos e 63.99% parciais (Tabela 5). Parcial também é o rótulo mais comum na amostra da loja (Leia a distribuição de rótulos de cada consulta). Os autores argumentam que a completude importa para a busca de produtos, porque "a incompletude no conjunto de dados de Product Search prejudica o poder discriminativo da avaliação" (seção 3.1).
Um pool pertence a uma consulta. Um produto sem julgamento para uma consulta é não julgado para ela, e um produto julgado para uma consulta pode ser não julgado para uma consulta parecida. Duas consultas da loja mostram isso: a consulta de treino trundle daybed e a consulta de teste full bed with trundle. Conte os produtos julgados como exatos para a primeira que não têm julgamento para a segunda, e veja como os julgadores avaliaram os que têm:
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
Uma métrica que atribui nota 0 a um produto não julgado está adivinhando sobre ele, e aqui a adivinhação importa. Pela nossa leitura da regra das diretrizes, uma daybed com trundle costuma ser o tipo certo de cama sem o tamanho que a consulta pede. Dos 113 produtos julgados como exatos para trundle daybed, 77 não têm julgamento para full bed with trundle, entre eles os dois de menor número de produto, daybed with trundle e pattonsburg daybed with trundle. Dos 36 que têm, os avaliadores classificaram 5 como exatos, 31 como parciais e 0 como irrelevantes. Se as camas não julgadas se parecerem com as julgadas, a maioria delas seria parcial também, mas uma métrica dá a cada uma nota 0.
Zobel alerta que julgamentos em pool podem subestimar sistemas que não contribuíram para o pool (Zobel, 1998). Isso torna os julgamentos mais justos para ranqueadores parecidos com os sistemas que montaram o pool: no WANDS, os cliques dos compradores, um mecanismo lexical, um recuperador neural e um classificador de consultas. Trata-se de uma tendência, não de uma lei. Aqui, o BM25, o ranqueador mais parecido com o mecanismo lexical do WANDS, tem o judged@10 mais baixo dos dois ranqueadores (Conte os produtos não julgados). Nossa suspeita é que o BM25 da loja lê campos diferentes dos que o mecanismo do pool leu, e por isso coloca no topo produtos diferentes.
Regra prática: Descubra de onde veio o seu pool antes de confiar em uma comparação. Quando você avaliar um ranqueador diferente dos sistemas que o montaram, espere que ele traga à tona produtos que ninguém julgou, e planeje julgá-los.
Conte os produtos sem julgamento antes de comparar as pontuações
Um produto que ninguém julgou para uma consulta é sem julgamento: sua nota é desconhecida, não 0. As métricas padrão não distinguem essa diferença. Elas pontuam um produto sem julgamento exatamente como pontuam um produto julgado irrelevante, e Buckley e Voorhees alertam que essas métricas se tornam não confiáveis quando os julgamentos são muito incompletos (Buckley and Voorhees, 2004). Dois diagnósticos são comuns em ferramentas de avaliação (ir-measures). Judged@k é a fração dos k primeiros resultados que tem um julgamento de qualquer nota:
judged@k = (number of the top k products that have a judgment for the query) / k
O segundo diagnóstico é a lista condensada, um ranking com seus produtos sem julgamento removidos antes da pontuação, de modo que os produtos julgados sobem. O ir-measures oferece essa lista como a opção judged_only. A medida bpref de Buckley e Voorhees segue o mesmo espírito: ela usa apenas documentos julgados, e eles constataram que ela é mais robusta a julgamentos incompletos.
No capítulo 1, o judged@10 médio do BM25 nas consultas de teste é 0.927. A média da recuperação semântica é 0.990. Uma propriedade dos dados da loja mantém esses números altos. O catálogo está quase todo julgado: 11,917 de 12,000 produtos têm um julgamento para pelo menos uma consulta (Carregue os dados da loja). Espere que um catálogo completo coloque mais produtos sem julgamento nos top 10 das consultas.
Calcule o judged@10 manualmente, confira-o com lib.metrics e liste onde estão os produtos sem julgamento do 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
O judged@10 calculado manualmente é igual a lib.metrics em 30 of 30 consultas de teste, com média de 0.927. Produtos sem julgamento ocupam 22 das posições do top 10 do BM25, distribuídas por 7 consultas. Segundo nossa leitura, alguns são claramente irrelevantes: lâmpadas para outdoor light fixtures, um travesseiro de exterior para beach blue headboard. Outros parecem quase acertos ou acertos: uma cama com trundle para full bed with trundle, um conjunto de bistrô para bistro table and chairs, um sofá-cama para pull out sleeper loveseat, que, pela regra de entidade e modificador, provavelmente é um quase acerto: os avaliadores consideraram 0 dos 143 produtos julgados daquela consulta irrelevantes.
Pontue os dois ranqueadores com listas condensadas, que removem os produtos sem julgamento, para ver quanto as pontuações se movem:
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 eleva o BM25 principalmente por perdoar resultados ruins, e não por desfazer uma penalização sobre os bons. O BM25 passa de 0.725 para 0.778, e a recuperação semântica, de 0.830 para 0.834. Do ganho do BM25, uma fração de 0.612 vem de outdoor light fixtures e beach blue headboard, as duas consultas cujos produtos sem julgamento são claramente irrelevantes. Para outdoor light fixtures, o BM25 passa de 0.286 para 1.000: quando as lâmpadas saem, os produtos julgados de iluminação que estavam abaixo delas sobem.
A vantagem da recuperação semântica cai de 0.105 para 0.056 quando as listas são condensadas. Se essa mudança é mais que ruído, ainda não está resolvido. O teste t pareado do capítulo 3 dá p = 0.073 para a mudança, e o teste de permutação dá 0.036. O intervalo bootstrap de 95% vai de -0.138 to -0.015. Ambas as verificações são exploratórias. Como a mudança é carregada por poucas consultas, trate-a como possível ruído.
A própria vantagem condensada tem p = 0.009 pelo teste de permutação e 0.011 pelo teste t. Nem a pontuação padrão nem a condensada é a verdade. A pontuação padrão penaliza produtos sem julgamento que podem ser bons, e a pontuação condensada oculta produtos sem julgamento que são ruins.
Regra prática: informe o judged@10 ao lado de cada nDCG@10, e calcule pontuações condensadas como diagnóstico, nunca como resultado principal. Quando o judged@10 de dois ranqueadores difere, peça que os produtos sem julgamento em seus top 10 sejam julgados antes de compará-los. Essa é a solução confiável, e, nesta amostra, é um trabalho pequeno: 22 julgamentos para a execução de teste do BM25. Em um catálogo completo, espere mais.
O que dá errado em produção
Os julgamentos envelhecem. O catálogo de uma loja e os seus compradores não param de mudar, e a relevância depende de mais do que a consulta. Tsagkias et al. citam o usuário, o momento, a consulta e o contexto, e dão um exemplo: uma consulta por jaquetas tem produtos relevantes diferentes no inverno e no verão (Tsagkias et al., 2020, seção 3.1.1). Produtos entram no catálogo sem julgamento, e produtos que saem dele permanecem no conjunto de julgamentos. Acompanhe o judged@10 do seu ranqueador em produção ao longo do tempo, e julgue novamente quando ele cair.
Rótulos de clique confirmam o ranqueamento que você já tem. Um ranqueador treinado com cliques registrados sob o ranqueamento atual aprende a ordem desse ranqueamento junto com as preferências dos compradores. Mantenha os julgamentos humanos como referência contra a qual os cliques são verificados (Trate os cliques como evidência enviesada).
As diretrizes moldam os julgamentos. Os anotadores do WANDS precisaram de quatro meses para chegar a uma concordância quase perfeita (Chen et al., 2022, Tabela 2). Pequenas escolhas nas diretrizes moldam o conjunto inteiro. O WANDS orientou os anotadores a ignorar erros de digitação e a julgar o exemplo como escrito (diretrizes), e por isso seus julgamentos pressupõem um leitor que entende ligth bulb. Um ranqueador que não entende isso terá nota baixa nessas consultas, o que é justo com o comprador. O Capítulo 8 constrói um corretor ortográfico e mostra o que ele ainda erra.
Seu ranqueador vê menos do que seus juízes. Os juízes viram imagens e páginas de produto, enquanto os ranqueadores da loja leem apenas texto sem os atributos (o capítulo 5 testa acrescentá-los). Qualquer modelo de linguagem de grande porte (LLM) que receba o mesmo texto para julgar vê o que o ranqueador vê. Parte da discordância entre esse sistema e os julgamentos humanos vem dessa diferença, e não do sistema. Verifique quais campos contêm os atributos que seus juízes valorizaram antes de culpar o ranqueador.
Preencher lacunas com um modelo ainda exige julgamentos humanos. Gienapp et al. ajustam, para cada consulta, um pequeno classificador com os julgamentos humanos dessa consulta, e o usam para julgar os produtos não julgados. Em TREC Robust04 e nas coleções TREC Deep Learning de 2019 e 2020, eles relatam que apenas 128 julgamentos humanos iniciais por tópico já melhoram a comparabilidade dos modelos, e que a abordagem é mais confiável do que avaliadores LLM por prompt (Gienapp et al., 2025). A recomendação de Soboroff sobre LLMs é mais direta: "não use LLMs para criar julgamentos de relevância em avaliações no estilo TREC" (Soboroff, 2025). O Capítulo 4 mede os julgamentos de LLM contra os humanos da loja antes de confiar neles.
Regra prática: Date os seus julgamentos, acompanhe o judged@10 em produção e reserve orçamento para julgar novamente.
Decisões tomadas neste capítulo
Os capítulos seguintes mantêm essas decisões, a menos que uma medição sobre as consultas de treino indique o contrário.
- Os julgamentos humanos são a referência. Todas as pontuações principais deste livro são calculadas sobre eles, inclusive as pontuações de ranqueadores construídos com LLMs. Os cliques são evidências sobre compradores, enviesadas pela posição e pela apresentação, e nunca servem de rótulos.
- As notas 2, 1 e 0 são os ganhos, de modo que o parcial vale metade do exato, a mesma proporção dos próprios 1.0, 0.5 e 0 do WANDS. Métricas binárias contam apenas o exato.
- Uma nota por par. Quando o WANDS lista um par mais de uma vez com rótulos diferentes, a amostra mantém a nota mais baixa, o que erra em desfavor do ranqueador.
query_classé uma dica, nunca um rótulo e nunca uma medida de intenção. Alguns de seus valores estão errados.- Produtos não julgados contam como nota 0, com judged@10 ao lado de cada nDCG@10. Pontuações condensadas servem apenas como diagnóstico. O remédio para produtos não julgados em um top 10 é fazer com que sejam julgados.
- Os ranqueadores leem o texto do produto, não os atributos. O Capítulo 5 testa acrescentá-los como campo e os mantém fora do texto do BM25. Os julgadores também viram imagens e páginas de produto, de modo que alguns produtos exatos dão pouco material para um ranqueador somente de texto combinar.
- Leia qualquer julgamento, ajuste no treino. Ler julgamentos de teste não altera nenhum ranqueador; escolher uma correção a partir deles, sim.
- O que o capítulo mostrou: uma pontuação só é tão boa quanto os julgamentos em que se apoia.
Este capítulo, nesta edição
Edição 2026.11.10Exemplos aprovados em 19 de nov de 202610 de 10 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.10.