Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Évaluer la qualité de la recherche

Paskaita 10 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Objectifs
  2. Pourquoi évaluer ?
  3. Métriques clés
  4. Créer un jeu de données d’évaluation
  5. Pipeline d’évaluation complet
  6. Comparer deux configurations
  7. Svarbiausi punktai

Objectifs

  • Comprendre les métriques standard d’évaluation de la recherche
  • Construire un jeu de données d’évaluation
  • Mesurer et améliorer la qualité de ton moteur

Pourquoi évaluer ?

Les leçons précédentes ont présenté une série de choix : modèle d’embedding, nombre de dimensions, taille des chunks et pondération hybride. Chaque choix peut améliorer ou dégrader ton système. Les impressions subjectives issues de tests manuels sur trois requêtes ne suffisent pas à décider, d’autant plus qu’un changement améliore souvent une catégorie de requêtes tout en dégradant une autre. Sans métriques, tu navigues à l’aveugle.

Métriques clés

Recall@k répond à cette question : parmi les documents pertinents, combien apparaissent dans les k premiers résultats ? C’est la métrique de référence pour le RAG, car un document absent du contexte ne pourra jamais être cité par le modèle de génération, aussi performant soit-il.

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 examine l’inverse : parmi les k résultats retournés, combien sont réellement pertinents ? Cela importe surtout lorsque le contexte envoyé au LLM est limité, car chaque document hors sujet prend de la place et dilue l’attention du modèle.

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) mesure le rang du premier résultat pertinent. Un document en première place obtient un score de 1, en deuxième place 0,5, et en cinquième place 0,2. Privilégie cette métrique pour les barres de recherche destinées aux humains, qui regardent rarement au-delà des trois premières lignes.

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) va plus loin en abandonnant la pertinence binaire : il accepte des degrés de pertinence, te permettant de distinguer un document qui répond exactement à la question d’un autre qui ne fait que l’effleurer. Le logarithme au dénominateur applique une décote progressive selon le rang, et la normalisation par rapport au classement idéal ramène tout entre 0 et 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

Créer un jeu de données d’évaluation

Aucune de ces formules n’est utile sans vérité terrain. Un jeu de données d’évaluation associe chaque requête à la liste des documents qui devraient apparaître, et optionnellement à ceux qui ne devraient absolument pas apparaître ; ces derniers sont utiles pour surveiller les faux positifs connus.

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)

Trente paires bien choisies couvrant les différents types de questions que ton moteur reçoit réellement valent mieux que trois cents générées en masse. Priorise l’extraction depuis tes journaux de recherche : ce sont les formulations réelles de tes utilisateurs, pas celles que tu imagines.

Générer des requêtes de test avec un LLM

Sur un grand corpus, la rédaction manuelle devient impraticable. Nous inversons donc le problème : au lieu de chercher des documents répondant à une question, nous demandons à un modèle quelles questions un document donné peut traiter. Le document est par construction pertinent pour ces questions, et tu obtiens des paires en quelques minutes.

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")

Cette méthode présente un angle mort que tu dois connaître : les questions générées réutilisent souvent le vocabulaire exact du document, ce qui les rend plus faciles que les requêtes réelles des utilisateurs et gonfle artificiellement tes scores. Utilise-les pour comparer deux configurations entre elles, jamais pour déclarer un niveau de qualité absolu.

Pipeline d’évaluation complet

L’évaluateur exécute chaque requête du jeu de données sur le moteur, calcule toutes les métriques pour plusieurs valeurs de k, puis fait la moyenne sur l’ensemble.

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}")

Le suivi de plusieurs valeurs de k est instructif en soi : un recall@10 élevé couplé à un mauvais recall@1 signale que les bons documents sont trouvés mais mal classés ; il s’agit d’un problème de reranking, pas d’indexation.

Comparer deux configurations

La fonction suivante oppose deux moteurs sur le même jeu de données et affiche l’écart de métrique par métrique. Répète cette étape avant chaque déploiement en production, même pour un changement qui semble trivial.

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}")

Lis les deltas avec prudence sur un petit jeu de données : un écart de 0,02 sur trente requêtes est probablement du bruit, tandis qu’une chute de 0,10 du recall@5 est un signal clair pour ne pas déployer.

Svarbiausi punktai

  • Recall@k, Precision@k, MRR et NDCG sont les métriques standard
  • Crée un jeu de données d’évaluation avec des paires (requête, documents pertinents)
  • Automatise la génération de requêtes avec un LLM
  • Compare systématiquement les configurations avant de déployer