Évaluation automatique du RAG : nouveau framework atteint 95% de corrélation avec les jugements humains

Vue d'ensemble de la recherche

Google Research a publié AutoRAGEval, un framework pour évaluer automatiquement les systèmes RAG qui atteint 95% de corrélation avec les jugements d'experts humains, éliminant potentiellement le besoin d'évaluations manuelles coûteuses.

Le défi de l'évaluation

Les méthodes actuelles d'évaluation RAG ont des limitations :

Évaluation humaine :

• Coûteuse (50-200$ par cas de test)
• Lente (jours à semaines)
• Incohérente (accord inter-évaluateurs ~70%)
• Non évolutive

Métriques automatisées existantes :

• BLEU/ROUGE : Médiocres pour RAG (22% de corrélation)
• Similarité sémantique : Meilleures mais insuffisantes (58% de corrélation)
• LLM-as-judge : Incohérent et coûteux

AutoRAGEval répond à ces limitations.

Le framework AutoRAGEval

Évaluation multidimensionnelle

Évalue cinq dimensions clés :

1. Fidélité : La réponse est-elle ancrée dans le contexte récupéré ?
2. Pertinence : La réponse répond-elle à la question ?
3. Complétude : Tous les aspects sont-ils couverts ?
4. Concision : La réponse est-elle concise sans informations inutiles ?
5. Cohérence : La réponse est-elle bien structurée et lisible ?

Chaque dimension est notée de 1 à 5, puis agrégée.

Approche à deux modèles

Utilise deux modèles spécialisés :

Modèle évaluateur (GPT-4 affiné)

DEVELOPERpython
score = evaluator.assess(
    query=query,
    answer=answer,
    context=context,
    dimension="faithfulness"
)

Modèle de calibration (plus petit, plus rapide)

DEVELOPERpython
# Calibre les scores pour correspondre à la distribution humaine
calibrated_score = calibrator.adjust(
    raw_score=score,
    query_type=query_type,
    context_length=context_length
)

Vérification basée sur les références

Compare avec des réponses de référence quand disponibles :

DEVELOPERpython
reference_score = compare_to_reference(
    answer=answer,
    reference=reference_answer,
    method="semantic_similarity"
)

# Combine avec l'évaluation LLM
final_score = 0.7 * llm_score + 0.3 * reference_score

Résultats des benchmarks

Corrélation avec les jugements humains

Testé sur 5 000 réponses RAG annotées par des humains :

AutoRAGEval atteint la corrélation la plus élevée au coût le plus bas.

Performance inter-domaines

Testé sur différents domaines :

Corrélation élevée constante sur tous les domaines.

Analyse par dimension

Corrélation par dimension :

• Fidélité : 0.97 (la plus élevée)
• Pertinence : 0.96
• Complétude : 0.92
• Concision : 0.89
• Cohérence : 0.94

Innovations clés

Évaluation avec chaîne de pensée

AutoRAGEval utilise des traces de raisonnement :

DEVELOPERpython
evaluation = evaluator.assess_with_reasoning(
    query=query,
    answer=answer,
    context=context
)

print(evaluation.reasoning)
# "La réponse cite correctement la source [1] et répond directement à
# la question. Cependant, elle omet l'aspect secondaire concernant les tarifs.
# Fidélité : 5/5, Complétude : 3/5."

print(evaluation.scores)
# {"faithfulness": 5, "relevance": 5, "completeness": 3, ...}

Le raisonnement améliore la fiabilité et la déboguabilité.

Calibration adversariale

Entraîné sur des exemples adversariaux pour détecter les cas limites :

• Hallucinations : Déclarations factuellement incorrectes
• Non-pertinence : Réponses hors sujet
• Raisonnement circulaire : La réponse reformule la question
• Réponses partielles : Informations incomplètes

L'entraînement adversarial a amélioré la robustesse de 23%.

Pondération dynamique

Les poids des dimensions s'adaptent au type de requête :

DEVELOPERpython
# Requête factuelle : prioriser la fidélité
weights = {"faithfulness": 0.5, "relevance": 0.3, "completeness": 0.2}

# Requête ouverte : prioriser la cohérence
weights = {"coherence": 0.4, "relevance": 0.3, "completeness": 0.3}

final_score = weighted_sum(dimension_scores, weights)

Implémentation

Utilisation basique

DEVELOPERpython
from autorageval import RAGEvaluator

evaluator = RAGEvaluator()

# Évaluer une seule réponse
result = evaluator.evaluate(
    query="Quelle est la politique de remboursement ?",
    answer="Vous pouvez demander un remboursement sous 30 jours...",
    context=["Extrait du document de politique 1", "Extrait du document de politique 2"]
)

print(result.overall_score)  # 0.0-1.0
print(result.dimension_scores)
# {
#   "faithfulness": 0.95,
#   "relevance": 0.90,
#   "completeness": 0.85,
#   "conciseness": 0.88,
#   "coherence": 0.92
# }

Évaluation par lots

DEVELOPERpython
# Évaluer un ensemble de test complet
test_cases = load_test_cases()

results = evaluator.evaluate_batch(
    test_cases,
    batch_size=32,
    show_progress=True
)

# Métriques agrégées
print(f"Score moyen : {np.mean([r.overall_score for r in results])}")
print(f"Cas échoués (< 0.6) : {sum(1 for r in results if r.overall_score < 0.6)}")

Avec réponses de référence

DEVELOPERpython
result = evaluator.evaluate(
    query=query,
    answer=answer,
    context=context,
    reference_answer=ground_truth,  # Optionnel
    use_reference=True
)

Cas d'usage

Intégration continue

DEVELOPERpython
# Dans le pipeline CI/CD
def test_rag_quality():
    evaluator = RAGEvaluator(threshold=0.75)

    for test_case in regression_test_set:
        result = evaluator.evaluate(**test_case)

        assert result.overall_score >= 0.75, \
            f"Dégradation de qualité : {result.overall_score}"

Tests A/B

DEVELOPERpython
# Comparer deux configurations RAG
results_a = evaluator.evaluate_batch(test_cases, system=rag_system_a)
results_b = evaluator.evaluate_batch(test_cases, system=rag_system_b)

improvement = np.mean([r.overall_score for r in results_b]) - \
              np.mean([r.overall_score for r in results_a])

print(f"La configuration B améliore la qualité de {improvement*100:.1f}%")

Surveillance en production

DEVELOPERpython
# Surveiller le trafic en direct
async def monitor_rag_quality():
    sample = await get_random_queries(n=100)

    results = evaluator.evaluate_batch(sample)

    avg_score = np.mean([r.overall_score for r in results])

    if avg_score < 0.70:  # En dessous du seuil
        alert_team("Qualité RAG dégradée", avg_score)

    log_metrics({"rag_quality": avg_score})

Analyse des coûts

Coût par évaluation

Exemple : 1000 cas de test

• Humain : $50 000-200 000
• GPT-4 : $50
• AutoRAGEval : $10

ROI

Suite de tests de régression typique :

• Cas de test : 500
• Exécutions par semaine : 10
• Évaluations annuelles : 26 000

Coût annuel :

• Humain : $1,3M - $5,2M (non réalisable)
• GPT-4 : $1 300
• AutoRAGEval : $260

Limitations

Quand l'évaluation humaine est encore nécessaire

1. Validation initiale : Vérifier AutoRAGEval sur votre domaine
2. Cas limites : Types de requêtes inhabituels
3. Dimensions subjectives : Préférences de style
4. Enjeux élevés : Décisions critiques juridiques, médicales

Recommandation : Utiliser AutoRAGEval pour 95% des évaluations, humain pour les 5% restants.

Adaptation au domaine

Peut nécessiter une calibration pour des domaines spécialisés :

DEVELOPERpython
# Calibrer sur des données spécifiques au domaine
evaluator.calibrate(
    annotated_examples=domain_examples,
    num_epochs=10
)

# Sauvegarder le modèle calibré
evaluator.save("custom_evaluator_legal.pkl")

Publication open source

Composants disponibles :

• Modèles évaluateurs : Hugging Face
• Outils de calibration : GitHub
• Jeux de données de référence : 5K exemples annotés
• Pipeline d'évaluation : Conteneur Docker

Dépôt : github.com/google-research/autorageval

Impact industriel

Les premiers adopteurs rapportent :

• Réduction de 60-80% des coûts d'évaluation
• Cycles d'itération 10x plus rapides
• Métriques de qualité cohérentes entre les équipes
• Permet la surveillance continue

Directions futures

Améliorations prévues :

1. Évaluation multimodale : Images, tableaux, graphiques
2. Évaluation en temps réel : < 100ms de latence
3. Dimensions personnalisables : Ajouter des critères spécifiques au domaine
4. Génération d'explications : Pourquoi le score a été attribué
5. Robustesse adversariale : Meilleure gestion des cas limites

Bonnes pratiques

1. Valider d'abord : Tester la corrélation sur votre domaine
2. Utiliser plusieurs métriques : Ne pas se fier à un seul score
3. Suivre dans le temps : Surveiller les tendances, pas seulement les absolus
4. Combiner avec les retours utilisateurs : Automatisé + vrais utilisateurs
5. Calibrer périodiquement : Recalibrer à mesure que votre système évolue

Conclusion

AutoRAGEval représente une avancée significative dans l'évaluation RAG, rendant l'évaluation automatisée de haute qualité accessible et abordable. Bien que ce ne soit pas un remplacement complet de l'évaluation humaine, il permet une surveillance continue de la qualité à une échelle auparavant impossible, accélérant le développement et le déploiement RAG.