Skip to content

Évaluateurs programmatiques

Notez automatiquement les trajectoires d'agent et les sorties textuelles avec la bibliothèque d'évaluateurs sans Flask de Potato — correspondance de trajectoire déterministe, justesse de l'usage des outils, LLM-juge sans référence et heuristiques (correspondance exacte, distance d'édition, JSON, plongements).

Potato est livré avec une bibliothèque d'évaluateurs à dépendances légères qui note automatiquement les trajectoires d'agent et les sorties textuelles : les vérifications déterministes et LLM-juge qui complètent l'annotation humaine. Les mêmes évaluateurs s'exécutent dans les expériences, le moteur d'automatisation et le plugin CI, et fonctionnent aussi de manière autonome.

Chaque évaluateur retourne un résultat normalisé unique — un score (par convention 0.0–1.0, plus haut est meilleur), une value, un comment et des metadata — de sorte que les évaluateurs déterministes, heuristiques et LLM-juge sont interchangeables. Les trajectoires peuvent être passées sous forme de listes de messages au format OpenAI, de tours conversation canoniques de Potato ou d'une CanonicalTrace ; la normalisation est automatique.

Correspondance de trajectoire (déterministe)

Compare la séquence d'appels d'outils d'un agent à une référence.

python
from potato.evaluators import TrajectoryMatchEvaluator
 
ev = TrajectoryMatchEvaluator(
    mode="unordered",               # strict | unordered | subset | superset
    tool_args_match_mode="subset",  # exact | ignore | subset | superset
    tool_args_match_overrides={"search": "ignore"},
)
result = ev.evaluate(outputs=agent_trace, reference_outputs=gold_trace)
modeRéussit lorsque…
strictappels d'outils identiques, dans le même ordre
unorderedmême multiensemble d'appels d'outils, dans n'importe quel ordre
subsetl'agent n'a appelé que des outils présents dans la référence
supersetl'agent a appelé au moins les outils de la référence (extras autorisés)

La comparaison des arguments se configure indépendamment (exact / ignore / subset / superset), avec des dérogations par outil.

Justesse de l'usage des outils

python
from potato.evaluators import ToolUseEvaluator, ToolCallAccuracyEvaluator
 
# Did the agent call a specific tool (optionally with expected args)?
ToolUseEvaluator(expected_tool="submit", expected_args={"id": 1}).evaluate(outputs=trace)
 
# What fraction of reference tool calls did the agent reproduce? (partial credit)
ToolCallAccuracyEvaluator(args_match_mode="exact").evaluate(outputs=trace, reference_outputs=gold)

LLM-juge (sans référence)

Note la qualité d'une trajectoire sans référence dorée, puisqu'il existe de nombreux chemins d'agent valides. Réutilise la même configuration de point de terminaison ai_support que le reste de Potato (OpenAI, Anthropic, Ollama, vLLM, …).

python
from potato.evaluators import LLMTrajectoryJudge
 
judge = LLMTrajectoryJudge(config=task_config, continuous=True)  # 0.0–1.0 score
result = judge.evaluate(outputs=agent_trace, inputs=task_prompt)

Évaluateurs heuristiques / par code

ExactMatch, Contains, RegexMatch, EditDistance, JSONValid, JSONSchemaMatch et EmbeddingDistance (import ML paresseux ou fonction de plongement injectée). Importer la bibliothèque ne charge jamais la pile ML.

Évaluation de trajectoire en graphe (LangGraph)

Pour l'évaluation des nœuds et transitions LangGraph, Potato réutilise le paquet sous licence MIT agentevals via un adaptateur paresseux — installez-le uniquement si vous en avez besoin.

Configurer les évaluateurs de manière déclarative

Un registre associe des noms aux évaluateurs pour permettre leur configuration en YAML (utilisé par l'exécuteur d'expériences et le moteur d'automatisation) :

python
from potato.evaluators import build_evaluator, list_evaluators
 
ev = build_evaluator("trajectory_match", {"mode": "unordered"})
result = ev.evaluate(outputs=trace, reference_outputs=gold)

Pages liées