Aller au contenu principal
Dernière mise à jour le

Juges personnalisés

Les juges personnalisés MLflow sont des évaluateurs basés sur des LLM qui vous permettent d’utiliser le langage naturel pour définir des critères de notation complexes et nuancés pour les agents.

Bien que les juges LLM intégrés de MLflow offrent d’excellents points de départ pour les dimensions de qualité courantes, les juges personnalisés créés à l’aide de make_judge() vous donnent un contrôle total sur les critères d’évaluation.

Invites et variables de Template​

Pour créer un juge, vous fournissez un prompt avec des instructions en langage naturel sur la manière d'évaluer la qualité de votre agent. make_judge() accepte les variables de template pour accéder aux entrées, sorties, sorties ou comportements attendus de l'agent, et même aux traces complètes.

Vos instructions doivent inclure au moins une variable de template, mais vous n'avez pas besoin de toutes les utiliser.

  • {{ inputs }} - Données d'entrée fournies à l'agent
  • {{ outputs }} - Données de sortie générées par votre agent
  • {{ expectations }} - Vérités terrain ou résultats attendus
  • {{ trace }} - La trace d'exécution complète de votre agent

Ce sont les seules variables autorisées. Les variables personnalisées comme {{ question }} généreront des erreurs de validation afin de garantir un comportement cohérent et d'éviter les problèmes d'injection de Template.

Juges basés sur les champs​

Les juges personnalisés les plus simples attribuent un score à une interaction unique à partir de ses champs : la requête ({{ inputs }}), la réponse de l’agent ({{ outputs }}) et, lorsque vous disposez d’une vérité de référence, la réponse attendue ({{ expectations }}). Utilisez-les pour évaluer la qualité des réponses sans inspecter les étapes internes de l’agent.

L’exemple suivant définit un juge qui vérifie si la réponse correspond à la réponse attendue :

Python
from mlflow.genai.judges import make_judge
from typing import Literal

# Field-based judge: compare the response to the expected answer
correctness_judge = make_judge(
    name="answer_correctness",
    instructions=(
        "Given the request in {{ inputs }}, decide whether the response in "
        "{{ outputs }} matches the expected answer in {{ expectations }}.\n\n"
        "Return 'correct' only if the response conveys the same facts as the "
        "expected answer. Otherwise, return 'incorrect'."
    ),
    feedback_value_type=Literal["correct", "incorrect"],
)

Contrairement aux juges basés sur les traces, les juges basés sur les champs ne nécessitent pas de spécifier un model ; ils s'exécutent sur le modèle de juge default. Omettez {{ expectations }} lorsque vous ne disposez pas de vérité terrain, par exemple pour noter le ton ou le format à partir des entrées et des sorties seules.

Juges basés sur les traces​

Les juges basés sur les traces analysent les traces d'exécution pour comprendre ce qui s'est passé pendant l'exécution de l'agent. Ils explorent de manière autonome les traces à l'aide des outils du protocole de contexte de modèle (MCP) et peuvent :

  • Valider les modèles d'utilisation des outils
  • Identifiez les goulots d'étranglement des performances
  • Rechercher les échecs d'exécution
  • Vérifier les workflows multi-étapes

L'exemple suivant définit un juge qui évalue l'exactitude de l'appel d'outil en analysant les traces :

Python
from mlflow.genai.judges import make_judge
from typing import Literal

# Agent judge for tool calling correctness
tool_usage_judge = make_judge(
    name="tool_usage_validator",
    instructions=(
        "Analyze the {{ trace }} to verify correct tool usage.\n\n"
        "Check that the agent selected appropriate tools for the user's request "
        "and called them with correct parameters."
    ),
    feedback_value_type=Literal["correct", "incorrect"],
    model="databricks:/databricks-gpt-5-mini"  # Required for trace-based judges
)

Pour que les juges basés sur les traces puissent analyser la trace complète, l'argument model doit être spécifié dans make_judge().

Pour un tutoriel complet, consultez Créez un juge personnalisé à l'aide de make_judge().

Exigences du modèle pour les juges basés sur les traces​

Les juges basés sur les traces requièrent un modèle capable d'analyse de traces. Le modèle peut être servi par :

Modèles recommandés :

  • databricks:/databricks-gpt-5-mini
  • databricks:/databricks-gpt-5
  • databricks:/databricks-gpt-oss-120b
  • databricks:/databricks-claude-opus-4-5

Bonnes pratiques pour la rédaction des instructions du juge​

Soyez précis quant au format de sortie attendu. Vos instructions doivent spécifier clairement le format que le juge doit renvoyer :

  • Réponses catégorielles : répertorier des valeurs spécifiques (par exemple, « fully_resolved », « partially_resolved », « needs_follow_up »)
  • Réponses booléennes : Indiquez explicitement que le juge doit retourner true ou false
  • Scores numériques : spécifiez la plage de notation et la signification de chaque score.

Décomposez les évaluations complexes. Pour les tâches d'évaluation complexes, structurez vos instructions en sections claires :

  • Quoi évaluer
  • Quelles informations examiner
  • Comment rendre le jugement
  • Quel format renvoyer

Aligner les juges avec les experts humains​

Le juge de base est un point de départ. Au fur et à mesure que vous recueillez des commentaires d'experts sur les sorties de votre application, vous pouvez aligner les juges LLM sur ces commentaires afin d'améliorer encore la précision des juges. Consultez Aligner les juges LLM avec le feedback humain.

Étapes suivantes​

Consultez Créer un juge personnalisé pour un tutoriel pratique qui présente à la fois des juges standard et basés sur des traces.

Étape suivante : Évaluateurs basés sur du code

Sur cette page