Juges IA intégrés (MLflow 2)

Cet article décrit les détails de chacun des juges IA intégrés à l'évaluation de l'agent IA Mosaïque, y compris les entrées requises et les métriques de sortie.

Voir aussi :

• Comment la qualité, le coût et la latence sont évalués par l’évaluation de l’agent (MLflow 2)
• Personnaliser les juges IA (MLflow 2)
• Informations de référence sur le SDK Python des juges joignables

Vue d’ensemble des juges IA

Sorties du juge IA

Chaque juge utilisé dans l’évaluation a produit en sortie les colonnes suivantes :

Chaque juge produit également une mesure globale pour l'ensemble de la course :

Respect des directives

Définition : La réponse respecte-t-elle les instructions fournies ?

Nécessite la vérité terrain : non si global_guidelines est utilisé. Oui lorsque guidelines est utilisé par ligne.

L’adhésion aux recommandations évalue si la réponse de l’agent suit des contraintes spécifiques ou des instructions fournies dans les instructions.

Les instructions peuvent être définies de l’une des manières suivantes :

• par ligne : la réponse d'une requête spécifique doit respecter les lignes directrices définies sur cette ligne d’évaluation.
• global : toutes les réponses pour toute demande doivent respecter les directives globales.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().
• guidelines par ligne ou global_guidelines défini dans la configuration.
• [Juges joignables uniquement] guidelines_context pour fournir un contexte arbitraire au juge.
  • Cette fonctionnalité nécessite databricks-agents>=0.20.0.

Exemples

Utiliser l’adhésion aux recommandations par ligne d’un jeu d’évaluation :

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

Utilisez la conformité générale aux lignes directrices à partir d’un ensemble d’évaluation.

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

Utiliser l’adhésion aux instructions avec le SDK de juge joignable :

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"],
    "grounded": ["The response must be grounded in the tool call result"],
  },
  # `guidelines_context` requires `databricks-agents>=0.20.0`
  guidelines_context={
    "tool_call_result": "{'country': 'France', 'capital': 'Paris'}",
  },
)
print(assessment)

Que faire quand la réponse ne respecte pas les directives ?

Lorsque la réponse enfreint les instructions :

• Identifiez quelle directive a été violée et analysez pourquoi l’agent n’a pas réussi à y adhérer.
• Ajustez l’invite pour mettre l’accent sur l’adhésion à des directives spécifiques ou réentraîner le modèle avec des exemples supplémentaires qui s’alignent sur le comportement souhaité.
• Pour les instructions globales, vérifiez qu’elles sont spécifiées correctement dans la configuration de l’évaluateur.

Justesse

Définition : l’agent a-t-il répondu avec une réponse factuellement précise ?

Nécessite des données de référence : Oui, expected_facts[] ou expected_response.

L'exactitude compare la réponse réelle de l'agent à une étiquette de vérité fondamentale et constitue un bon moyen de détecter les erreurs factuelles.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().
• données_prévues ou réponse_attendue

Exemples

Utiliser l’exactitude depuis un jeu d’évaluation :

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

Utiliser l’exactitude avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire quand une réponse est incorrecte ?

Lorsqu’un agent fournit une réponse factuellement inexacte, vous devriez :

• Comprendre si un contexte récupéré par l’agent n’est pas pertinent ou innacuré. Pour les applications RAG, vous pouvez utiliser le juge de suffisance de contexte pour déterminer si le contexte est suffisant pour générer le expected_facts ou le expected_response.
• S’il existe un contexte suffisant, ajustez l’invite pour inclure des informations pertinentes.

Pertinence de la requête

Définition : La réponse est-elle pertinente pour la demande d’entrée ?

Nécessite la vérité terrain : non.

La pertinence garantit que la réponse de l’agent traite directement l’entrée de l’utilisateur sans dévier dans des rubriques non liées.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().

Exemples

Utiliser la pertinence depuis un jeu d'évaluation :

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

Utiliser la pertinence avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire lorsqu’une réponse n’est pas pertinente ?

Lorsque l’agent fournit une réponse non pertinente, tenez compte des étapes suivantes :

• Évaluez la compréhension de la requête par le modèle et ajustez son récupérateur, ses données d'entraînement ou les instructions de prompt en conséquence.

Suffisance du contexte

Définition : Les documents récupérés sont-ils suffisants pour produire la réponse attendue ?

Nécessite des données de référence : Oui, expected_facts ou expected_response.

La suffisance du contexte évalue si les documents récupérés fournissent toutes les informations nécessaires pour générer la réponse attendue.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().
• expected_facts ou expected_response. Consultez expected_facts les instructions et expected_response les instructions.
• retrieved_context[].content si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().

Exemples

Utiliser la suffisance de contexte depuis un jeu d’évaluation :

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

Utiliser la suffisance de contexte avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire quand le contexte est insuffisant ?

Lorsque le contexte est insuffisant :

• Améliorez le mécanisme de récupération pour vous assurer que tous les documents nécessaires sont inclus.
• Modifiez l’invite de modèle pour référencer explicitement les informations manquantes ou hiérarchiser le contexte pertinent.

Sécurité

Définition : La réponse évite-t-elle des contenus nocifs ou toxiques ?

Nécessite la vérité terrain : non.

La sécurité garantit que les réponses de l’agent ne contiennent pas de contenu nocif, offensant ou toxique.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().

Exemples

Utiliser la sécurité depuis un jeu d’évaluation :

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

Utiliser la sécurité avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire quand la réponse est dangereuse ?

Lorsque la réponse inclut du contenu dangereux :

• Analysez la demande pour identifier si elle peut entraîner par inadvertance des réponses non sécurisées. Modifiez l’entrée si nécessaire.
• Affinez le modèle ou le paramétrez pour éviter explicitement de générer du contenu nocif ou toxique.
• Utilisez des mécanismes de sécurité supplémentaires, tels que des filtres de contenu, pour intercepter les réponses non sécurisées avant d’atteindre l’utilisateur.

Fondement

Définition : La réponse est-elle cohérente avec le contexte récupéré ?

Nécessite la vérité terrain : non.

L'ancrage évalue si la réponse de l’agent est alignée avec les informations fournies dans le contexte récupéré.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• response si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().
• retrieved_context[].content si vous n’utilisez pas l’argument model dans l’appel à mlflow.evaluate().

Exemples

Utiliser le fondement depuis un jeu d’évaluation :

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

Utiliser l’exactitude avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire quand la réponse manque de base ?

Lorsque la réponse n’est pas fondée :

• Passez en revue le contexte récupéré pour vous assurer qu’il inclut les informations nécessaires pour générer la réponse attendue.
• Si le contexte est insuffisant, améliorez le mécanisme de récupération ou le jeu de données pour inclure des documents pertinents.
• Modifiez l’invite pour indiquer au modèle de hiérarchiser l’utilisation du contexte récupéré lors de la génération de réponses.

Pertinence de bloc

Définition : Les blocs récupérés sont-ils pertinents pour la demande d’entrée ?

Nécessite la vérité terrain : non.

La pertinence du segment mesure si chaque segment est pertinent pour la demande d’entrée.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir les colonnes suivantes :

• request
• retrieved_context[].content si vous n’avez pas spécifié le model paramètre sur mlflow.evaluate().

Si vous n’utilisez pas l’argument model dans l’appel à mlflow.evaluate(), vous devez également fournir soit retrieved_context[].content, soit trace.

Exemples

Cet exemple utilise le juge de pertinence de segment avec une métrique de précision personnalisée pour calculer un score de précision au niveau des lignes. Pour plus d’informations sur les métriques personnalisées, consultez Métriques personnalisées (MLflow 2)

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]
)

Utiliser chunk_relevance avec le kit de développement logiciel (SDK) de juge joignable :

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)

Que faire quand les blocs récupérés ne sont pas pertinents ?

Lorsque des blocs non pertinents sont récupérés :

• Évaluez la configuration du récupérateur et ajustez les paramètres pour hiérarchiser la pertinence.
• Affinez les données d'entraînement du récupérateur pour y inclure des exemples plus diversifiés ou plus précis.

Document_recall

Définition : Combien de documents pertinents connus le récupérateur a-t-il trouvé ?

Nécessite la vérité terrain : oui, expected_retrieved_context[].doc_uri.

Le rappel de document mesure la proportion des documents pertinents pour la vérité terrain qui ont été récupérés par rapport au nombre total de documents pertinents pour la vérité terrain.

Entrées requises

Le jeu d’évaluation d’entrée doit avoir la colonne suivante :

• expected_retrieved_context[].doc_uri

En outre, si vous n’utilisez pas l’argument model dans l’appel de mlflow.evaluate(), vous devez également fournir retrieved_context[].doc_uri ou trace.

Exemples

Utiliser le rappel de document d’un jeu d’évaluation :

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

Il n’existe aucun SDK de juge invocable pour cette métrique puisqu'elle n’utilise pas de juge IA.

Que faire quand le rappel de document est faible ?

Lorsque le rappel est faible :

• Vérifiez que les données de vérité de base reflètent avec précision les documents pertinents.
• Améliorez le récupérateur ou ajustez les paramètres de recherche pour augmenter le rappel.

Juges d’IA personnalisés

Vous pouvez également créer un juge personnalisé pour effectuer des évaluations spécifiques à votre cas d’usage.

Pour plus d’informations, consultez :

• Créer des juges d’IA à partir de directives.
• Convertissez make_genai_metric_from_prompt en métrique personnalisée.
• Vérifiez que le contexte récupéré n’a pas d’informations d’identification personnelle