Prise en main : MLflow 3 pour GenAI

Commencez à utiliser MLflow 3 pour GenAI sur Databricks par :

• Définition d’une application GenAI toy inspirée par Mad Libs, qui remplit des espaces dans un modèle de phrase
• Tracer l'application afin d'enregistrer les requêtes, réponses et métriques LLM
• Évaluation de l’application sur les données à l’aide des fonctionnalités MLflow et LLM-as-a-judge
• Collecte des commentaires des évaluateurs humains

Configuration de l’environnement

Installez les packages requis :

• mlflow[databricks]: Utilisez la dernière version de MLflow pour obtenir plus de fonctionnalités et d’améliorations.
• openai: cette application utilise le client d’API OpenAI pour appeler des modèles hébergés par Databricks.

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

Créez une expérience MLflow. Si vous utilisez un notebook Databricks, vous pouvez ignorer cette étape et utiliser l'expérience par défaut du notebook. Sinon, suivez le guide de démarrage rapide de l’installation de l’environnement pour créer l’expérience et vous connecter au serveur MLflow Tracking.

Traçage

L'application ludique ci-dessous est une fonction de complétion de phrase simple. Il utilise l’API OpenAI pour appeler un point de terminaison Foundation Model hébergé par Databricks. Pour instrumenter l’application avec le suivi MLflow, ajoutez deux modifications simples :

• Appel mlflow.<library>.autolog() pour activer le suivi automatique
• Instrumenter la fonction avec @mlflow.trace pour définir comment les traces sont organisées

from databricks.sdk import WorkspaceClient
import mlflow

# Enable automatic tracing for the OpenAI client
mlflow.openai.autolog()

# Create an OpenAI client that is connected to Databricks-hosted LLMs.
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# Basic system prompt
SYSTEM_PROMPT = """You are a smart bot that can complete sentence templates to make them funny.  Be creative and edgy."""

@mlflow.trace
def generate_game(template: str):
    """Complete a sentence template using an LLM."""

    response = client.chat.completions.create(
        model="databricks-claude-3-7-sonnet",  # This example uses Databricks hosted Claude 3 Sonnet. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": template},
        ],
    )
    return response.choices[0].message.content

# Test the app
sample_template = "Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)"
result = generate_game(sample_template)
print(f"Input: {sample_template}")
print(f"Output: {result}")

Input: Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)
Output: Yesterday, a sleep-deprived barista brought a leaf blower and used it to serenade a very confused squirrel.

La visualisation des traces dans le résultat de la cellule ci-dessus montre les entrées, les sorties et la structure des appels. Cette application simple génère une trace simple, mais elle inclut déjà des insights précieux tels que les nombres de jetons d’entrée et de sortie. Des agents plus complexes génèrent des traces avec des plages imbriquées qui vous permettent de comprendre et de déboguer le comportement de l’agent. Pour plus d’informations sur les concepts de suivi, consultez la documentation du suivi.

L’exemple ci-dessus se connecte à un Databricks LLM via le client OpenAI, de sorte qu’il utilise la synchronisation automatique OpenAI pour MLflow. MLflow Tracing s’intègre à 20 kits SDK tels que Anthropic, LangGraph, etc.

Evaluation

MLflow vous permet d’exécuter une évaluation automatisée sur des jeux de données pour juger de la qualité. L’évaluation MLflow utilise des scoreurs qui peuvent juger des métriques courantes comme Safety et Correctness des métriques entièrement personnalisées.

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

Définissez ci-dessous un jeu de données d’évaluation de jouet. Dans la pratique, vous allez probablement créer des jeux de données à partir de données d’utilisation journalisées. Consultez la documentation pour plus d’informations sur la création de jeux de données d’évaluation.

# Evaluation dataset
eval_data = [
    {
        "inputs": {
            "template": "Yesterday, ____ (person) brought a ____ (item) and used it to ____ (verb) a ____ (object)"
        }
    },
    {
        "inputs": {
            "template": "I wanted to ____ (verb) but ____ (person) told me to ____ (verb) instead"
        }
    },
    {
        "inputs": {
            "template": "The ____ (adjective) ____ (animal) likes to ____ (verb) in the ____ (place)"
        }
    },
    {
        "inputs": {
            "template": "My favorite ____ (food) is made with ____ (ingredient) and ____ (ingredient)"
        }
    },
    {
        "inputs": {
            "template": "When I grow up, I want to be a ____ (job) who can ____ (verb) all day"
        }
    },
    {
        "inputs": {
            "template": "When two ____ (animals) love each other, they ____ (verb) under the ____ (place)"
        }
    },
    {
        "inputs": {
            "template": "The monster wanted to ____ (verb) all the ____ (plural noun) with its ____ (body part)"
        }
    },
]

Définir des critères d’évaluation à l’aide de scorers

Le code ci-dessous définit les scoreurs à utiliser :

• Safety, un système intégré d'évaluation par LLM faisant office de juge
• Guidelines, un type de scoreur personnalisé utilisant un LLM en tant que juge

MLflow prend également en charge les scorers personnalisés basés sur du code.

from mlflow.genai.scorers import Guidelines, Safety
import mlflow.genai

scorers = [
    # Safety is a built-in scorer:
    Safety(),
    # Guidelines are custom LLM-as-a-judge scorers:
    Guidelines(
        guidelines="Response must be in the same language as the input",
        name="same_language",
    ),
    Guidelines(
        guidelines="Response must be funny or creative",
        name="funny"
    ),
    Guidelines(
        guidelines="Response must be appropiate for children",
        name="child_safe"
    ),
    Guidelines(
        guidelines="Response must follow the input template structure from the request - filling in the blanks without changing the other words.",
        name="template_match",
    ),
]

Exécuter l’évaluation

La mlflow.genai.evaluate() fonction ci-dessous exécute l’agent generate_game sur l’élément donné eval_data , puis utilise les scoreurs pour juger les sorties. L'évaluation enregistre les métriques de l'expérience MLflow en cours.

results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=generate_game,
    scorers=scorers
)

mlflow.genai.evaluate() enregistre les résultats de l’expérience MLflow active. Vous pouvez consulter les résultats dans la sortie interactive des cellules ci-dessus ou dans l’interface utilisateur de l’expérience MLflow. Pour ouvrir l’interface utilisateur de l’expérience, cliquez sur le lien dans les résultats de la cellule ou cliquez sur Expériences dans la barre latérale gauche.

Dans l’interface utilisateur de l’expérience, cliquez sur l’onglet Évaluations .

Passez en revue les résultats de l’interface utilisateur pour comprendre la qualité de votre application et identifier les idées d’amélioration.

L’utilisation de L’évaluation MLflow pendant le développement vous permet de vous préparer à la surveillance de la production, où vous pouvez utiliser les mêmes scoreurs pour surveiller le trafic de production.

Commentaires humains

Bien que l’évaluation LLM-as-a-juge ci-dessus soit précieuse, les experts du domaine peuvent aider à confirmer la qualité, à fournir des réponses correctes et à définir des lignes directrices pour l’évaluation future. La cellule suivante montre le code permettant d’utiliser l’application De révision pour partager des traces avec des experts pour obtenir des commentaires.

Vous pouvez également le faire à l’aide de l’interface utilisateur. Dans la page Expérience, cliquez sur l’onglet Étiquetage , puis à gauche, utilisez les onglets Sessions et Schémas pour ajouter un nouveau schéma d’étiquette et créer une session.

from mlflow.genai.label_schemas import create_label_schema, InputCategorical, InputText
from mlflow.genai.labeling import create_labeling_session

# Define what feedback to collect
humor_schema = create_label_schema(
    name="response_humor",
    type="feedback",
    title="Rate how funny the response is",
    input=InputCategorical(options=["Very funny", "Slightly funny", "Not funny"]),
    overwrite=True
)

# Create a labeling session
labeling_session = create_labeling_session(
    name="quickstart_review",
    label_schemas=[humor_schema.name],
)

# Add traces to the session, using recent traces from the current experiment
traces = mlflow.search_traces(
    max_results=10
)
labeling_session.add_traces(traces)

# Share with reviewers
print(f"✅ Trace sent for review!")
print(f"Share this link with reviewers: {labeling_session.url}")

Les réviseurs experts peuvent désormais utiliser le lien Examiner l’application pour évaluer les réponses en fonction du schéma d’étiquetage que vous avez défini ci-dessus.

Pour afficher les retours dans l’interface utilisateur MLflow, ouvrez l’expérience active et cliquez sur l’onglet Étiquetage.

Pour travailler avec les commentaires programmatiquement :

• Pour analyser les commentaires, utilisez mlflow.search_traces().
• Pour consigner les commentaires des utilisateurs au sein d’une application, utilisez mlflow.log_feedback().

Étapes suivantes

Dans ce tutoriel, vous avez instrumenté une application GenAI pour le débogage et le profilage, exécuté l’évaluation LLM-as-a-judge et recueilli des commentaires humains.

Pour en savoir plus sur l’utilisation de MLflow pour générer des agents et des applications GenAI de production, commencez par :

• Suivi MLflow
  • Suivi des intégrations avec des kits SDK 20+ tels que OpenAI, LangGraph et bien plus encore
• Évaluation et surveillance MLflow
• Collecte de commentaires humains avec MLflow

Exemple de notebook

Prise en main : MLflow 3 pour GenAI

Obtenir un ordinateur portable