Aller au contenu principal
Dernière mise à jour le

Développer des évaluateurs basés sur du code

Dans l'évaluation MLflow pour GenAI, les scorers personnalisés basés sur le code vous permettent de définir des métriques d'évaluation flexibles pour votre agent ou application IA.

Lorsque vous développez des évaluateurs, vous devrez souvent itérer rapidement. Utilisez ce workflow de développeur pour mettre à jour votre évaluateur sans réexécuter l'intégralité de votre application à chaque fois :

  1. Définir les données d'évaluation
  2. Générez des traces depuis votre application.
  3. Interrogez et stockez les traces résultantes
  4. Au fur et à mesure que vous itérez sur votre scorer, évaluez à l’aide des traces stockées

Le Notebook d'exemple contient tout le code de ce tutoriel.

Prérequis : configurez MLflow et définissez votre application​

Mettez à jour mlflow[databricks] vers la dernière version pour la meilleure expérience GenAI, et installez openai car l'exemple d'application ci-dessous utilise le client OpenAI.

Python
%pip install -q --upgrade "mlflow[databricks]>=3.1" "openai>=1.0.0"
dbutils.library.restartPython()

L'appel mlflow.openai.autolog() ci-dessous instrumente automatiquement l'application avec MLflow Tracing. Les traces enregistrées serviront d’entrées aux évaluateurs pendant l’évaluation.

Python
import mlflow

mlflow.openai.autolog()

# If running outside of Databricks, set up MLflow tracking to Databricks.
# mlflow.set_tracking_uri("databricks")

# In Databricks notebooks, the experiment defaults to the notebook experiment.
# mlflow.set_experiment("/Shared/docs-demo")

Utilisez le package 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
from databricks_openai import DatabricksOpenAI

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

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

Créez une application d'assistant de questions-réponses simple pour ce tutoriel :

Python
@mlflow.trace
def sample_app(messages: list[dict[str, str]]):
    # 1. Prepare messages for the LLM
    messages_for_llm = [
        {"role": "system", "content": "You are a helpful assistant."},
        *messages,
    ]

    # 2. Call LLM to generate a response
    response = client.chat.completions.create(
        model= model_name,
        messages=messages_for_llm,
    )
    return response.choices[0].message.content


sample_app([{"role": "user", "content": "What is the capital of France?"}])

Étape 1 : Définir les données d'évaluation​

Les données d'évaluation ci-dessous sont une liste de requêtes auxquelles le LLM doit répondre. Pour cette application, les requêtes peuvent être de simples questions ou des conversations avec plusieurs messages.

Python
eval_dataset = [
    {
        "inputs": {
            "messages": [
                {"role": "user", "content": "How much does a microwave cost?"},
            ]
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "Can I return the microwave I bought 2 months ago?",
                },
            ]
        },
    },
    {
        "inputs": {
            "messages": [
                {
                    "role": "user",
                    "content": "I'm having trouble with my account.  I can't log in.",
                },
                {
                    "role": "assistant",
                    "content": "I'm sorry to hear that you're having trouble with your account.  Are you using our website or mobile app?",
                },
                {"role": "user", "content": "Website"},
            ]
        },
    },
]

Étape 2 : générer des traces depuis votre application​

Utilisez mlflow.genai.evaluate() pour générer des traces depuis l'application. Puisque evaluate() nécessite au moins un évaluateur, définissez un évaluateur de substitution pour cette génération initiale de traces :

Python
from mlflow.genai.scorers import scorer

@scorer
def placeholder_metric() -> int:
    # placeholder return value
    return 1

Exécuter l'évaluation à l'aide de l'évaluateur de remplacement :

Python
eval_results = mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=sample_app,
    scorers=[placeholder_metric]
)

Après avoir exécuté le code ci-dessus, vous devriez avoir une trace dans votre expérimentation pour chaque ligne de votre dataset d'évaluation. Les Databricks Notebooks affichent également les visualisations de trace dans le cadre des résultats des cellules. La réponse du LLM générée par le sample_app lors de l'évaluation apparaît dans le champ **Outputs** de l'interface utilisateur Trace du notebook et dans la colonne **Response** de l'interface utilisateur d'Experimentation MLflow.

Traces d'échantillons générées

Étape 3 : Interroger et stocker les traces résultantes​

Stockez les traces générées dans une variable locale. La fonction mlflow.search_traces() renvoie un DataFrame Pandas de traces.

Python
generated_traces = mlflow.search_traces(run_id=eval_results.run_id)
generated_traces

Étape 4 : Lorsque vous itérez sur votre évaluateur, appelez evaluate() en utilisant les traces stockées​

Passez le DataFrame Pandas de traces directement à evaluate() comme dataset d'entrée. Cela vous permet d'itérer rapidement sur votre métrique sans avoir à réexécuter votre application. Le code ci-dessous exécute un nouvel évaluateur sur le generated_traces précalculé.

Python
from mlflow.genai.scorers import scorer

@scorer
def response_length(outputs: str) -> int:
    # Example metric.
    # Implement your actual metric logic here.
    return len(outputs)

# Note the lack of a predict_fn parameter.
mlflow.genai.evaluate(
    data=generated_traces,
    scorers=[response_length],
)

Exemple de Notebook​

Le Notebook suivant inclut l'ensemble du code sur cette page.

Flux de travail du développeur pour les évaluateurs basés sur le code pour l'évaluation MLflow

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks

Ressources supplémentaires​

Sur cette page