Оценяване на качеството на търсенето
На тази страница
Цели
- Да разберете стандартните метрики за оценяване на търсенето
- Да изградите набор от данни за оценяване
- Да измерите и подобрите качеството на вашата система
Защо да оценявате?
Предишните уроци въведоха поредица от избори: модел за вграждане, брой измерения, размер на чанка и хибридно претегляне. Всеки избор може да подобри или влоши вашата система. Субективните впечатления от ръчно тестване на три заявки не са достатъчни за вземане на решение – особено след като промяна често подобрява една категория заявки, докато влошава друга. Без метрики летите на сляпо.
Ключови метрики
Recall@k отговаря на въпроса: сред релевантните документи колко се появяват в топ k резултата? Това е златният стандарт за RAG, защото документ, липсващ в контекста, никога не може да бъде цитиран от генеративния модел, колкото и добър да е той.
def recall_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion of relevant documents found in the top-k."""
top_k = set(resultats[:k])
trouves = pertinents & top_k
return len(trouves) / len(pertinents) if pertinents else 0.0
Precision@k разглежда обратното: сред върнатите k резултата колко са всъщност релевантни? Това е най-важно, когато контекстът, изпратен до LLM, е ограничен, тъй като всеки документ извън темата заема място и размива вниманието на модела.
def precision_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion of relevant results in the top-k."""
top_k = resultats[:k]
trouves = sum(1 for r in top_k if r in pertinents)
return trouves / k if k > 0 else 0.0
MRR (Mean Reciprocal Rank) измерва ранга на първия релевантен резултат. Документ на първо място получава оценка 1, на второ – 0,5, а на пето – 0,2. Приоритизирайте тази метрика за ленти за търсене, предназначени за хора, които рядко поглеждат отвъд първите три реда.
def mrr(pertinents: set[str], resultats: list[str]) -> float:
"""Reciprocal rank of the first relevant result."""
for i, r in enumerate(resultats):
if r in pertinents:
return 1.0 / (i + 1)
return 0.0
NDCG@k (Normalized Discounted Cumulative Gain) отива по-далеч, като изоставя бинарната релевантност: той приема степени на релевантност, позволявайки ви да разграничите документ, който отговаря точно на въпроса, от такъв, който само го засяга. Логаритъмът в знаменателя прилага прогресивно намаление спрямо ранга, а нормализирането спрямо идеалното класиране скалира всичко между 0 и 1.
import numpy as np
def ndcg_at_k(relevances: list[float], k: int) -> float:
"""NDCG with graded relevance scores."""
dcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(relevances[:k])
)
ideal = sorted(relevances, reverse=True)[:k]
idcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(ideal)
)
return dcg / idcg if idcg > 0 else 0.0
Създаване на набор от данни за оценяване
Нито една от тези формули не е полезна без истинска основа (ground truth). Наборът от данни за оценяване свързва всяка заявка със списъка от документи, които трябва да се появят, и по желание с тези, които определено не трябва – последните са полезни за мониторинг на известни фалшиви положителни резултати.
import json
# Dataset structure
dataset_eval = [
{
"requête": "comment installer Python sur Windows",
"pertinents": ["doc_install_python", "doc_setup_env"],
"non_pertinents": ["doc_cuisine"]
},
{
"requête": "configurer nginx comme reverse proxy",
"pertinents": ["doc_nginx_proxy", "doc_nginx_config"],
"non_pertinents": ["doc_python_web"]
},
]
# Save
with open("eval_dataset.json", "w") as f:
json.dump(dataset_eval, f, ensure_ascii=False, indent=2)
Тридесет добре подбрани двойки, обхващащи различните типове въпроси, които вашата система действително получава, струват повече от триста масово произведени. Приоритизирайте извличането от вашите логове за търсене: това са действителните формулировки на вашите потребители, а не тези, които си представяте.
Генериране на тестови заявки с LLM
При голям корпус ръчното писане става непрактично. Затова обръщаме проблема: вместо да търсим документи, които отговарят на въпрос, питаме модел какви въпроси може да адресира даден документ. Документът по конструкция е релевантен за тези въпроси и получавате двойки за минути.
from openai import OpenAI
client = OpenAI()
def generer_requetes_test(document: str, n: int = 3) -> list[str]:
"""Generate n queries that this document should answer."""
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Voici un document :\n\n{document}\n\n"
f"Génère {n} questions auxquelles ce document répond. "
f"Retourne uniquement les questions, une par ligne."
)
}]
)
return response.choices[0].message.content.strip().split("\n")
Този метод има сляпо петно, което трябва да знаете: генерираните въпроси често използват точния речник на документа, което ги прави по-лесни от реалните потребителски заявки и изкуствено повишава вашите резултати. Използвайте ги, за да сравните две конфигурации една спрямо друга, но никога, за да обявите абсолютно ниво на качество.
Пълен конвейер за оценяване
Оценителят изпълнява всяка заявка от набора от данни върху системата, изчислява всички метрики за няколко стойности на k и след това осреднява целия набор.
class EvaluateurRecherche:
def __init__(self, moteur_recherche):
self.moteur = moteur_recherche
def evaluer(
self, dataset: list[dict], k_values: list[int] = [1, 3, 5, 10]
) -> dict:
"""Evaluate the engine on a complete dataset."""
resultats = {f"recall@{k}": [] for k in k_values}
resultats.update({f"precision@{k}": [] for k in k_values})
resultats["mrr"] = []
for item in dataset:
# Run search
res = self.moteur.rechercher(item["requête"], k=max(k_values))
ids_resultats = [r["id"] for r in res]
pertinents = set(item["pertinents"])
# Calculate metrics
resultats["mrr"].append(mrr(pertinents, ids_resultats))
for k in k_values:
resultats[f"recall@{k}"].append(
recall_at_k(pertinents, ids_resultats, k)
)
resultats[f"precision@{k}"].append(
precision_at_k(pertinents, ids_resultats, k)
)
# Average
return {
metrique: round(np.mean(scores), 4)
for metrique, scores in resultats.items()
}
# Usage
evaluateur = EvaluateurRecherche(moteur)
metriques = evaluateur.evaluer(dataset_eval)
print("Résultats d'évaluation :")
for metrique, score in metriques.items():
print(f" {metrique}: {score}")
Проследяването на множество стойности на k е само по себе си поучително: висок recall@10, съчетан с лош recall@1, сигнализира, че правилните документи се намират, но са лошо класирани – това е проблем с преподреждането (reranking), а не с индексирането.
Сравняване на две конфигурации
Следната функция противопоставя две системи на един и същи набор от данни и показва разликата в метриките за всяка метрика. Повтаряйте тази стъпка преди всяко внедряване в продукция, дори за промяна, която изглежда тривиална.
def comparer_configs(moteur_a, moteur_b, dataset, noms=("A", "B")):
"""Compare two search engines."""
eval_a = EvaluateurRecherche(moteur_a).evaluer(dataset)
eval_b = EvaluateurRecherche(moteur_b).evaluer(dataset)
print(f"{Métrique:<20} {noms[0]:<10} {noms[1]:<10} {Delta:<10}")
print("-" * 50)
for metrique in eval_a:
delta = eval_b[metrique] - eval_a[metrique]
signe = "+" if delta > 0 else ""
print(f"{metrique:<20} {eval_a[metrique]:<10.4f} "
f"{eval_b[metrique]:<10.4f} {signe}{delta:<10.4f}")
Четете делтите внимателно при малък набор от данни: разлика от 0,02 при тридесет заявки вероятно е шум, докато спад от 0,10 в recall@5 е ясен сигнал да не внедрявате.
Ключови изводи
- Recall@k, Precision@k, MRR и NDCG са стандартните метрики
- Създайте набор от данни за оценяване с двойки (заявка, релевантни документи)
- Автоматизирайте генерирането на заявки с LLM
- Систематично сравнявайте конфигурациите преди внедряване