Skip to content

Evaluadores programáticos

Puntúa trayectorias de agentes y salidas de texto automáticamente con la biblioteca de evaluadores de Potato, sin dependencia de Flask: coincidencia determinista de trayectorias, corrección del uso de herramientas, LLM como juez sin referencia y heurísticas (coincidencia exacta, distancia de edición, JSON, embeddings).

Potato incluye una biblioteca de evaluadores con dependencias mínimas que puntúa automáticamente trayectorias de agentes y salidas de texto: las comprobaciones deterministas y de LLM como juez que complementan la anotación humana. Los mismos evaluadores se ejecutan dentro de los experimentos, del motor de automatización y del plugin de CI, y también funcionan de forma independiente.

Cada evaluador devuelve un resultado normalizado — un score (por convención 0.0–1.0, cuanto más alto mejor), un value, un comment y metadata — de modo que los evaluadores deterministas, heurísticos y de juez LLM son intercambiables. Las trayectorias pueden pasarse como listas de mensajes al estilo de OpenAI, como los turnos conversation canónicos de Potato o como una CanonicalTrace; la normalización es automática.

Coincidencia de trayectorias (determinista)

Compara la secuencia de llamadas a herramientas de un agente con una referencia.

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)
modePasa cuando…
strictllamadas a herramientas idénticas, en el mismo orden
unorderedel mismo multiconjunto de llamadas a herramientas, en cualquier orden
subsetel agente solo llamó a herramientas que aparecen en la referencia
supersetel agente llamó al menos a las herramientas de la referencia (se permiten extras)

La comparación de argumentos se configura de forma independiente (exact / ignore / subset / superset), con anulaciones por herramienta.

Corrección del uso de herramientas

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 como juez (sin referencia)

Puntúa la calidad de la trayectoria sin una referencia dorada, ya que existen muchos caminos de agente válidos. Reutiliza la misma configuración de endpoint ai_support que el resto 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)

Evaluadores heurísticos y de código

ExactMatch, Contains, RegexMatch, EditDistance, JSONValid, JSONSchemaMatch y EmbeddingDistance (importación perezosa de ML o una función de embeddings inyectada). Importar la biblioteca nunca carga la pila de ML.

Evaluación de trayectorias en grafo (LangGraph)

Para la evaluación de nodos y transiciones de LangGraph, Potato reutiliza el paquete con licencia MIT agentevals mediante un adaptador perezoso: instálalo solo si lo necesitas.

Configurar evaluadores de forma declarativa

Un registro asocia nombres → evaluadores para poder configurarlos en YAML (lo usan el ejecutor de experimentos y el motor de automatización):

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

Relacionado