Conjuntos de avaliação (MLflow 2)

Para medir a qualidade de um agente de IA, você precisa ser capaz de definir um conjunto representativo de solicitações, juntamente com critérios que caracterizem respostas de alta qualidade. Você faz isso fornecendo um conjunto de avaliação. Este artigo aborda as várias opções para o seu conjunto de avaliação e algumas práticas recomendadas para criar um conjunto de avaliação.

A Databricks recomenda a criação de um conjunto de avaliação rotulado por humanos, que consiste em perguntas representativas e respostas verdadeiras. Se o seu pedido incluir uma etapa de recuperação, pode opcionalmente fornecer os documentos comprovativos em que espera que a resposta se baseie. Para ajudá-lo a começar a criar um conjunto de avaliações, o Databricks fornece um SDK para gerar perguntas sintéticas de alta qualidade e respostas de verdade fundamental que podem ser usadas diretamente na Avaliação de Agentes ou enviadas a especialistas no assunto para revisão. Veja Sintetizar conjuntos de avaliação.

Um bom conjunto de avaliação tem as seguintes características:

• Representante: Deve refletir com precisão a gama de solicitações que o aplicativo encontrará na produção.
• Desafiador: Deve incluir casos difíceis e diversos para testar efetivamente toda a gama de recursos do aplicativo.
• Continuamente atualizado: Ele deve ser atualizado regularmente para refletir como o aplicativo é usado e os padrões de mudança do tráfego de produção.

Para obter o esquema necessário de um conjunto de avaliação, consulte Esquema de entrada de avaliação do agente (MLflow 2).

Conjuntos de amostras para avaliação

Esta secção inclui exemplos simples de conjuntos de avaliação.

Conjunto de avaliação da amostra com apenas request

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

Conjunto de avaliação da amostra com request e expected_response

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

Conjunto de avaliação de amostra com request, expected_response, e expected_retrieved_content

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.",
    }
]

Conjunto de avaliação da amostra com apenas request e response

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.",
    }
]

Conjunto de avaliação de amostra com request e response arbitrariamente formatados

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",
            ]
        }
    }
]

Conjunto de avaliação de amostra com request, response, e guidelines

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"],
        }
    }
]

Conjunto de avaliação de amostra com request, response, guidelinese expected_facts

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"],
        }
    }
]

Conjunto de avaliação de amostra com request, response, e retrieved_context

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",
            },
        ],
    }
]

Conjunto de avaliação da amostra com request, response, retrieved_context e expected_facts

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",
            },
        ],
    }
]

Conjunto de avaliação da amostra com request, response, retrieved_context, expected_facts, e expected_retrieved_context

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",
            },
        ],
    }
]

Melhores práticas para o desenvolvimento de um conjunto de avaliação

• Considere cada amostra, ou grupo de amostras, no conjunto de avaliação como um teste unitário. Ou seja, cada amostra deve corresponder a um cenário específico com um resultado esperado explícito. Por exemplo, considere testar contextos mais longos, raciocínio de múltiplas etapas e a capacidade de deduzir respostas a partir de evidências indiretas.
• Considere testar cenários adversários de usuários mal-intencionados.
• Não há uma diretriz específica sobre o número de perguntas a serem incluídas em um conjunto de avaliação, mas sinais claros de dados de alta qualidade geralmente têm um desempenho melhor do que sinais barulhentos de dados fracos.
• Considere incluir exemplos que são muito desafiadores, mesmo para humanos responderem.
• Quer esteja a criar uma aplicação de uso geral ou a visar um domínio específico, a sua aplicação irá provavelmente encontrar uma grande variedade de perguntas. O conjunto de avaliação deve refletir isso. Por exemplo, se estiver a desenvolver um aplicativo para responder a questões específicas de RH, deve ainda considerar testar outros domínios (por exemplo, operações), para assegurar que o aplicativo não gere respostas imprecisas ou prejudiciais.
• Rótulos de alta qualidade e consistentes gerados por humanos são a melhor maneira de garantir que os valores de verdade básica que você fornece ao aplicativo reflitam com precisão o comportamento desejado. Alguns passos para garantir rótulos humanos de alta qualidade são os seguintes:
  • Agregar respostas de vários etiquetadores humanos para a mesma pergunta.
  • Certifique-se de que as instruções de rotulagem são claras e que os rotuladores humanos são consistentes.
  • Assegurar que as condições para o processo de rotulagem humana são idênticas ao formato dos pedidos apresentados à aplicação RAG.
• Os rotuladores humanos são, por natureza, barulhentos e inconsistentes, por exemplo, devido a diferentes interpretações da pergunta. Trata-se de uma parte importante do processo. O uso da etiquetagem humana pode revelar interpretações de perguntas que você não havia considerado, e isso pode fornecer informações sobre o comportamento que você observa em seu aplicativo.