Aller au contenu principal
Dernière mise à jour le

Ensembles d'évaluation (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.

Pour mesurer la qualité d'un agent IA, vous devez pouvoir définir un ensemble représentatif de requêtes ainsi que des critères qui caractérisent les réponses de haute qualité. Vous le faites en fournissant un ensemble d’évaluation. Cet article couvre les différentes options pour votre ensemble d’évaluation et certaines bonnes pratiques pour la création d’un ensemble d’évaluation.

Databricks recommande de créer un ensemble d'évaluation annoté par des humains, composé de questions représentatives et de réponses de vérité terrain. Si votre application inclut une étape de récupération, vous pouvez éventuellement fournir les documents justificatifs sur lesquels vous vous attendez à ce que la réponse soit basée. Pour vous aider à start la création d'un ensemble d'évaluation, Databricks fournit un SDK pour générer des questions synthétiques de haute qualité et des réponses de vérité terrain qui peuvent être utilisées directement dans l'Agent Evaluation, ou envoyées à des experts en la matière pour examen. Voir Synthétiser les ensembles d'évaluation.

Un bon jeu d'évaluation présente les caractéristiques suivantes :

  • Représentatif : elle doit refléter fidèlement l'éventail de requêtes que l'application rencontrera en production.
  • Complexe : Il devrait inclure des cas difficiles et variés pour tester efficacement toute l’étendue des capacités de l’application.
  • Mise à jour continue : Elle doit être mise à jour régulièrement pour refléter la façon dont l'application est utilisée et les schémas changeants du trafic de production.

Pour le schéma requis d'un jeu d'évaluation, consultez le schéma d'entrée de l'Agent Evaluation (MLflow 2).

Ensembles d'évaluations d'échantillons​

Cette section comprend des exemples simples d'ensembles d'évaluation.

Ensemble d'évaluation d'échantillon avec seulement request​

Python
eval_set = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
    }
]

Jeu d'évaluation échantillon avec request et expected_response​

Python
eval_set  = [
    {
        "request_id": "request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_response": "There's no significant difference.",
    }
]

Exemple d'ensemble d'évaluation avec request, expected_response et expected_retrieved_content​

Python
eval_set  = [
    {
        "request_id": "request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                "doc_uri": "doc_uri_1",
            },
            {
                "doc_uri": "doc_uri_2",
            },
        ],
        "expected_response": "There's no significant difference.",
    }
]

Jeu d'évaluation échantillon avec seulement request et response​

Python
eval_set = [
    {
        "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.",
    }
]

Échantillonner le jeu d'évaluation avec un request formaté arbitrairement et response​

Python
eval_set = [
    {
        "request": {"query": "Difference between", "item_a": "reduceByKey", "item_b": "groupByKey"},
        "response": {
            "differences": [
                "reduceByKey aggregates data before shuffling",
                "groupByKey shuffles all data",
                "reduceByKey is more efficient",
            ]
        }
    }
]

Exemple d'ensemble d'évaluation avec request, response et guidelines​

Python
eval_set = [
    {
        "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.",
        # 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"],
        }
    }
]

Échantillon d'ensemble d'évaluation avec request, response, guidelines et expected_facts​

Python
eval_set = [
    {
        "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.",
        "expected_facts": [
            "There's no significant difference.",
        ],
        # 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"],
        }
    }
]

Exemple d'ensemble d'évaluation avec request, response et retrieved_context​

Python
eval_set = [
    {
        "request_id": "request-id", # optional, but useful for tracking
        "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.",
        "retrieved_context": [
            {
                # In `retrieved_context`, `content` is optional, but delivers additional functionality if provided (the Databricks Context Relevance LLM judge runs to check the relevance of the provided content 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",
            },
        ],
    }
]

Échantillon d'ensemble d'évaluation avec request, response, retrieved_context et expected_facts​

Python
eval_set  = [
    {
        "request_id": "request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_facts": [
            "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, but delivers additional functionality if provided (the Databricks Context Relevance LLM judge runs to check the relevance of the provided content 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",
            },
        ],
    }
]

Ensemble d'évaluation d'échantillon avec request, response, retrieved_context, expected_facts et expected_retrieved_context​

Python
eval_set  = [
    {
        "request_id": "request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                "doc_uri": "doc_uri_2_1",
            },
            {
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_facts": [
            "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, but delivers additional functionality if provided (the Databricks Context Relevance LLM judge runs to check the relevance of the provided content 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",
            },
        ],
    }
]

Bonnes pratiques pour l'élaboration d'un ensemble d'évaluation​

  • Considérer chaque échantillon, ou groupe d'échantillons, dans l'ensemble d'évaluation comme un test unitaire. Autrement dit, chaque échantillon doit correspondre à un scénario spécifique avec un résultat attendu explicite. Par exemple, envisagez de tester des contextes plus longs, un raisonnement multi-étapes et la capacité à déduire des réponses à partir de preuves indirectes.

  • Envisagez de tester des scénarios adverses provenant d'utilisateurs malveillants.

  • Il n'existe aucune directive spécifique sur le nombre de questions à inclure dans un ensemble d'évaluation, mais les signaux clairs provenant de données de haute qualité donnent généralement de meilleurs résultats que les signaux bruités provenant de données faibles.

  • Envisagez d'inclure des exemples très difficiles, même pour les humains à répondre.

  • Que vous développiez une application à usage général ou que vous cibljez un domaine spécifique, votre application rencontrera probablement un large éventail de questions. L'ensemble d'évaluation devrait refléter cela. Par exemple, si vous créez une application pour répondre à des questions RH spécifiques, vous devez quand même envisager de tester d'autres domaines (par exemple, les opérations) pour vous assurer que l'application n'hallucine pas et ne fournit pas de réponses nuisibles.

  • Des étiquettes de haute qualité, cohérentes et générées par l'homme, sont le meilleur moyen de garantir que les valeurs de vérité terrain que vous fournissez à l'application reflètent précisément le comportement souhaité. Voici quelques étapes pour garantir des étiquettes humaines de haute qualité :

    • Agréguez les réponses (étiquettes) de plusieurs étiqueteurs humains pour la même question.
    • Assurez-vous que les instructions d'étiquetage sont claires et que les étiqueteurs humains sont cohérents.
    • Assurez-vous que les conditions du processus d'étiquetage humain sont identiques au format des requêtes soumises à l'application RAG.

  • Les étiqueteurs humains sont par nature bruyants et incohérents, par exemple en raison de différentes interprétations de la question. C'est une partie importante du processus. L'utilisation de l'étiquetage humain peut révéler des interprétations de questions que vous n'aviez pas envisagées, et qui pourraient fournir des insights sur le comportement que vous observez dans votre application.

Sur cette page