Partager via

Synthétisez des ensembles d’évaluation

  • Article

Important

Cette fonctionnalité est disponible en préversion publique .

Cette page explique comment generate de manière synthétique une évaluation de haute qualité set pour mesurer la qualité de votre agent.

La création manuelle d'une évaluation set est souvent chronophage et il est difficile de s'assurer qu'elle couvre toutes les fonctionnalités de votre agent. Mosaic AI Agent Evaluation élimine cette barrière en générant automatiquement une évaluation représentative set à partir de vos documents, vous permettant ainsi d’évaluer rapidement votre agent avec une bonne couverture des cas de test.

Generate une évaluation de set

Pour synthétiser les évaluations d’un agent qui utilise la récupération de documents, utilisez la méthode generate_evals_df qui fait partie du package Python databricks-agents. Pour plus d’informations sur l’API, consultez la référence du SDK Python .

Cette méthode vous oblige à fournir vos documents en tant que DataFrame Pandas ou un DataFrame Spark.

Le DataFrame d’entrée doit avoir les columnssuivants :

  • content: contenu du document analysé sous forme de chaîne.
  • doc_uri: URI du document.

Vous pouvez utiliser trois parameters supplémentaires pour aider à contrôler la génération :

  • num_evals: Le nombre total d'évaluations pour generate dans tous les documents. La fonction tente de distribuer des valeurs d’évaluation générées sur tous vos documents, en tenant compte de leur taille. Si num_evals est inférieur au nombre de documents, tous les documents ne seront pas couverts dans l'évaluation set.

    Pour plus d’informations sur la façon dont num_evals est utilisée pour distribuer des évaluations dans les documents, consultez Comment num_evals est utilisé.

  • agent_description: description de la tâche de l’agent

  • question_guidelines : une set de lignes directrices qui aident à guider la génération de questions synthétiques. Il s’agit d’une chaîne de forme libre qui sera utilisée pour alimenter la génération. Consultez l’exemple ci-dessous.

La sortie de generate_evals_df est un DataFrame avec les columnssuivants :

  • request_id: ID de requête unique.
  • request: requête synthétisée.
  • expected_facts : list des faits attendus dans la réponse. Cette column a un type dtype list[string].
  • expected_retrieved_context: le contexte à partir duquel cette évaluation a été synthétisée, y compris le contenu du document et le doc_uri.

Exemple

L’exemple suivant utilise generate_evals_df pour generate une évaluation set, puis appelle directement mlflow.evaluate() pour mesurer la performance de Meta Llama 3.1 sur cette évaluation set. Le modèle Llama 3.1 n’a jamais vu vos documents, il est donc probable qu’il soit halluciné. Même si, cette expérience est une bonne base de référence pour votre agent personnalisé.


%pip install mlflow mlflow[databricks] databricks-agents
dbutils.library.restartPython()

import mlflow
from databricks.agents.evals import generate_evals_df
import pandas as pd
import math

# `docs` can be a Pandas DataFrame or a Spark DataFrame with two columns: 'content' and 'doc_uri'.
docs = pd.DataFrame.from_records(
    [
      {
        'content': f"""
            Apache Spark is a unified analytics engine for large-scale data processing. It provides high-level APIs in Java,
            Scala, Python and R, and an optimized engine that supports general execution graphs. It also supports a rich set
            of higher-level tools including Spark SQL for SQL and structured data processing, pandas API on Spark for pandas
            workloads, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for incremental
            computation and stream processing.
        """,
        'doc_uri': 'https://spark.apache.org/docs/3.5.2/'
      },
      {
        'content': f"""
            Spark’s primary abstraction is a distributed collection of items called a Dataset. Datasets can be created from Hadoop InputFormats (such as HDFS files) or by transforming other Datasets. Due to Python’s dynamic nature, we don’t need the Dataset to be strongly-typed in Python. As a result, all Datasets in Python are Dataset[Row], and we call it DataFrame to be consistent with the data frame concept in Pandas and R.""",
        'doc_uri': 'https://spark.apache.org/docs/3.5.2/quick-start.html'
      }
    ]
)

agent_description = """
The Agent is a RAG chatbot that answers questions about using Spark on Databricks. The Agent has access to a corpus of Databricks documents, and its task is to answer the user's questions by retrieving the relevant docs from the corpus and synthesizing a helpful, accurate response. The corpus covers a lot of info, but the Agent is specifically designed to interact with Databricks users who have questions about Spark. So questions outside of this scope are considered irrelevant.
"""

question_guidelines = """
# User personas
- A developer who is new to the Databricks platform
- An experienced, highly technical Data Scientist or Data Engineer

# Example questions
- what API lets me parallelize operations over rows of a delta table?
- Which cluster settings will give me the best performance when using Spark?

# Additional Guidelines
- Questions should be succinct, and human-like
"""

num_evals = 10

evals = generate_evals_df(
    docs,
    # The total number of evals to generate. The method attempts to generate evals that have full coverage over the documents
    # provided. If this number is less than the number of documents, is less than the number of documents,
    # some documents will not have any evaluations generated. See "How num_evals is used" below for more details.
    num_evals=num_evals,
    # A set of guidelines that help guide the synthetic generation. These are free-form strings that will be used to prompt the generation.
    agent_description=agent_description,
    question_guidelines=question_guidelines
)

display(evals)

# Evaluate the model using the newly generated evaluation set. After the function call completes, click the UI link to see the results. You can use this as a baseline for your agent.
results = mlflow.evaluate(
  model="endpoints:/databricks-meta-llama-3-1-405b-instruct",
  data=evals,
  model_type="databricks-agent"
)

# Note: To use a different model serving endpoint, use the following snippet to define an agent_fn. Then, specify that function using the `model` argument.
# MODEL_SERVING_ENDPOINT_NAME = '...'
# def agent_fn(input):
#   client = mlflow.deployments.get_deploy_client("databricks")
#   return client.predict(endpoint=MODEL_SERVING_ENDPOINT_NAME, inputs=input)

Dans l’exemple de sortie suivant, les columnsrequest_id et les expected_retrieved_context ne sont pas affichés.

demande expected_facts
Qu’est-ce que Spark SQL utilisé dans Apache Spark ? - Spark SQL est utilisé pour le traitement SQL dans Apache Spark.
- Spark SQL est utilisé pour le traitement structuré des données dans Apache Spark.
Quels sont les outils de haut niveau pris en charge par Apache Spark et quels objectifs servent-ils ? - Spark SQL pour le traitement des données SQL et structurées.
- API Pandas sur Spark pour la gestion des charges de travail avec Pandas.
- MLlib pour le Machine Learning.
- GraphX pour le traitement de graphe.
- Structured Streaming pour le calcul incrémentiel et le traitement de flux.
Quelle est l’abstraction principale dans Spark et comment les jeux de données sont-ils représentés en Python ? - L’abstraction principale dans Spark est un jeu de données.
- Dans Python, les jeux de données de Spark sont appelés DataFrame.
- Dans Python, les jeux de données sont représentés en tant que jeu de données[ligne]
Pourquoi tous les jeux de données en Python sont-ils appelés DataFrames dans Spark ? - Les jeux de données en Python sont appelés DataFrames dans Spark pour maintenir la cohérence avec le concept de trame de données..
- Le concept de trame de données est standard dans Pandas et R.

comment num_evals est utilisé

num_evals correspond au nombre total d’évaluations générées pour la set de documents. La fonction distribue ces évaluations dans les documents tout en essayant de tenir compte des différences de taille des documents. Autrement dit, il tente de maintenir environ le même nombre de questions par page dans le document set.

Si num_evals est inférieur au nombre de documents, certains documents n’ont pas d’évaluations générées. Le DataFrame renvoyé par la fonction inclut une column avec les source_doc_ids utilisées pour generate évaluations. Vous pouvez utiliser cette column pour join revenir à votre DataFrame d’origine afin de generate les évaluations pour les documents ignorés.

Pour vous aider à estimer la num_evals pour une couverture souhaitée, nous fournissons la méthode estimate_synthetic_num_evals :


from databricks.agents.evals import estimate_synthetic_num_evals

num_evals = estimate_synthetic_num_evals(
  docs, # Same docs as before.
  eval_per_x_tokens = 1000 # Generate 1 eval for every x tokens to control the coverage level.
)

Créer un cahier d'exemple pour l'évaluation synthétique set

Consultez le notebook suivant pour un exemple de code permettant de créer une évaluation synthétique set.

Exemple de cahier d’évaluations synthétiques

Get notebook

Démonstration de 10 minutes pour améliorer les performances de l’agent

Le notebook d'exemple suivant montre comment améliorer la qualité de votre agent. Elle comprend les étapes suivantes :

  1. Generate un jeu de données d’évaluation synthétique.
  2. Générez et évaluez un agent de référence.
  3. Comparez l'agent de référence à travers plusieurs configurations, telles que différentes invites, et modèles fondamentaux, afin de trouver le juste équilibre entre la qualité, le coût et la latence.
  4. Déployez l’agent sur une interface utilisateur web pour permettre aux parties prenantes de tester et de fournir des commentaires supplémentaires.

Améliorer les performances de l’agent en utilisant le carnet de données synthétiques

Get notebook

Informations sur les modèles qui alimentent les données synthétiques

  • Les données synthétiques peuvent utiliser des services tiers pour évaluer vos applications GenAI, y compris Azure OpenAI géré par Microsoft.
  • Pour Azure OpenAI, Databricks a refusé l’analyse des abus afin qu’aucune invite ou réponse ne soit stockée avec Azure OpenAI.
  • Pour les espaces de travail de l’Union européenne (UE), les données synthétiques 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 d’assistance d’IA Azure empêche l'appel des modèles alimentés par l’IA Azure par le service de données synthétiques.
  • Les données envoyées au service de données synthétiques ne sont pas utilisées pour l’entraînement de modèle.
  • Les données synthétiques sont destinées à aider les clients à évaluer leurs applications d’agent et les sorties ne doivent pas être utilisées pour entraîner, améliorer ou affiner un LLM.