RAGAS, DeepEval et Promptfoo : Les outils clés pour évaluer les LLM

Introduction aux cadres d'évaluation des LLM

L'évaluation des modèles de langage de grande taille (LLM) est une tâche complexe qui nécessite des outils adaptés pour mesurer efficacement leurs performances. Parmi les principaux cadres open-source disponibles, RAGAS, DeepEval et Promptfoo se distinguent par leurs approches uniques. Ces outils reposent sur le mécanisme LLM-as-a-judge, qui présente des biais mesurables qu'il est crucial de considérer lors de la conception de systèmes basés sur les LLM.

Objectifs des cadres d'évaluation

Les cadres RAGAS, DeepEval et Promptfoo diffèrent principalement par leurs objectifs et les situations dans lesquelles ils sont les plus utiles. Il est essentiel de comprendre quand utiliser chacun d'eux, ainsi que les combinaisons recommandées par les équipes expérimentées.

• RAGAS : Ce cadre est basé sur la recherche, avec une méthodologie de qualité académique derrière des métriques comme la fidélité, la précision et le rappel du contexte. Il se concentre sur l'évaluation de la fidélité et de la précision des réponses générées par les LLM en se basant sur des données récupérées. Il est particulièrement adapté aux architectures axées sur la récupération d'informations. Cependant, il est limité à l'évaluation de la récupération et de la génération, sans surveillance de production ou couche de collaboration intégrée.

• DeepEval : Intégré à Python et basé sur pytest, DeepEval propose plus de 14 métriques pour évaluer les hallucinations, le biais, la toxicité et d'autres aspects spécifiques aux RAG. Il est conçu explicitement pour fonctionner comme une porte de qualité CI/CD qui peut bloquer un déploiement si nécessaire, assurant ainsi une intégration fluide dans les suites de tests existantes.

• Promptfoo : Ce cadre est orienté vers la ligne de commande et utilise la configuration YAML. Il excelle dans la comparaison de prompts multi-modèles et le red-teaming, avec une suite de tests de sécurité comprenant plus de 500 vecteurs d'attaque.

Comprendre l'évaluation des LLM

Avant de plonger dans les spécificités de chaque cadre, il est important de distinguer les différentes catégories d'évaluation des LLM. Cette distinction aide à éviter les erreurs courantes lors de la sélection d'un cadre d'évaluation.

• Benchmarking de modèle : Cette catégorie évalue les capacités brutes des modèles sur des tâches académiques standardisées comme MMLU, GSM8K et HumanEval. L'outil lm-evaluation-harness est souvent utilisé pour ces benchmarks académiques.

• Évaluation d'application : Elle se concentre sur la performance des applications spécifiques, telles que les pipelines RAG, les chatbots ou les agents, en vérifiant si les sorties sont correctes, fondées et sûres.

• Surveillance de production : Cette catégorie suit le trafic en direct après le déploiement pour détecter les régressions et les dérives non anticipées par les tests hors ligne. Des outils comme LangSmith, Braintrust et Arize Phoenix sont utilisés dans ce cadre.

Les biais dans l'évaluation des LLM

Lors de l'évaluation des LLM, il est crucial de prendre en compte les biais de position, de préférence personnelle et de verbosité. Ces biais peuvent influencer les résultats de manière significative. Les biais de position se réfèrent à la tendance d'un modèle à privilégier certaines positions dans une séquence de texte. Les biais de préférence personnelle concernent les inclinations subjectives qui peuvent affecter les jugements. Enfin, les biais de verbosité se manifestent lorsque des réponses plus longues sont favorisées, indépendamment de leur pertinence ou précision.

Pour détecter ces biais, un audit rigoureux est nécessaire. Cela implique de tester systématiquement les réponses du modèle dans divers scénarios pour identifier les tendances indésirables. Une fois détectés, ces biais peuvent être atténués en ajustant les paramètres du modèle ou en modifiant les données d'entraînement pour équilibrer les préférences.

Les métriques essentielles des cadres

Pour comprendre les différences entre RAGAS, DeepEval et Promptfoo, il est crucial de connaître les métriques qu'ils utilisent. Chaque outil implémente une version de quelques métriques clés. Le véritable facteur différenciateur entre ces cadres n'est pas la nouveauté des métriques, car ils implémentent principalement les mêmes idées. C'est plutôt l'adéquation du flux de travail : comment la métrique est déclenchée, où le résultat va, et si cela bloque un déploiement ou génère simplement un rapport.

• Fidélité : Cette métrique vérifie si une réponse ne contient que des affirmations soutenues par le contexte récupéré, ce qui est essentiel pour détecter les hallucinations RAG.

• Précision et rappel du contexte : Ces métriques vérifient si la récupération a extrait les bons documents avant la génération des réponses.

• Pertinence de la réponse : Elle évalue si la réponse aborde réellement la question posée, indépendamment de son fondement factuel.

• G-Eval : Introduit par Liu et al., ce mécanisme utilise le prompting en chaîne de pensée pour guider un juge LLM à travers un processus explicite, alignant les évaluations plus étroitement avec les préférences humaines.

Comparaison directe : RAGAS, DeepEval et Promptfoo

Chacun de ces cadres a ses forces et ses faiblesses, et leur choix dépend des besoins spécifiques de l'évaluation. Notamment, DeepEval et RAGAS ne sont pas vraiment des concurrents. DeepEval couvre les tests d'application LLM larges, tandis que RAGAS se spécialise spécifiquement dans RAG. Une part significative des équipes de production utilise les deux ensemble — avec RAGAS notant les dimensions spécifiques à la récupération et DeepEval gérant tout le reste dans le même pipeline CI.

• RAGAS : Idéal pour les architectures axées sur la récupération, avec des métriques soutenues par des recherches académiques.

• DeepEval : Conçu pour s'intégrer dans les suites de tests CI/CD, avec une large couverture de métriques.

• Promptfoo : Parfait pour l'ingénierie des prompts multi-modèles et les tests de sécurité.

Examen de code : Détection des hallucinations

Un exemple de code simple démontre le mécanisme de vérification de la fidélité utilisé par RAGAS. Ce code décompose une réponse en affirmations atomiques et vérifie chaque affirmation par rapport au contexte récupéré. Une affirmation sans soutien dans le contexte est considérée comme une hallucination.

# Exemple de code pour vérifier la fidélité
import re

def decompose_claims(answer: str) -> list[str]:
    """Divise une réponse en déclarations atomiques."""
    sentences = re.split(r'(?<=[.!?])\s+', answer.strip())
    return [s.strip() for s in sentences if s.strip()]

def claim_supported_by_context(claim: str, context: str) -> bool:
    """
    Vérifie si une affirmation est soutenue par le contexte récupéré.
    """
    claim_words = set(re.findall(r'\b[a-zA-Z]{4,}\b', claim.lower()))
    context_words = set(re.findall(r'\b[a-zA-Z]{4,}\b', context.lower()))
    if not claim_words:
        return True
    overlap = len(claim_words & context_words) / len(claim_words)
    return overlap >= 0.5

def compute_faithfulness(answer: str, context: str) -> dict:
    """
    Calcule le score de fidélité.
    """
    claims = decompose_claims(answer)
    supported = [c for c in claims if claim_supported_by_context(c, context)]
    unsupported = [c for c in claims if c not in supported]
    score = len(supported) / len(claims) if claims else 1.0
    return {
        "score": round(score, 3),
        "total_claims": len(claims),
        "unsupported_claims": unsupported,
    }

if __name__ == "__main__":
    context = "Abuja est devenue la capitale du Nigeria en 1991, remplaçant Lagos."
    grounded_answer = "La capitale du Nigeria est Abuja. Elle est devenue la capitale en 1991."
    result_1 = compute_faithfulness(grounded_answer, context)
    print("Réponse fondée :")
    print(f"  Score de fidélité : {result_1['score']}")
    print(f"  Affirmations non soutenues : {result_1['unsupported_claims']}\n")
    
    hallucinated_answer = (
        "La capitale du Nigeria est Abuja. Elle est devenue la capitale en 1991. "
        "La ville a une population de plus de 3 millions d'habitants."
    )
    result_2 = compute_faithfulness(hallucinated_answer, context)
    print("Réponse avec un détail halluciné :")
    print(f"  Score de fidélité : {result_2['score']}")
    print(f"  Affirmations non soutenues : {result_2['unsupported_claims']}")

Ce code illustre comment une affirmation non soutenue par le contexte peut être identifiée comme une hallucination, soulignant l'importance de la vérification de la fidélité dans l'évaluation des LLM.