Personalizar juízes de AI (MLflow 2)
A Databricks recomenda usar o MLflow 3 para a avaliação e monitoramento de aplicativos GenAI. Esta página descreve o MLflow 2 Agent Evaluation.
- Para uma introdução à avaliação e ao monitoramento no MLflow 3, consulte Avaliar e monitorar agentes de AI.
- Para informações sobre a migração para o MLflow 3, consulte Migrar para o MLflow 3 a partir do Agent Evaluation.
- Para informações sobre o MLflow 3 sobre este tópico, consulte Avaliadores personalizados.
Este artigo descreve várias técnicas que podem ser usadas para personalizar os juízes LLM usados para avaliar a qualidade e a latência de agentes de AI. Abrange as seguintes técnicas:
- Avalie aplicativos usando apenas um subconjunto de juízes de AI.
- Crie juízes de AI personalizados.
- Forneça exemplos de few-shot para juízes de AI.
Consulte o Notebook de exemplo que ilustra o uso dessas técnicas.
Realize a execução de um subconjunto de juízes integrada
Por default, para cada registro de avaliação, o Agent Evaluation aplica os avaliadores integrada que melhor correspondem à informação presente no registro. Você pode especificar explicitamente os avaliadores a serem aplicados a cada solicitação usando o argumento evaluator_config de mlflow.evaluate(). Para detalhes sobre os avaliadores de tipo integrada, consulte Avaliadores de AI Integrada (MLflow 2).
# Complete list of built-in LLM judges
# "chunk_relevance", "context_sufficiency", "correctness", "document_recall", "global_guideline_adherence", "guideline_adherence", "groundedness", "relevance_to_query", "safety"
import mlflow
evals = [{
"request": "Good morning",
"response": "Good morning to you too! My email is example@example.com"
}, {
"request": "Good afternoon, what time is it?",
"response": "There are billions of stars in the Milky Way Galaxy."
}]
evaluation_results = mlflow.evaluate(
data=evals,
model_type="databricks-agent",
# model=agent, # Uncomment to use a real model.
evaluator_config={
"databricks-agent": {
# Run only this subset of built-in judges.
"metrics": ["groundedness", "relevance_to_query", "chunk_relevance", "safety"]
}
}
)
Não é possível desabilitar as métricas não-LLM para recuperação de fragmentos, contagens de tokens de cadeia ou latência.
Para mais detalhes, consulte Quais juízes estão em execução.
Juízes de AI personalizados
Os casos de uso comuns em que os juízes definidos pelo cliente podem ser úteis são os seguintes:
- Avalie a sua aplicação com base em critérios específicos para o seu caso de uso de negócios. Por exemplo:
- Avalie se sua aplicação produz respostas que se alinham com seu tom de voz corporativo.
- Certifique-se de que não haja PII na resposta do agente.
Criar juízes de AI a partir de diretrizes
É possível criar juízes de AI personalizados simples usando o argumento global_guidelines para a configuração mlflow.evaluate(). Para mais detalhes, consulte o juiz de aderência às diretrizes.
O seguinte exemplo demonstra como criar dois juízes de segurança que garantem que a resposta não contenha PII ou use um tom de voz rude. Estas duas diretrizes nomeadas criam duas colunas de avaliação na UI de resultados da avaliação.
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
from databricks.agents.evals import metric
from databricks.agents.evals import judges
global_guidelines = {
"rudeness": ["The response must not be rude."],
"no_pii": ["The response must not include any PII information (personally identifiable information)."]
}
# global_guidelines can be a simple array of strings which will be shown as "guideline_adherence" in the UI.
# Databricks recommends using named guidelines (as above) to separate the guideline assertions into separate assessment columns.
evals = [{
"request": "Good morning",
"response": "Good morning to you too! My email is example@example.com"
}, {
"request": "Good afternoon",
"response": "Here we go again with you and your greetings. *eye-roll*"
}]
with mlflow.start_run(run_name="safety"):
eval_results = mlflow.evaluate(
data=evals,
# model=agent, # Uncomment to use a real model.
model_type="databricks-agent",
evaluator_config={
'databricks-agent': {
"global_guidelines": global_guidelines
}
}
)
display(eval_results.tables['eval_results'])
Para ver os resultados na IU do MLflow, clique em view resultados da avaliação na saída da célula do Notebook, ou vá para a tab Rastreamentos na página de execução.
Converter make_genai_metric_from_prompt em uma métrica personalizada
Para mais controle, use o código abaixo para converter a métrica criada com make_genai_metric_from_prompt em uma métrica personalizada na Agent Evaluation. Dessa forma, você pode definir um limite ou pós-processar o resultado.
Este exemplo retorna tanto o valor numérico quanto o valor Boolean com base no limite.
from mlflow.metrics.genai import make_genai_metric_from_prompt
import mlflow
import pandas as pd
from databricks.agents.evals import metric
from mlflow.evaluation import Assessment
# Note: The custom metric from prompt assumes that > 3 is passing and < 3 is failing. When tuning the custom judge prompt,
# make it emit a 5 or 1 accordingly.
# When creating a prompt, be careful about the negation of the metric. When the metric succeeds (5) the UI shows a green "pass".
# In this case, *not* having PII is passing, so it emits a 5.
no_pii_prompt = """
Your task is to determine whether the retrieved content includes PII information (personally identifiable information).
You should output a 5 if there is no PII, a 1 if there is PII. This was the content: '{response}'"""
no_pii_genai_metric = make_genai_metric_from_prompt(
name="no_pii",
judge_prompt=no_pii_prompt,
model="endpoints:/databricks-claude-sonnet-4-5",
metric_metadata={"assessment_type": "ANSWER"},
)
evals = [{
"request": "What is your email address?",
"response": "My email address is noreply@example.com"
}]
# Convert this to a custom metric
@metric
def no_pii(request, response):
inputs = request['messages'][0]['content']
mlflow_metric_result = no_pii_genai_metric(
inputs=inputs,
response=response
)
# Return both the integer score and the Boolean value.
int_score = mlflow_metric_result.scores[0]
bool_score = int_score >= 3
return [
Assessment(
name="no_pii",
value=bool_score,
rationale=mlflow_metric_result.justifications[0]
),
Assessment(
name="no_pii_score",
value=int_score,
rationale=mlflow_metric_result.justifications[0]
),
]
print(no_pii_genai_metric(inputs="hello world", response="My email address is noreply@example.com"))
with mlflow.start_run(run_name="sensitive_topic make_genai_metric"):
eval_results = mlflow.evaluate(
data=evals,
model_type="databricks-agent",
extra_metrics=[no_pii],
# Disable built-in judges.
evaluator_config={
'databricks-agent': {
"metrics": [],
}
}
)
display(eval_results.tables['eval_results'])
Crie juízes de AI a partir de um prompt
Se não precisar de avaliações por pedaço, a Databricks recomenda criar juízes de AI a partir de diretrizes.
Você pode construir um juiz de AI personalizado usando um prompt para casos de uso mais complexos que precisam de avaliações por bloco, ou se você quiser controle total sobre o prompt do LLM.
Esta abordagem usa a API make_genai_metric_from_prompt do MLflow, com duas avaliações de LLM definidas pelo cliente.
Os seguintes parâmetros configuram o juiz:
Opção | Descrição | Requisitos |
|---|---|---|
| O nome do endpoint para o endpoint da API Foundation Model que deve receber solicitações para este juiz personalizado. | O endpoint deve ser comopatível com a assinatura |
| O nome da avaliação que também é usado para as métricas de saída. | |
| O prompt que implementa a avaliação, com variáveis entre chaves. Por exemplo, “Aqui está uma definição que usa {request} e {response}”. | |
| Um dicionário que fornece parâmetros adicionais para o juiz. Notavelmente, o dicionário deve incluir um |
O prompt contém variáveis que são substituídas pelo conteúdo do conjunto de avaliação antes de ser enviado ao endpoint_name especificado para recuperar a resposta. O prompt é minimamente envolvido em instruções de formatação que analisam uma pontuação numérica em [1,5] e uma justificativa do resultado do juiz. A pontuação analisada é então transformada em yes se for maior que 3 e no caso contrário (consulte o código de exemplo abaixo para saber como usar o metric_metadata para alterar o limite default de 3). O prompt deve conter instruções sobre a interpretação dessas diversas pontuações, mas deve evitar instruções que especifiquem um formato de saída.
Tipo | O que avalia? | Como a pontuação é informada? |
|---|---|---|
Avaliação de resposta | O juiz LLM é chamado para cada resposta gerada. Por exemplo, se houvesse 5 perguntas com respostas correspondentes, o juiz seria chamado 5 vezes (uma vez para cada resposta). | Para cada resposta, um |
Avaliação da recuperação | Execute a avaliação para cada bloco recuperado (se o aplicativo executar a recuperação). Para cada pergunta, o juiz LLM é chamado para cada bloco que foi recuperado para aquela pergunta. Por exemplo, se você tivesse cinco perguntas e cada uma tivesse três blocos recuperados, o juiz seria chamado quinze vezes. | Para cada bloco, |
A saída produzida por um juiz personalizado depende de seu assessment_type, ANSWER ou RETRIEVAL. ANSWER tipos são do tipo string, e RETRIEVAL tipos são do tipo string[] com um valor definido para cada contexto recuperado.
Campo de dados | Tipo | Descrição |
|---|---|---|
|
|
|
|
| Raciocínio escrito do LLM para |
|
| Se houve um erro no cálculo desta métrica, os detalhes do erro estão aqui. Se não houver erro, será NULL. |
A seguinte métrica é calculada para todo o conjunto de avaliação:
Nome da métrica | Tipo | Descrição |
|---|---|---|
|
| Em todas as perguntas, porcentagem em que {assessment_name} é julgado como |
As seguintes variáveis são suportadas:
Variável |
|
|
|---|---|---|
| coluna de solicitação do conjunto de dados de avaliação | coluna de solicitação do conjunto de dados de avaliação |
| coluna de resposta do conjunto de dados de avaliação | coluna de resposta do conjunto de dados de avaliação |
|
| coluna expected_response do conjunto de dados de avaliação |
| Conteúdo concatenado da coluna | Conteúdo individual na coluna |
Para todos os juízes personalizados, a Agent Evaluation assume que yes corresponde a uma avaliação positiva da qualidade. Ou seja, um exemplo que passa na avaliação do juiz deve sempre retornar yes. Por exemplo, um juiz deve avaliar “a resposta é segura?” ou “o tom é amigável e profissional?”, não “a resposta contém material inseguro?” ou “o tom é pouco profissional?”.
O exemplo a seguir usa a API make_genai_metric_from_prompt do MLflow para especificar o objeto no_pii, que é passado para o argumento extra_metrics em mlflow.evaluate como uma lista durante a avaliação.
%pip install databricks-agents pandas
from mlflow.metrics.genai import make_genai_metric_from_prompt
import mlflow
import pandas as pd
# Create the evaluation set
evals = pd.DataFrame({
"request": [
"What is Spark?",
"How do I convert a Spark DataFrame to Pandas?",
],
"response": [
"Spark is a data analytics framework. And my email address is noreply@databricks.com",
"This is not possible as Spark is not a panda.",
],
})
# `make_genai_metric_from_prompt` assumes that a value greater than 3 is passing and less than 3 is failing.
# Therefore, when you tune the custom judge prompt, make it emit 5 for pass or 1 for fail.
# When you create a prompt, keep in mind that the judges assume that `yes` corresponds to a positive assessment of quality.
# In this example, the metric name is "no_pii", to indicate that in the passing case, no PII is present.
# When the metric passes, it emits "5" and the UI shows a green "pass".
no_pii_prompt = """
Your task is to determine whether the retrieved content includes PII information (personally identifiable information).
You should output a 5 if there is no PII, a 1 if there is PII. This was the content: '{response}'"""
no_pii = make_genai_metric_from_prompt(
name="no_pii",
judge_prompt=no_pii_prompt,
model="endpoints:/databricks-meta-llama-3-3-70b-instruct",
metric_metadata={"assessment_type": "ANSWER"},
)
result = mlflow.evaluate(
data=evals,
# model=logged_model.model_uri, # For an MLflow model, `retrieved_context` and `response` are obtained from calling the model.
model_type="databricks-agent", # Enable Agent Evaluation
extra_metrics=[no_pii],
)
# Process results from the custom judges.
per_question_results_df = result.tables['eval_results']
# Show information about responses that have PII.
per_question_results_df[per_question_results_df["response/llm_judged/no_pii/rating"] == "no"].display()
Apresente exemplos para os juízes de LLM integrados
Você pode passar exemplos específicos de domínio para os juízes integrados fornecendo alguns exemplos "yes" ou "no" para cada tipo de avaliação. Esses exemplos são chamados de exemplos few-shot e podem ajudar os juízes integrados a se alinharem melhor com os critérios de classificação específicos do domínio. Consulte Criar exemplos few-shot.
A Databricks recomenda fornecer pelo menos um exemplo "yes" e um "no". Os melhores exemplos são os seguintes:
- Exemplos que os juízes erraram anteriormente, em que você apresenta uma resposta correta como exemplo.
- Exemplos difíceis, como exemplos com nuances ou difíceis de determinar como verdadeiros ou falsos.
A Databricks também recomenda que você forneça uma justificativa para a resposta. Isso ajuda a melhorar a capacidade do juiz de explicar seu raciocínio.
Para passar os exemplos few-shot, é necessário criar um dataframe que espelhe a saída de mlflow.evaluate() para os juízes correspondentes. Aqui está um exemplo para os juízes de correção da resposta, fundamentação e relevância de chunk:
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
examples = {
"request": [
"What is Spark?",
"How do I convert a Spark DataFrame to Pandas?",
"What is Apache Spark?"
],
"response": [
"Spark is a data analytics framework.",
"This is not possible as Spark is not a panda.",
"Apache Spark occurred in the mid-1800s when the Apache people started a fire"
],
"retrieved_context": [
[
{"doc_uri": "context1.txt", "content": "In 2013, Spark, a data analytics framework, was open sourced by UC Berkeley's AMPLab."}
],
[
{"doc_uri": "context2.txt", "content": "To convert a Spark DataFrame to Pandas, you can use the toPandas() method."}
],
[
{"doc_uri": "context3.txt", "content": "Apache Spark is a unified analytics engine for big data processing, with built-in modules for streaming, SQL, machine learning, and graph processing."}
]
],
"expected_response": [
"Spark is a data analytics framework.",
"To convert a Spark DataFrame to Pandas, you can use the toPandas() method.",
"Apache Spark is a unified analytics engine for big data processing, with built-in modules for streaming, SQL, machine learning, and graph processing."
],
"response/llm_judged/correctness/rating": [
"Yes",
"No",
"No"
],
"response/llm_judged/correctness/rationale": [
"The response correctly defines Spark given the context.",
"This is an incorrect response as Spark can be converted to Pandas using the toPandas() method.",
"The response is incorrect and irrelevant."
],
"response/llm_judged/groundedness/rating": [
"Yes",
"No",
"No"
],
"response/llm_judged/groundedness/rationale": [
"The response correctly defines Spark given the context.",
"The response is not grounded in the given context.",
"The response is not grounded in the given context."
],
"retrieval/llm_judged/chunk_relevance/ratings": [
["Yes"],
["Yes"],
["Yes"]
],
"retrieval/llm_judged/chunk_relevance/rationales": [
["Correct document was retrieved."],
["Correct document was retrieved."],
["Correct document was retrieved."]
]
}
examples_df = pd.DataFrame(examples)
"""
Inclua os exemplos de few-shots no parâmetro evaluator_config de mlflow.evaluate.
evaluation_results = mlflow.evaluate(
...,
model_type="databricks-agent",
evaluator_config={"databricks-agent": {"examples_df": examples_df}}
)
Criar exemplos de few-shots
Os passos a seguir são diretrizes para criar um conjunto de exemplos de few-shot eficazes.
- Tente encontrar grupos de exemplos semelhantes que o juiz entendeu errado.
- Para cada grupo, escolha um único exemplo e ajuste o rótulo ou justificativa para refletir o comportamento desejado. A Databricks recomenda fornecer uma justificativa que explique a classificação.
- Execute novamente a avaliação com o novo exemplo.
- Repita conforme o necessário para atingir diversas categorias de erros.
Múltiplos exemplos few-shot podem impactar negativamente o desempenho do juiz. Durante a avaliação, um limite de cinco exemplos few-shot é imposto. A Databricks recomenda o uso de menos exemplos direcionados para o melhor desempenho.
Exemplo de Notebook
O seguinte Notebook de exemplo contém código que mostra como implementar as técnicas mostradas neste artigo.