Przejdź do głównej treści
Polski— Wybierz język
Menu

Oceniaj jakość wyszukiwania

Lekcja 10 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Dlaczego oceniać?
  3. Kluczowe metryki
  4. Tworzenie zbioru danych ewaluacyjnych
  5. Kompletny potok ewaluacji
  6. Porównywanie dwóch konfiguracji
  7. Kluczowe wnioski

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