Juízes de IA integrados

Importante

Esta funcionalidade está em Pré-visualização Pública.

Este artigo aborda os detalhes de cada um dos juízes de IA que são incorporados no Mosaic AI Agent Evaluation, incluindo as métricas de entrada e saída necessárias.

Ver também:

• Como a qualidade, o custo e a latência são avaliados pelo Agent Evaluation
• Personalize os juízes de IA
• Referência de chamadas para juízes no SDK do Python

Visão geral dos avaliadores de IA

Observação

Nem todos os juízes exigem rótulos de verdade fundamental. Juízes que não exigem rótulos são úteis quando você tem apenas um conjunto de solicitações para avaliar seu agente.

Nome do juiz	Aspeto de qualidade que o juiz avalia	Entradas necessárias	Requer verdade fundamentada
global_guideline_adherence	A resposta gerada segue as diretrizes globais?	request, response, global_guidelines (do evaluator_config)	Não, mas requer global_guidelines
guideline_adherence	A resposta gerada segue as diretrizes fornecidas por pergunta?	request, response, guidelines	Sim
correctness	A resposta gerada é precisa (em comparação com a verdade básica)?	response, expected_facts[] ou expected_response	Sim
relevance_to_query	O endereço de resposta (é relevante para) o pedido do utilizador?	response, request	Não
context_sufficiency	O recuperador encontrou documentos com informações suficientes para produzir a resposta esperada?	retrieved_context, expected_response	Sim
safety	Existe conteúdo nocivo ou tóxico na resposta?	response	Não
chunk_relevance	O recuperador encontrou partes que são úteis (relevantes) para responder ao pedido do utilizador? Nota: Esta análise é aplicada separadamente a cada fragmento recuperado, produzindo uma pontuação e justificativa para cada fragmento. Essas pontuações são agregadas numa pontuação chunk_relevance/precision para cada linha que representa a % de blocos relevantes.	retrieved_context, request	Não
groundedness	A resposta gerada está fundamentada no contexto recuperado (não alucinante)?	response, trace[retrieved_context]	Não
document_recall	Quantos dos documentos relevantes conhecidos o recuperador encontrou?	retrieved_context, expected_retrieved_context[].doc_uri	Sim

Observação

Para conversas em turnos múltiplos, os juízes de IA avaliam apenas a última entrada da conversa.

AI avalia resultados

Cada juiz utilizou na avaliação as seguintes colunas:

Campo de dados	Tipo	Descrição
response/llm_judged/{judge_name}/rating	string	yes se o juiz passar, no se o juiz falhar.
response/llm_judged/{judge_name}/rationale	string	Raciocínio escrito de LLM para yes ou no.
response/llm_judged/{judge_name}/error_message	string	Se houve um erro ao calcular esta avaliação, os detalhes do erro estão aqui. Se nenhum erro, então será NULL.

Cada jurado também produzirá uma métrica agregada para toda a corrida:

Nome da métrica	Tipo	Descrição
response/llm_judged/{judge_name}/rating/average	float, [0, 1]	Percentagem de todas as avaliações que foram consideradas yes.

Adesão às diretrizes

Definição: A resposta segue as orientações fornecidas?

Requer dados de referência: Não quando se usa global_guidelines. Sim ao usar guidelinespor linha.

A adesão às diretrizes avalia se a resposta do agente segue restrições específicas ou instruções fornecidas nas diretrizes.

As diretrizes podem ser definidas de uma das seguintes maneiras:

• por linha: A resposta de uma solicitação específica deve seguir as diretrizes definidas na linha de avaliação específica.
• globalmente: Todas as respostas a qualquer solicitação devem seguir as diretrizes globais.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().
• guidelines ou global_guidelines por linha, definido na configuração.

Exemplos

Utilize a aderência às diretrizes por linha do conjunto de avaliação.

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  # 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"],
  }
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["guideline_adherence"]
      }
  }
)

Utilize a aderência às diretrizes globais de um conjunto de avaliação.

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["guideline_adherence"],
          "global_guidelines": ["The response must be in English", "The response must be concise"]
      }
  }
)

Utilize a conformidade com as diretrizes com o SDK de juiz invocável:

from databricks.agents.evals import judges

assessment = judges.guideline_adherence(
  request="What is the capital of France?",
  response="The capital of France is Paris.",
  # 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"],
  },
)
print(assessment)

O que fazer quando a resposta não segue as diretrizes?

Quando a resposta viola as diretrizes:

• Identifique qual diretriz foi violada e analise por que o agente não a cumpriu.
• Ajuste o prompt para enfatizar a adesão a diretrizes específicas ou treine novamente o modelo com exemplos adicionais que se alinham com o comportamento desejado.
• Para orientações globais, certifique-se de que estão especificadas corretamente na configuração do avaliador.

Correção

Definição: O agente respondeu com uma resposta factualmente precisa?

Requer verificação de verdade: Sim, expected_facts[] ou expected_response.

A correção compara a resposta efetiva do agente a um rótulo de verdade fundamental e é uma boa maneira de detetar erros factuais.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().
• factos_esperados ou resposta_esperada

Importante

Databricks recomenda o uso de expected_facts[] em vez de expected_response. expected_facts[] representam o conjunto mínimo de factos necessários numa resposta correta e são mais fáceis de serem selecionados por especialistas no assunto.

Se tiver de usar expected_response, deve incluir somente o conjunto mínimo de factos necessário para uma resposta correta. Se você copiar uma resposta de outra fonte, edite-a para remover qualquer texto que não seja necessário para que uma resposta seja considerada correta.

Incluir apenas as informações necessárias, e deixar de fora informações que não são estritamente exigidas na resposta, permite que a Avaliação do Agente forneça um sinal mais robusto sobre a qualidade da saída.

Exemplos

Utilize a precisão de um conjunto de avaliação.

import mlflow

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": [
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["correctness"]
      }
  }
)

Utilize a correção com o SDK do juiz invocável :

from databricks.agents.evals import judges

assessment = judges.correctness(
  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=[
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ]
)
print(assessment)

O que fazer quando uma resposta está incorreta?

Quando um agente responde com uma resposta factualmente imprecisa, você deve:

• Compreenda se algum contexto recuperado pelo agente é irrelevante ou impreciso. Para aplicações RAG, pode-se usar o Context sufficiency Judge para determinar se o contexto é suficiente para gerar o expected_facts ou expected_response.
• Se houver contexto suficiente, ajuste o prompt para incluir informações relevantes.

Relevância para a consulta

Definição: A resposta é relevante para o pedido de entrada?

Requer verdade factual: Não.

A relevância garante que a resposta do agente aborde diretamente a entrada do usuário sem se desviar em tópicos não relacionados.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().

Exemplos

Use a relevância de um conjunto de avaliação:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris."
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["relevance_to_query"]
      }
  }
)

Utilize a relevância com o SDK de julgamento chamável :

from databricks.agents.evals import judges

assessment = judges.relevance_to_query(
  request="What is the capital of France?",
  response="The capital of France is Paris."
)
print(assessment)

O que fazer quando uma resposta não é relevante?

Quando o agente fornecer uma resposta irrelevante, considere as seguintes etapas:

• Avalie a compreensão do modelo sobre a solicitação e ajuste o seu mecanismo de recuperação, os dados de treinamento ou as instruções de prompt conforme necessário.

Suficiência do contexto

Definição: Os documentos recuperados são suficientes para produzir a resposta esperada?

Requer verificação de verdade: Sim, expected_facts ou expected_response.

A suficiência de contexto avalia se os documentos recuperados fornecem todas as informações necessárias para gerar a resposta esperada.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().
• expected_facts ou expected_response. Consulte expected_facts diretrizes e expected_response diretrizes.
• retrieved_context[].content se você não tiver especificado o parâmetro model para mlflow.evaluate().

Exemplos

Utilize a suficiência de contexto de um conjunto de avaliação.

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."}
  ],
  "expected_facts": [
    "Paris"
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["context_sufficiency"]
      }
  }
)

Use a suficiência de contexto com o SDK de juízes chamável :

from databricks.agents.evals import judges

assessment = judges.context_sufficiency(
  request="What is the capital of France?",
  retrieved_context=[
    {"content": "Paris is the capital city of France."}
  ]
)
print(assessment)

O que fazer quando o contexto é insuficiente?

Quando o contexto é insuficiente:

• Melhorar o mecanismo de recuperação para garantir que todos os documentos necessários sejam incluídos.
• Modifique o prompt do modelo para fazer referência explícita a informações ausentes ou priorizar o contexto relevante.

Segurança

Definição: A resposta evita conteúdos nocivos ou tóxicos?

Requer dados reais: Não.

A segurança garante que as respostas do agente não contenham conteúdo prejudicial, ofensivo ou tóxico.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().

Exemplos

Utilize as medidas de segurança de um conjunto de avaliação.

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris."
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["safety"]
      }
  }
)

Use o SDK de juiz invocável com segurança .

from databricks.agents.evals import judges

assessment = judges.safety(
  request="What is the capital of France?",
  response="The capital of France is Paris."
)
print(assessment)

O que fazer quando a resposta não é segura?

Quando a resposta inclui conteúdo nocivo:

• Analise a solicitação para identificar se ela pode inadvertidamente levar a respostas inseguras. Modifique a entrada, se necessário.
• Refine o modelo ou o comando para evitar explicitamente a geração de conteúdo nocivo ou tóxico.
• Utilize mecanismos de segurança adicionais, como filtros de conteúdo, para intercetar respostas inseguras antes que elas cheguem ao usuário.

Fundamentação

Definição: A resposta é factualmente consistente com o contexto recuperado?

Requer validação real: Não.

A fundamentação avalia se a resposta do agente está alinhada com as informações fornecidas no contexto recuperado.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• response se você não tiver especificado o parâmetro model para mlflow.evaluate().
• retrieved_context[].content se não usares o argumento model na chamada para mlflow.evaluate().

Exemplos

Use a fundamentação de um conjunto de avaliação:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."}
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["groundedness"]
      }
  }
)

Use a base sólida com o SDK do juiz chamável :

from databricks.agents.evals import judges

assessment = judges.groundedness(
  request="What is the capital of France?",
  response="The capital of France is Paris.",
  retrieved_context=[
    {"content": "Paris is the capital city of France."}
  ]
)
print(assessment)

O que fazer quando a resposta carece de fundamento?

Quando a resposta não é fundamentada:

• Analise o contexto recuperado para garantir que ele inclua as informações necessárias para gerar a resposta esperada.
• Se o contexto for insuficiente, melhorar o mecanismo de recuperação ou o conjunto de dados para incluir documentos relevantes.
• Modifique o prompt para instruir o modelo a priorizar usando o contexto recuperado ao gerar respostas.

Relevância do bloco

Definição: As partes recuperadas são relevantes para a solicitação de entrada?

Requer dados de referência: Não.

A relevância do bloco mede se cada parte é relevante para a solicitação de entrada.

Entradas necessárias

O conjunto de avaliação de entrada deve ter as seguintes colunas:

• request
• retrieved_context[].content se você não tiver especificado o parâmetro model para mlflow.evaluate().

Se você não usar o argumento model na chamada para mlflow.evaluate(), você também deve fornecer retrieved_context[].content ou trace.

Exemplos

Este exemplo usa o juiz de relevância de bloco com uma métrica de precisão personalizada para calcular uma pontuação de precisão em nível de linha. Para obter mais detalhes sobre métricas personalizadas, consulte Métricas personalizadas

import mlflow
from mlflow.evaluation import Assessment

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."},
    {"content": "The best baguettes are in Nice."},
    {"content": "Mount Everest is  the highest mountain in the world."},
  ],
}]

def judged_precision_at_k(request, retrieved_context, k):
  judged_precisions = [judges.chunk_relevance(request, [doc]) for doc in retrieved_context[:k]]
  precision_at_k = sum([1 if judgement[0].value =='yes' else 0 for judgement in judged_precisions]) / k

  rationales = [
    f"""## Chunk ID {i+1}: `{retrieved_context[i]['doc_uri']}`
    - **{judged_precisions[i][0].value}**: `{judged_precisions[i][0].rationale}`"""
    for i in range(0, k-1)]

  return Assessment(name=f'judged_precision_at_{k}', value=precision_at_k, rationale='\n'.join(rationales))

@metric
def judged_precision_at_3(request, retrieved_context):
  k = 3
  return judged_precision_at_k(request=request, retrieved_context=retrieved_context,  k=k)

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["chunk_relevance"]
      }
  },
  extra_metrics=[judged_precision_at_3]
)

Use chunk_relevance com o SDK do avaliador chamável:

from databricks.agents.evals import judges

# NOTE: This callable judge returns an assessment per item in the retrieved context.
assessments = judges.chunk_relevance(
  request="What is the capital of France?",
  retrieved_context=[
    {"content": "Paris is the capital city of France."},
    {"content": "The chicken crossed the road."},
  ]
)
print(assessments)

O que fazer quando os pedaços recuperados são irrelevantes?

Quando partes irrelevantes são recuperadas:

• Avalie a configuração do retriever e ajuste os parâmetros para priorizar a relevância.
• Refine os dados de treinamento do recuperador para incluir exemplos mais diversos ou precisos.

Retirada de documentos

Definição: Quantos dos documentos relevantes conhecidos o sistema de recuperação encontrou?

Requer confirmação verdadeira: Sim, expected_retrieved_context[].doc_uri.

A recuperação de documentos mede a proporção de documentos relevantes de verdade fundamentada que foram recuperados em comparação com o número total de documentos relevantes em verdade fundamentada.

Entradas necessárias

O conjunto de avaliação de entrada deve ter a seguinte coluna:

• expected_retrieved_context[].doc_uri

Além disso, se não utilizares o argumento model na chamada para mlflow.evaluate(), deves também fornecer retrieved_context[].doc_uri ou trace.

Exemplos

Use a recuperação de documentos de um conjunto de avaliação:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "expected_retrieved_context": [
    {"doc_uri": "doc_123"},
    {"doc_uri": "doc_456"}
  ],
  "retrieved_context": [
    {"doc_uri": "doc_123"}
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["document_recall"]
      }
  }
)

Não existe um SDK de juiz acessível para esta métrica, pois não utiliza um juiz AI.

O que fazer quando o recall de documentos é baixo?

Quando a lembrança é baixa:

• Verifique se os dados da verdade básica refletem com precisão os documentos relevantes.
• Melhore o sistema de recuperação ou ajuste os parâmetros de pesquisa para aumentar a capacidade de recuperação.

Juízes de IA personalizados

Você também pode criar um juiz personalizado para realizar avaliações específicas para seu caso de uso.

Para obter mais detalhes, consulte:

• Crie juízes de IA a partir de diretrizes.
• Converter make_genai_metric_from_prompt em uma métrica personalizada.
• Verifique se o contexto recuperado não tem PII