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

Cet article explique comment exécuter une évaluation et afficher les résultats à mesure que vous développez votre application IA. Pour plus d’informations sur la surveillance des agents déployés, consultez Surveiller GenAI en production.

Pour évaluer un agent, vous devez indiquer un jeu d’évaluation. Au minimum, un ensemble d'évaluations est un ensemble de demandes adressées à votre application qui peuvent provenir d'un ensemble structuré de demandes d'évaluation ou d'enregistrements provenant des utilisateurs de l'agent. Pour plus d’informations, consultez Jeux d’évaluation (MLflow 2) et schéma d’entrée d’évaluation de l’agent (MLflow 2).

Exécuter une évaluation

Pour exécuter une évaluation, utilisez la méthode mlflow.evaluate() à partir de l’API MLflow, en définissant le model_type sur databricks-agent pour activer l’évaluation de l’agent sur Databricks et les juges d’IA intégrés.

L’exemple suivant indique un ensemble de consignes de réponse globales pour le juge d’IA des consignes globales qui entraînent l’échec de l’évaluation lorsque les réponses ne respectent pas les consignes. Vous n’avez pas besoin de collecter des étiquettes par demande pour évaluer votre agent avec cette approche.

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 sous l’onglet Traces de la page D’exécution MLflow :

Dans cet exemple, on exécute des juges qui n’ont pas besoin d’étiquettes « réalité du terrain » : Respect des consignes, Pertinence par rapport à la requête, Sécurité.

Si vous utilisez un agent avec un récupérateur, les juges suivants sont exécutés : Ancrage, Pertinence du bloc

mlflow.evaluate() calcule également la latence et les métriques de coût pour chaque enregistrement d’évaluation, en agrégeant les résultats sur toutes les entrées d’une exécution donnée. Il s’agit des résultats de l’évaluation. Les résultats de l’évaluation sont consignés dans la session englobante, ainsi que les informations enregistrées par d'autres commandes, comme 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 « réalité du terrain »

L’exemple suivant spécifie des étiquettes « réalité du terrain » par ligne : expected_facts et guidelines qui permettront d'exécuter respectivement les juges d’exactitude et de consignes. Les évaluations individuelles sont traitées séparément à l’aide des étiquettes « réalité du terrain » par ligne.

%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 critères que ci-dessus, en plus des éléments suivants : Correction, Pertinence, Sécurité

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

Spécifications

Les fonctionnalités IA optimisées par les partenaires doivent être activées pour votre espace de travail.

Fournir des données à un processus d'évaluation

Il existe deux manières de fournir une entrée à une exécution d’évaluation :

• Fournir des sorties précédemment générées à comparer au jeu d’évaluation. Nous vous recommandons cette option 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 indiquez un jeu d’évaluation comme illustré dans le code suivant. Le jeu d’évaluation doit comporter des sorties générées précédemment. Pour obtenir des exemples plus détaillés, consultez Exemple : Transmettre des sorties générées précédemment à Agent Evaluation.

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

• Transmettre l’application en tant qu’argument d’entrée. mlflow.evaluate() appelle l’application pour chaque entrée dans le jeu d’évaluation, puis effectue un reporting sur les évaluations de qualité et d’autres métriques pour chaque sortie générée. Nous vous recommandons cette option si votre application a été journalisée à l’aide de MLflow avec le Suivi MLflow 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 ou est déployée en dehors de Databricks.

  Cette option vous permet de spécifier le jeu d’évaluation et l’application dans l’appel de fonction, comme illustré dans le code suivant. Pour obtenir des exemples plus détaillés, consultez Exemple : Transmettre une application à Agent Evaluation.

  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 d’informations sur le schéma du jeu d’évaluation, consultez Schéma d'entrée d'Agent Evaluation (MLflow 2).

Sorties d’évaluation

Agent Evaluation retourne ses sorties à partir de mlflow.evaluate() en tant que dataframe, et les enregistre dans l’exécution de MLflow. Vous pouvez inspecter les sorties dans le notebook ou à partir de la page de l’exécution MLflow correspondante.

Consulter la sortie dans le notebook

Le code suivant illustre quelques manières passer en revue les résultats d’une exécution d’évaluation à partir de votre notebook.

%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 ainsi que tous les résultats d’évaluation spécifiques à chaque requête. Pour plus d’informations sur les résultats calculés, consultez Comment la qualité, le coût et la latence sont évalués par l’évaluation de l’agent (MLflow 2).

Passer en revue la sortie à l’aide de l’interface utilisateur MLflow

Vous pouvez également consulter les résultats de l’évaluation dans l’interface utilisateur MLflow. Pour accéder à l’interface utilisateur MLflow, cliquez sur dans la barre latérale droite du bloc-notes, puis sur l’exécution correspondante, ou cliquez sur les liens qui s’affichent dans les résultats de la cellule de bloc-notes dans laquelle vous avez exécuté mlflow.evaluate().

Passer en revue les résultats de l’évaluation pour une seule exécution

Cette section explique comment passer en revue les résultats d’é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 version 0.3.0 et ultérieure.

Pour afficher une vue d’ensemble de la qualité de chaque requête évaluée par LLM dans le jeu d’évaluation, cliquez sur l’onglet Traces de la page d'exécution MLflow.

)

Cette vue d’ensemble présente les évaluations des différents juges pour chaque demande et l’état de réussite/échec de qualité de chaque demande en fonction de ces évaluations.

Pour plus d’informations, cliquez sur une ligne dans le tableau pour afficher la page de détails de cette demande. Dans la page de détails, vous pouvez cliquer sur Afficher la vue de trace détaillée.

Résultats agrégés dans le jeu d’évaluation complet

Pour voir les résultats agrégés dans le jeu d’évaluation complet, cliquez sur l’onglet Vue d’ensemble (pour les valeurs numériques) ou Métriques du modèle (pour les 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épond aux modifications. Comparer les résultats peut vous aider à déterminer si vos modifications ont un impact positif sur la qualité ou vous aident à résoudre les problèmes liés au changement de comportement.

Utilisez la page Expérience MLflow pour comparer les résultats entre les exécutions. Pour accéder à la page Expérience, cliquez sur dans la barre latérale droite du bloc-notes, ou cliquez sur les liens qui s’affichent dans les résultats de la cellule de bloc-notes dans laquelle vous avez exécuté mlflow.evaluate().

Comparer 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 d’affichage d’évaluation des artefacts, illustrée dans la capture d’écran suivante. Une table indique chaque question du jeu d'évaluation. Utilisez les menus déroulants pour sélectionner les colonnes à afficher. Cliquez sur une cellule pour afficher son contenu complet.

Comparer les résultats agrégés entre les exécutions

Pour comparer les résultats agrégés d’une exécution ou entre différentes exécutions, cliquez sur l’icône d’affichage du graphique, illustrée dans la capture d’écran suivante. Vous pourrez ainsi visualiser les résultats agrégés de l’exécution sélectionnée et de comparer les exécutions passées.

Quels sont les juges exécutés ?

Par défaut, pour chaque enregistrement d’évaluation, Mosaic AI Agent Evaluation applique le sous-ensemble de juges qui correspond le mieux aux informations présentes dans l’enregistrement. En particulier :

• Si l’enregistrement comprend une réponse « réalité du terrain », l’évaluation de l’agent applique les juges context_sufficiency, groundedness, correctness, safety et guideline_adherence.
• Si l’enregistrement ne comprend pas de réponse « réalité du terrain », l’évaluation de l’agent applique les juges chunk_relevance, groundedness, relevance_to_query, safety et guideline_adherence.

Pour plus d’informations, consultez :

• Exécuter un sous-ensemble de juges intégrés
• Juges d’IA personnalisés
• Comment la qualité, le coût et la latence sont évalués par l’évaluation de l’agent (MLflow 2)

Pour obtenir des informations sur la confiance et la sécurité du juge LLM, consultez Informations sur les modèles qui alimentent les juges LLM.

Exemple : Transmettre une application à Agent Evaluation

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

• Modèle inscrit dans le catalogue Unity.
• Modèle MLflow journalisé dans l’expérience MLflow actuelle.
• Modèle PyFunc chargé dans le notebook.
• Fonction locale dans le notebook.
• Point de terminaison d’agent déployé.

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

Option numéro 1. Modèle inscrit dans le catalogue Unity.

%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 MLflow journalisé dans l’expérience MLflow actuelle.

%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 chargé dans le notebook.

%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 = mlflow.pyfunc.load_model(...)
    model_type="databricks-agent",
)

Option 4. Fonction locale dans le notebook.

La fonction reçoit une entrée mise en forme comme suit :

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

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

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "MLflow is a machine learning toolkit.",
      },
      ...
    }
  ],
  ...,
}

Dans l'exemple suivant, on utilise une fonction locale pour encapsuler un point de terminaison de modèle de base et l’évaluer :

  %pip install databricks-agents pandas
  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-1-405b-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. Point de terminaison d’agent déployé

Cette option ne fonctionne que lorsque vous utilisez des points de terminaison d’agent qui ont été déployés à l’aide de databricks.agents.deploy et le databricks-agents SDK version 0.8.0 ou ultérieure. Pour les modèles de base ou les versions antérieures du SDK, utilisez l’option 4 pour encapsuler le modèle dans une fonction locale.

%pip install databricks-agents pandas
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",
)

Transmettre le jeu d’évaluation lorsque l’application est incluse dans l’appel mlflow_evaluate()

Dans le code suivant, data est un DataFrame Pandas comportant votre jeu d’évaluation. Ces exemples sont simples. Pour plus d’informations, consultez le schéma d’entrée.

# 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 : Transmettre des sorties générées précédemment à Agent Evaluation

Cette section explique comment transmettre des sorties générées précédemment dans l’appel mlflow_evaluate(). Pour le schéma du jeu 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 jeu d’évaluation et les sorties générées par l’application. Ces exemples sont simples. Pour plus d’informations, consultez le schéma d’entrée.

%pip install databricks-agents pandas
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 pourvus de fonctionnalités de conversation, peuvent retourner 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 l’évaluation de l’agent.

Vous pouvez par exemple utiliser une fonction personnalisée pour traiter la réponse. L’exemple ci-dessous illustre une fonction personnalisée qui extrait le dernier message de conversation à partir d’un modèle LangGraph. Cette fonction est ensuite utilisée dans mlflow.evaluate() pour retourner une seule réponse de chaîne, que vous pouvez comparer à la colonne ground_truth.

L'exemple de code repose sur les hypothèses suivantes :

• Le modèle accepte l’entrée au format {“messages”: [{“role”: “user”, “content”: “hello”}]}.
• Le modèle retourne une liste de chaînes au format [“response 1”, “response 2”].

Le code suivant envoie les réponses concaténées au juge dans au format “response 1nresponse2”.

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 an open-source platform for managing the end-to-end machine learning (ML) lifecycle. It was developed by Databricks, a company that specializes in big data and machine learning solutions. MLflow is designed to address the challenges that data scientists and machine learning engineers face when developing, training, and deploying machine learning models.",
            "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éation d’un tableau de bord avec des métriques

Lorsque vous effectuez une itération sur la qualité de votre agent, vous pouvez partager un tableau de bord avec les parties prenantes. Ce tableau indique l'amélioration de la qualité 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 illustre comment extraire et enregistrer les valeurs de métriques à partir de l’exécution d’évaluation la plus récente dans votre notebook :

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 illustre comment extraire et enregistrer des valeurs de métrique pour les exécutions passées que vous avez enregistrées dans votre expérience MLflow.

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 désormais créer un tableau de bord à l’aide de ces données.

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

# 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 (géré par Microsoft).
• En ce qui concerne Azure OpenAI, Databricks a choisi de ne pas participer à la surveillance des abus. Aucun prompt ou réponse n’est donc stocké dans Azure OpenAI.
• Pour les espaces de travail de l’Union européenne (UE), les juges LLM utilisent des modèles hébergés dans l’UE. Toutes les autres régions utilisent des modèles hébergés aux États-Unis.
• La désactivation des fonctionnalités IA optimisées par partenaires empêche le juge LLM d’appeler des modèles optimisés par partenaires. Vous pouvez toujours utiliser des juges LLM en fournissant votre propre modèle.
• Les juges LLM sont destinés à aider les clients à évaluer leurs agents/applications GenAI, et les sorties des juges LLM ne doivent pas être utilisées pour former, améliorer ou affiner un LLM.