Juge RetrievalGroundedness

Le juge RetrievalGroundedness évalue si la réponse de votre application est factuellement étayée par le contexte fourni (soit à partir d'un système RAG, soit générée par un appel d'outil), aidant à détecter les hallucinations ou les déclarations non étayées par ce contexte. Ce juge LLM intégré est conçu pour évaluer les applications RAG qui doivent garantir que les réponses sont fondées sur les informations récupérées.

Pour plus de détails sur l'API, consultez la documentation MLflow.

Pour une documentation détaillée et des exemples supplémentaires, veuillez consulter la documentation MLflow RetrievalGroundedness.

Prérequis pour l'exécution des exemples

1. Installez MLflow et les packages requis.

   Python

   %pip install --upgrade "mlflow[databricks]>=3.4.0"
   dbutils.library.restartPython()

2. Créez une expérience MLflow en suivant le guide de démarrage rapide de configuration de votre environnement.

Exemples d’utilisation

Le juge RetrievalGroundedness peut être appelé directement pour une évaluation de trace unique ou utilisé avec le cadre d'évaluation de MLflow pour l'évaluation par batch.

Exigences :

• Exigences de traçabilité :
  • La trace MLflow doit contenir au moins un span avec span_type défini sur RETRIEVER
  • inputs et outputs doit être sur la portée racine de la trace

Invoke directly

Python

from mlflow.genai.scorers import retrieval_groundedness
import mlflow

# Get a trace from a previous run
trace = mlflow.get_trace("<your-trace-id>")

# Assess if the response is grounded in the retrieved context
feedback = retrieval_groundedness(trace=trace)
print(feedback)

Invoke with evaluate()

Python

import mlflow
from mlflow.genai.scorers import RetrievalGroundedness

# Evaluate traces from previous runs
results = mlflow.genai.evaluate(
    data=traces,  # DataFrame or list containing trace data
    scorers=[RetrievalGroundedness()]
)

Exemple de RAG

Voici un exemple complet montrant comment créer une application RAG et évaluer si les réponses sont fondées sur le contexte extrait :

1. Initialisez un client OpenAI pour vous connecter soit à des LLM hébergés par Databricks, soit à des LLM hébergés par OpenAI.

Databricks-hosted LLMs

Utilisez databricks-openai pour obtenir un client OpenAI qui se connecte aux LLM hébergés par Databricks. Sélectionnez un modèle parmi les modèles de fondation disponibles.

Python

import mlflow
from databricks_openai import DatabricksOpenAI

# Enable MLflow's autologging to instrument your application with Tracing
mlflow.openai.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client that is connected to Databricks-hosted LLMs
client = DatabricksOpenAI()

# Select an LLM
model_name = "databricks-claude-sonnet-4"

OpenAI-hosted LLMs

Utilisez le SDK natif OpenAI pour vous connecter aux modèles hébergés par OpenAI. Sélectionnez un modèle parmi les modèles OpenAI disponibles.

Python

import mlflow
import os
import openai

# Ensure your OPENAI_API_KEY is set in your environment
# os.environ["OPENAI_API_KEY"] = "<YOUR_API_KEY>" # Uncomment and set if not globally configured

# Enable auto-tracing for OpenAI
mlflow.openai.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client connected to OpenAI SDKs
client = openai.OpenAI()

# Select an LLM
model_name = "gpt-4o-mini"

2. Définir et évaluer votre application RAG :

   Python

   from mlflow.genai.scorers import RetrievalGroundedness
   from mlflow.entities import Document
   from typing import List
   
   
   # Define a retriever function with proper span type
   @mlflow.trace(span_type="RETRIEVER")
   def retrieve_docs(query: str) -> List[Document]:
       # Simulated retrieval based on query
       if "mlflow" in query.lower():
           return [
               Document(
                   id="doc_1",
                   page_content="MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
                   metadata={"source": "mlflow_docs.txt"}
               ),
               Document(
                   id="doc_2",
                   page_content="MLflow provides tools for experiment tracking, model packaging, and deployment.",
                   metadata={"source": "mlflow_features.txt"}
               )
           ]
       else:
           return [
               Document(
                   id="doc_3",
                   page_content="Machine learning involves training models on data.",
                   metadata={"source": "ml_basics.txt"}
               )
           ]
   
   # Define your RAG app
   @mlflow.trace
   def rag_app(query: str):
       # Retrieve relevant documents
       docs = retrieve_docs(query)
       context = "\n".join([doc.page_content for doc in docs])
   
       # Generate response using LLM
       messages = [
           {"role": "system", "content": f"Answer based on this context: {context}"},
           {"role": "user", "content": query}
       ]
   
       response = client.chat.completions.create(
           # This example uses Databricks hosted Claude.  If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
           model=model_name,
           messages=messages
       )
   
       return {"response": response.choices[0].message.content}
   
   # Create evaluation dataset
   eval_dataset = [
       {
           "inputs": {"query": "What is MLflow used for?"}
       },
       {
           "inputs": {"query": "What are the main features of MLflow?"}
       }
   ]
   
   # Run evaluation with RetrievalGroundedness scorer
   eval_results = mlflow.genai.evaluate(
       data=eval_dataset,
       predict_fn=rag_app,
       scorers=[
           RetrievalGroundedness(
               model="databricks:/databricks-gpt-oss-120b",  # Optional. Defaults to custom Databricks model.
           )
       ]
   )

Sélectionnez le LLM qui alimente le juge

Par défaut, les juges intégrés utilisent un LLM hébergé par Databricks, conçu pour effectuer des évaluations de la qualité de l'IA. Vous pouvez changer le modèle de juge en utilisant l'argument model lorsque vous créez le juge. Le modèle doit être spécifié au format <provider>:/<model-name>, où <provider> est un fournisseur de modèles compatible LiteLLM. Si vous utilisez databricks comme fournisseur de modèles, le nom du modèle est le même que le nom de l'Endpoint de diffusion.

Vous pouvez personnaliser le juge en fournissant un modèle de juge différent :

Python

from mlflow.genai.scorers import RetrievalGroundedness

# Use a different judge model
groundedness_judge = RetrievalGroundedness(
    model="databricks:/databricks-gpt-5-mini"  # Or any LiteLLM-compatible model
)

# Use in evaluation
eval_results = mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=rag_app,
    scorers=[groundedness_judge]
)

Interpréter les résultats

Le juge renvoie un objet Feedback avec :

• value : « oui » si la réponse est fondée, « non » si elle contient des hallucinations
• rationale ** ** : Explication détaillée identifiant :
  • Quelles instructions sont prises en charge par le contexte
  • Quelles instructions manquent de support (hallucinations)
  • Citations spécifiques du contexte qui étayent ou contredisent les affirmations

Ressources supplémentaires

• Évaluer la suffisance du contexte – Vérifiez si votre récupérateur fournit des informations adéquates.
• Évaluer la pertinence du contexte – Assurez-vous que les documents récupérés sont pertinents pour les queries.
• Exécuter une évaluation RAG complète – Combiner plusieurs juges pour une évaluation RAG complète