Aller au contenu principal
Dernière mise à jour le

Exécuter une évaluation et afficher les résultats (MLflow 2)

important

Databricks recommande d’utiliser MLflow 3 pour l’évaluation et le monitoring des applications GenAI. Cette page décrit MLflow 2 Agent Evaluation.

Cet article décrit comment exécuter une évaluation et afficher les résultats lorsque vous développez votre application d'IA. Pour en savoir plus sur la surveillance des agents déployés, consultez Surveiller les applications GenAI en production.

Pour évaluer un agent, vous devez spécifier un jeu d'évaluation. Au minimum, un jeu d'évaluation est un ensemble de requêtes adressées à votre application, provenant soit d'un ensemble organisé de requêtes d'évaluation, soit de traces d'utilisateurs de l'agent. Pour plus de détails, consultez les jeux d'évaluation (MLflow 2) et le schéma d'entrée de l'Agent Evaluation (MLflow 2).

Exécuter une évaluation​

Pour exécuter une évaluation, utilisez le mlflow.evaluate() méthode de l'API MLflow, en spécifiant model_type comme databricks-agent pour activer Agent Evaluation sur Databricks et les juges IA intégrés.

L'exemple suivant spécifie un ensemble de directives de réponse globales pour le juge IA des directives globales qui entraînent l'échec de l'évaluation lorsque les réponses ne respectent pas les directives. Vous n'avez pas besoin de recueillir des étiquettes par requête pour évaluer votre agent avec cette approche.

Python
import mlflow
from mlflow.deployments import get_deploy_client

# The guidelines below will be used to evaluate any response of the agent.
global_guidelines = {
  "rejection": ["If the request is unrelated to Databricks, the response must should be a rejection of the request"],
  "conciseness": ["If the request is related to Databricks, the response must should be concise"],
  "api_code": ["If the request is related to Databricks and question about API, the response must have code"],
  "professional": ["The response must be professional."]
}

eval_set = [{
  "request": {"messages": [{"role": "user", "content": "What is the difference between reduceByKey and groupByKey in Databricks Spark?"}]}
}, {
  "request": "What is the weather today?",
}]

# Define a very simple system-prompt agent.
@mlflow.trace(span_type="AGENT")
def llama3_agent(messages):
  SYSTEM_PROMPT = """
    You are a chatbot that answers questions about Databricks.
    For requests unrelated to Databricks, reject the request.
  """
  return get_deploy_client("databricks").predict(
    endpoint="databricks-meta-llama-3-3-70b-instruct",
    inputs={"messages": [{"role": "system", "content": SYSTEM_PROMPT}, *messages]}
  )

# Evaluate the Agent with the evaluation set and log it to the MLFlow run "system_prompt_v0".
with mlflow.start_run(run_name="system_prompt_v0") as run:
  mlflow.evaluate(
    data=eval_set,
    model=lambda request: llama3_agent(**request),
    model_type="databricks-agent",
    evaluator_config={
      "databricks-agent": {
        "global_guidelines": global_guidelines
      }
    }
  )

Les résultats sont disponibles dans l'onglet tab de la page d'exécution MLflow :

Interface utilisateur MLflow affichant les résultats de l'exemple ci-dessus

Cet exemple exécute les juges suivants qui n'ont pas besoin d'étiquettes de vérité terrain : Adhésion aux directives, Pertinence par rapport à la query, Sécurité.

Si vous utilisez un agent avec un extracteur, les juges suivants sont exécutés : Groundedness, Chunk relevance

mlflow.evaluate() calcule également les métriques de latence et de coût pour chaque enregistrement d'évaluation, en agrégeant les résultats de toutes les entrées pour une exécution donnée. Ceux-ci sont appelés les résultats d'évaluation. Les résultats d'évaluation sont enregistrés dans l'exécution englobante, ainsi que les informations enregistrées par d'autres commandes telles que les paramètres du modèle. Si vous appelez mlflow.evaluate() en dehors d'une exécution MLflow, une nouvelle exécution est créée.

Évaluer avec des étiquettes de vérité terrain​

L'exemple suivant spécifie des étiquettes de vérité terrain par ligne : expected_facts et guidelines, qui exécuteront respectivement les juges de conformité et de directives. Les évaluations individuelles sont traitées séparément en utilisant les étiquettes de vérité terrain par ligne.

Python
%pip install databricks-agents
dbutils.library.restartPython()

import mlflow
from mlflow.types.llm import ChatCompletionResponse, ChatCompletionRequest
from mlflow.deployments import get_deploy_client
import dataclasses

eval_set = [{
  "request": "What is the difference between reduceByKey and groupByKey in Databricks Spark?",
  "expected_facts": [
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ],
  "guidelines": ["The response must be concice and show a code snippet."]
}, {
  "request": "What is the weather today?",
  "guidelines": ["The response must reject the request."]
}]

# Define a very simple system-prompt agent.
@mlflow.trace(span_type="AGENT")
def llama3_agent(messages):
  SYSTEM_PROMPT = """
    You are a chatbot that answers questions about Databricks.
    For requests unrelated to Databricks, reject the request.
  """
  return get_deploy_client("databricks").predict(
    endpoint="databricks-meta-llama-3-3-70b-instruct",
    inputs={"messages": [{"role": "system", "content": SYSTEM_PROMPT}, *messages]}
  )

# Evaluate the agent with the evaluation set and log it to the MLFlow run "system_prompt_v0".
with mlflow.start_run(run_name="system_prompt_v0") as run:
  mlflow.evaluate(
    data=eval_set,
    model=lambda request: llama3_agent(**request),
    model_type="databricks-agent"
  )

Cet exemple exécute les mêmes juges que ci-dessus, en plus des suivants : Exactitude, Pertinence, Sécurité

Si vous utilisez un agent avec un récupérateur, le juge suivant est exécuté : Suffisance du contexte

Exigences​

Les fonctionnalités d'IA optimisées par des partenaires doivent être activées pour votre workspace.

Fournir des entrées à une exécution d’évaluation​

Il existe deux façons de fournir des entrées à une exécution d'évaluation :

  • **Fournissez les sorties précédemment générées à comparer à l'ensemble d'évaluation.** Cette option est recommandée si vous souhaitez évaluer les sorties d'une application déjà déployée en production, ou si vous souhaitez comparer les résultats d'évaluation entre les configurations d'évaluation.

    Avec cette option, vous spécifiez un jeu d'évaluation comme indiqué dans le code suivant. Le jeu d'évaluation doit inclure les résultats générés précédemment. Pour des exemples plus détaillés, consultez Exemple : Comment transmettre les sorties générées précédemment à l'Agent Evaluation.

    Python
    evaluation_results = mlflow.evaluate(
        data=eval_set_with_chain_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
        model_type="databricks-agent",
    )

  • Passez l'application comme argument d'entrée. mlflow.evaluate() appelle l'application pour chaque entrée de l'ensemble d'évaluation et signale les évaluations de qualité et d'autres métriques pour chaque sortie générée. Cette option est recommandée si votre application a été journalisée à l'aide de MLflow avec MLflow Tracing activé, ou si votre application est implémentée en tant que fonction Python dans un Notebook. Cette option n'est pas recommandée si votre application a été développée en dehors de Databricks ou est déployée en dehors de Databricks.

    Avec cette option, vous spécifiez l'ensemble d'évaluation et l'application dans l'appel de fonction, comme indiqué dans le code suivant. Pour des exemples plus détaillés, consultez Exemple : comment transmettre une application à l'Agent Evaluation.

    Python
    evaluation_results = mlflow.evaluate(
        data=eval_set_df,  # pandas DataFrame containing just the evaluation set
        model=model,  # Reference to the MLflow model that represents the application
        model_type="databricks-agent",
    )

Pour plus de détails sur le schéma de l'ensemble d'évaluation, consultez le schéma d'entrée d'Agent Evaluation (MLflow 2).

Sorties d'évaluation​

Agent Evaluation renvoie ses sorties de mlflow.evaluate() en tant que DataFrames et Logs également ces sorties vers l'exécution MLflow. Vous pouvez inspecter les sorties dans le Notebook ou depuis la page de l'exécution MLflow correspondante.

Revoir la sortie dans le notebook​

Le code suivant montre quelques exemples de la façon de consulter les résultats d'une exécution d'évaluation à partir de votre Notebook.

Python
%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

###
# Run evaluation
###
evaluation_results = mlflow.evaluate(..., model_type="databricks-agent")

###
# Access aggregated evaluation results across the entire evaluation set
###
results_as_dict = evaluation_results.metrics
results_as_pd_df = pd.DataFrame([evaluation_results.metrics])

# Sample usage
print(f"The percentage of generated responses that are grounded: {results_as_dict['response/llm_judged/groundedness/percentage']}")

###
# Access data about each question in the evaluation set
###

per_question_results_df = evaluation_results.tables['eval_results']

# Show information about responses that are not grounded
per_question_results_df[per_question_results_df["response/llm_judged/groundedness/rating"] == "no"].display()

Le DataFrame per_question_results_df inclut toutes les colonnes du schéma d'entrée et tous les résultats d'évaluation spécifiques à chaque requête. Pour plus de détails sur les résultats calculés, consultez Comment la qualité, le coût et la latence sont évalués par Agent Evaluation (MLflow 2).

Vérifier le résultat à l'aide de l'interface utilisateur MLflow​

Les résultats d'évaluation sont également disponibles dans l'interface utilisateur MLflow. Pour accéder à l’interface utilisateur de MLflow, cliquez sur l’icône Expérimentation Icône d'expérimentation dans la barre latérale droite du Notebook, puis sur l’exécution correspondante, ou cliquez sur les liens qui apparaissent dans les résultats de la cellule pour la cellule du Notebook dans laquelle vous avez exécuté mlflow.evaluate().

Examiner les résultats de l'évaluation pour une seule exécution​

Cette section explique comment consulter les résultats de l'évaluation d'une exécution individuelle. Pour comparer les résultats entre les exécutions, consultez Comparer les résultats d'évaluation entre les exécutions.

Vue d'ensemble des évaluations de qualité par les juges LLM​

Les évaluations de juge par requête sont disponibles dans databricks-agents à partir de la version 0.3.0.

Pour avoir un aperçu de la qualité évaluée par le LLM de chaque requête dans l'ensemble d'évaluation, cliquez sur la tab Traces sur la page d'exécution MLflow.

présentation_judges)

Cette vue d'ensemble présente les évaluations de différents juges pour chaque demande et l'état de validation/d'échec de la qualité de chaque demande en fonction de ces évaluations.

Pour plus de détails, cliquez sur une ligne du tableau pour afficher la page de détails de cette requête. Depuis la page de détails, vous pouvez cliquer sur Afficher la vue détaillée de la trace .

details_judges

Résultats agrégés sur l'ensemble complet d'évaluation​

Pour afficher les résultats agrégés sur l'ensemble complet d'évaluation, cliquez sur le tab Vue d'ensemble (pour les valeurs numériques) ou sur le tab Métriques du modèle (pour les graphiques).

métriques d'évaluation, valeurs

métriques d'évaluation, graphiques.

Comparer les résultats d’évaluation entre les exécutions​

Il est important de comparer les résultats d'évaluation entre les exécutions pour voir comment votre application agentique réagit aux changements. La comparaison des résultats peut vous aider à comprendre si vos changements ont un impact positif sur la qualité ou à résoudre les problèmes de comportement changeant.

Utiliser la page d'Experimentation MLflow pour comparer les résultats entre les exécutions. Pour accéder à la page d'Experimentation, cliquez sur l'icône d'Experimentation Icône d'expérimentation dans la barre latérale droite du Notebook, ou cliquez sur les Links qui apparaissent dans les résultats des cellules pour la cellule de Notebook dans laquelle vous avez exécuté mlflow.evaluate().

Comparez les résultats par requête entre les exécutions​

Pour comparer les données de chaque requête individuelle entre les exécutions, cliquez sur l'icône de la vue d'évaluation des artefacts, comme indiqué dans la capture d'écran suivante. Un tableau montre chaque question de l'ensemble d'évaluation. Utilisez les menus déroulants pour sélectionner les colonnes à afficher. Cliquez sur une cellule pour afficher son contenu complet.

questions individuelles dans l'ensemble d'évaluation

Comparez les résultats agrégés entre les exécutions​

Pour comparer les résultats agrégés d'une exécution ou de différentes exécutions, cliquez sur l'icône d'affichage du graphique, illustrée dans la capture d'écran suivante. Cela vous permet de visualiser les résultats agrégés pour l'exécution sélectionnée et de les comparer aux exécutions précédentes.

résultats agrégés

Quels juges sont exécutés​

Par défaut, pour chaque enregistrement d'évaluation, Agent Evaluation applique le sous-ensemble de juges qui correspond le mieux aux informations présentes dans l'enregistrement. Spécifiquement :

  • Si l’enregistrement inclut une réponse de vérité terrain, Agent Evaluation applique les juges context_sufficiency, groundedness, correctness, safety et guideline_adherence.
  • Si l'enregistrement n'inclut pas de réponse de vérité terrain, Agent Evaluation applique les juges chunk_relevance, groundedness, relevance_to_query, safety et guideline_adherence.

Pour plus de détails, consultez :

Pour les informations sur la confiance et la sécurité des juges LLM, consultez Informations sur les modèles alimentant les juges LLM.

Exemple : comment transmettre une application à Agent Evaluation​

Pour passer une application à mlflow_evaluate(), utilisez l’argument model. Il existe 5 options pour transmettre une application dans l'argument model.

  • Un modèle enregistré dans Unity Catalog.
  • Un modèle journalisé MLflow dans l'expérimentation MLflow actuelle.
  • Un modèle PyFunc qui est chargé dans le Notebook.
  • Une fonction locale dans le Notebook.
  • Un endpoint d'agent déployé.

Consultez les sections suivantes pour des exemples de code illustrant chaque option.

Option 1. Modèle enregistré dans Unity Catalog​

Python
%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "models:/catalog.schema.model_name/1"  # 1 is the version number
    model_type="databricks-agent",
)

Option 2. Modèle enregistré MLflow dans l’Expérimentation MLflow actuelle​

Python
%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `6b69501828264f9s9a64eff825371711` is the run_id, and `chain` is the artifact_path that was
# passed with mlflow.xxx.log_model(...).
# If you called model_info = mlflow.langchain.log_model() or mlflow.pyfunc.log_model(), you can access this value using `model_info.model_uri`.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "runs:/6b69501828264f9s9a64eff825371711/chain"
    model_type="databricks-agent",
)

Option 3. Modèle PyFunc qui est chargé dans le Notebook​

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = mlflow.pyfunc.load_model(...)
    model_type="databricks-agent",
)

Option 4. Fonction locale dans le notebook​

La fonction reçoit une entrée formatée comme suit :

Python
{
  "messages": [
    {
      "role": "user",
      "content": "What is MLflow?",
    }
  ],
  ...
}

La fonction doit renvoyer une valeur sous forme de chaîne de caractères simple ou de dictionnaire sérialisable (par exemple, Dict[str, Any]). Pour de meilleurs résultats avec les juges intégrés, Databricks recommande d'utiliser un format de conversation tel que ChatCompletionResponse. Par exemple :

Python
{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
      },
      ...
    }
  ],
  ...,
}

L'exemple suivant utilise une fonction locale pour encapsuler un Endpoint de modèle de fondation et l'évaluer :

Python
  %pip install databricks-agents==0.16.0 pandas==2.2.3
  dbutils.library.restartPython()

  import mlflow
  import pandas as pd

  def model(model_input):
    client = mlflow.deployments.get_deploy_client("databricks")
    return client.predict(endpoint="endpoints:/databricks-meta-llama-3-3-70b-instruct", inputs={"messages": model_input["messages"]})

  evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = model
    model_type="databricks-agent",
  )

Option 5. Endpoint de l'agent déployé​

Cette option ne fonctionne que lorsque vous utilisez des Endpoint d'agent qui ont été déployés à l'aide de databricks.agents.deploy et avec le SDK databricks-agents version 0.8.0 ou supérieure. Pour les modèles de fondation ou les anciennes versions du SDK, utilisez l'option 4 pour envelopper le modèle dans une fonction locale.

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `endpoint-name-of-your-agent` is the name of the agent endpoint.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "endpoints:/endpoint-name-of-your-agent"
    model_type="databricks-agent",
)

Comment réussir le jeu d'évaluation lorsque l'application est incluse dans l'appel mlflow_evaluate()​

Dans le code suivant, data est un DataFrame pandas contenant votre ensemble d'évaluation. Ce sont des exemples simples. Consultez le schéma d'entrée pour plus de détails.

Python
# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimal evaluation set
bare_minimum_eval_set_schema = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
    }]

# Complete evaluation set
complete_eval_set_schema = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
    }]

# Convert dictionary to a pandas DataFrame
eval_set_df = pd.DataFrame(bare_minimum_eval_set_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_df = spark_df.toPandas()

Exemple : Comment passer les sorties précédemment générées à Agent Evaluation​

Cette section décrit comment passer les sorties générées précédemment dans l'appel mlflow_evaluate(). Pour le schéma de l'ensemble d'évaluation requis, consultez Schéma d'entrée d'Agent Evaluation (MLflow 2).

Dans le code suivant, data est un DataFrame pandas avec votre ensemble d'évaluation et les sorties générées par l'application. Ce sont des exemples simples. Consultez le schéma d'entrée pour plus de détails.

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_with_app_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
    model_type="databricks-agent",
)

# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimum required input
bare_minimum_input_schema = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
    }]

# Input including optional arguments
complete_input_schema  = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
        "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
        "retrieved_context": [
            {
                # In `retrieved_context`, `content` is optional. If provided, the Databricks Context Relevance LLM Judge is executed to check the `content`'s relevance to the `request`.
                "content": "reduceByKey reduces the amount of data shuffled by merging values before shuffling.",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "groupByKey may lead to inefficient data shuffling due to sending all values across the network.",
                "doc_uri": "doc_uri_6_extra",
            },
        ],
        # You can also just pass an array of guidelines directly to guidelines, but Databricks recommends naming them with a dictionary.
        "guidelines": {
            "english": ["The response must be in English"],
            "clarity": ["The response must be clear, coherent, and concise"],
        }
    }]

# Convert dictionary to a pandas DataFrame
eval_set_with_app_outputs_df = pd.DataFrame(bare_minimum_input_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_with_app_outputs_df = spark_df.toPandas()

Exemple : utiliser une fonction personnalisée pour traiter les réponses de LangGraph​

Les agents LangGraph, en particulier ceux dotés d’une fonctionnalité de chat, peuvent renvoyer plusieurs messages pour un seul appel d’inférence. Il incombe à l’utilisateur de convertir la réponse de l’agent dans un format pris en charge par Agent Evaluation.

Une approche consiste à utiliser une fonction personnalisée pour traiter la réponse. L'exemple suivant montre une fonction personnalisée qui extrait le dernier message de chat d'un modèle LangGraph. Cette fonction est ensuite utilisée dans mlflow.evaluate() pour renvoyer une seule réponse de chaîne, qui peut être comparée à la colonne ground_truth.

L’exemple de code suppose les éléments suivants :

  • Le modèle accepte les entrées au format {“messages”: [{“role”: “user”, “content”: “hello”}]}.
  • Le modèle renvoie une liste de chaînes au format [« réponse 1 », « réponse 2 »].

Le code suivant envoie les réponses concaténées au juge dans ce format : « response 1nresponse2 »

Python
import mlflow
import pandas as pd
from typing import List

loaded_model = mlflow.langchain.load_model(model_uri)
eval_data = pd.DataFrame(
    {
        "inputs": [
            "What is MLflow?",
            "What is Spark?",
        ],
        "expected_response": [
            "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models. MLflow enables teams of all sizes to debug, evaluate, monitor, and optimize their AI applications while controlling costs and managing access to models and data. With over 30 million monthly downloads, thousands of organizations rely on MLflow each day to ship AI to production with confidence.",
            "Apache Spark is an open-source, distributed computing system designed for big data processing and analytics. It was developed in response to limitations of the Hadoop MapReduce computing model, offering improvements in speed and ease of use. Spark provides libraries for various tasks such as data ingestion, processing, and analysis through its components like Spark SQL for structured data, Spark Streaming for real-time data processing, and MLlib for machine learning tasks",
        ],
    }
)

def custom_langgraph_wrapper(model_input):
    predictions = loaded_model.invoke({"messages": model_input["messages"]})
    # Assuming `predictions` is a list of strings
    return predictions.join("\n")

with mlflow.start_run() as run:
    results = mlflow.evaluate(
        custom_langgraph_wrapper,  # Pass the function defined above
        data=eval_data,
        model_type="databricks-agent",
    )

print(results.metrics)

Créer un tableau de bord avec des métriques​

Lorsque vous itérez sur la qualité de votre agent, vous pourriez vouloir partager un tableau de bord avec vos parties prenantes qui montre comment la qualité s'est améliorée au fil du temps. Vous pouvez extraire les métriques de vos exécutions d'évaluation MLflow, enregistrer les valeurs dans une table Delta et créer un tableau de bord.

L'exemple suivant montre comment extraire et enregistrer les valeurs métriques de la dernière exécution d'évaluation dans votre Notebook :

Python
uc_catalog_name = "catalog"
uc_schema_name = "schema"
table_name = "results"

eval_results = mlflow.evaluate(
    model=logged_agent_info.model_uri, # use the logged Agent
    data=evaluation_set, # Run the logged Agent for all queries defined above
    model_type="databricks-agent", # use Agent Evaluation
)

# The `append_metrics_to_table function` is defined below
append_metrics_to_table("<identifier-for-table>", eval_results.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

L'exemple suivant montre comment extraire et enregistrer des valeurs de métrique pour les exécutions passées que vous avez enregistrées dans votre expérimentation MLflow.

Python
import pandas as pd

def get_mlflow_run(experiment_name, run_name):
  runs = mlflow.search_runs(experiment_names=[experiment_name], filter_string=f"run_name = '{run_name}'", output_format="list")

  if len(runs) != 1:
    raise ValueError(f"Found {len(runs)} runs with name {run_name}. {run_name} must identify a single run. Alternatively, you can adjust this code to search for a run based on `run_id`")

   return runs[0]

run = get_mlflow_run(experiment_name ="/Users/<user_name>/db_docs_mlflow_experiment", run_name="evaluation__2024-10-09_02:27:17_AM")

# The `append_metrics_to_table` function is defined below
append_metrics_to_table("<identifier-for-table>", run.data.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

Vous pouvez maintenant créer un tableau de bord à l'aide de ces données.

Le code suivant définit la fonction append_metrics_to_table qui est utilisée dans les exemples précédents.

Python
# Definition of `append_metrics_to_table`

def append_metrics_to_table(run_name, mlflow_metrics, delta_table_name):
  data = mlflow_metrics.copy()

  # Add identifying run_name and timestamp
  data["run_name"] = run_name
  data["timestamp"] = pd.Timestamp.now()

  # Remove metrics with error counts
  data = {k: v for k, v in mlflow_metrics.items() if "error_count" not in k}

  # Convert to a Spark DataFrame(
  metrics_df = pd.DataFrame([data])
  metrics_df_spark = spark.createDataFrame(metrics_df)

  # Append to the Delta table
  metrics_df_spark.write.mode("append").saveAsTable(delta_table_name)

Informations sur les modèles qui alimentent les juges LLM​

  • Les juges LLM peuvent utiliser des services tiers pour évaluer vos applications GenAI, y compris Azure OpenAI exploité par Microsoft.
  • Pour Azure OpenAI, Databricks s'est désabonné du monitoring des abus, de sorte qu'aucune invite ou réponse n'est stockée avec Azure OpenAI.
  • Lorsque le cross-Geo processing est désactivé, les juges LLM traitent le contenu dans le Databricks Geo du workspace. Si aucun modèle in-Geo éligible n'est disponible, le juge renvoie une erreur de restriction géographique. Lorsque le cross-Geo processing est activé, les juges LLM peuvent traiter le contenu dans d'autres Geos.
  • La désactivation des fonctionnalités d’IA optimisées par des partenaires empêche le juge LLM d'appeler des modèles optimisés par des partenaires. Vous pouvez toujours utiliser les juges LLM en fournissant votre propre modèle.
  • Les juges LLM sont destinés à aider les clients à évaluer leurs agents/applications GenAI, et les résultats des juges LLM ne doivent pas être utilisés pour entraîner, améliorer ou affiner un LLM.
Sur cette page