Oceniaj jakość wyszukiwania
Na tej stronie
Cele
- Zrozumienie standardowych metryk oceny wyszukiwania
- Budowa zbioru danych ewaluacyjnych
- Pomiar i poprawa jakości Twojego silnika
Dlaczego oceniać?
Poprzednie lekcje wprowadziły szereg wyborów: model osadzeń, liczba wymiarów, rozmiar fragmentu oraz wagi hybrydowe. Każdy z tych wyborów może poprawić lub pogorszyć działanie Twojego systemu. Subiektywne wrażenia z ręcznego przetestowania trzech zapytań nie wystarczą do podjęcia decyzji – zwłaszcza że zmiana często poprawia jedną kategorię zapytań, pogarszając jednocześnie inną. Bez metryk działasz po omacku.
Kluczowe metryki
Recall@k odpowiada na pytanie: spośród dokumentów istotnych, ile pojawia się w top k wyników? To złoty standard metryk dla RAG, ponieważ dokument pominięty w kontekście nigdy nie zostanie przytoczony przez model generujący, niezależnie od jego jakości.
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 patrzy na odwrotność: spośród k zwróconych wyników, ile jest faktycznie istotnych? Ma to największe znaczenie, gdy kontekst wysyłany do LLM jest ograniczony, ponieważ każdy dokument niezwiązany z tematem zajmuje miejsce i rozprasza uwagę modelu.
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) mierzy pozycję pierwszego istotnego wyniku. Dokument na pierwszym miejscu otrzymuje wynik 1, na drugim 0,5, a na piątym 0,2. Nadaj priorytet tej metryce w przypadku pasków wyszukiwania przeznaczonych dla ludzi, którzy rzadko patrzą dalej niż pierwsze trzy linie.
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) idzie dalej, rezygnując z binarnej istotności: akceptuje stopnie istotności, pozwalając rozróżnić dokument, który dokładnie odpowiada na pytanie, od takiego, który jedynie go dotyczy. Logarytm w mianowniku stosuje progresywne obniżenie wagi w zależności od pozycji, a normalizacja względem idealnego rankingu skaluje wszystko między 0 a 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
Tworzenie zbioru danych ewaluacyjnych
Żaden z tych wzorów nie jest użyteczny bez prawdy referencyjnej (ground truth). Zbiór danych ewaluacyjnych kojarzy każde zapytanie z listą dokumentów, które powinny się pojawić, a opcjonalnie także z tymi, które zdecydowanie nie powinny – te ostatnie są przydatne do monitorowania znanych fałszywych trafień.
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)
Trzydzieści dobrze dobranych par obejmujących różne typy pytań, które Twój silnik faktycznie otrzymuje, jest warte więcej niż trzysta wyprodukowanych masowo. Priorytetem powinno być czerpanie danych z logów wyszukiwania: to rzeczywiste sformułowania Twoich użytkowników, a nie te, które sobie wyobrażasz.
Generowanie zapytań testowych za pomocą LLM
Przy dużym korpusie ręczne pisanie staje się niewykonalne. Odwracamy więc problem: zamiast szukać dokumentów odpowiadających na pytanie, pytamy model, na jakie pytania może odpowiedzieć dany dokument. Dokument z założenia jest istotny dla tych pytań, a pary uzyskujesz w kilka minut.
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")
Ta metoda ma ślepy punkt, o którym musisz wiedzieć: generowane pytania często używają dokładnego słownictwa z dokumentu, co czyni je łatwiejszymi niż rzeczywiste zapytania użytkowników i sztucznie zawyża Twoje wyniki. Używaj ich do porównywania dwóch konfiguracji względem siebie, nigdy do deklarowania absolutnego poziomu jakości.
Kompletny potok ewaluacji
Ewaluator uruchamia każde zapytanie ze zbioru danych na silniku, oblicza wszystkie metryki dla kilku wartości k, a następnie uśrednia cały zestaw.
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}")
Śledzenie wielu wartości k jest samo w sobie pouczające: wysoki recall@10 przy słabym recall@1 sygnalizuje, że odpowiednie dokumenty są znajdowane, ale źle rankowane – to problem rerankingu, a nie indeksowania.
Porównywanie dwóch konfiguracji
Poniższa funkcja zestawia dwa silniki przeciwko temu samemu zbiorowi danych i wyświetla różnicę metryk dla każdej z nich. Powtarzaj ten krok przed każdym wdrożeniem produkcyjnym, nawet w przypadku zmiany, która wydaje się trywialna.
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}")
Odczytuj delty ostrożnie na małym zbiorze danych: różnica 0,02 przy trzydziestu zapytaniach to prawdopodobnie szum, podczas gdy spadek recall@5 o 0,10 jest wyraźnym sygnałem, by nie wdrażać zmian.
Kluczowe wnioski
- Recall@k, Precision@k, MRR i NDCG to standardowe metryki
- Stwórz zbiór danych ewaluacyjnych z parami (zapytanie, istotne dokumenty)
- Automatyzuj generowanie zapytań za pomocą LLM
- Systematycznie porównuj konfiguracje przed wdrożeniem