Évaluations Pydantic

Documentation > Agent Observability > Enquêter > Évaluations > Évaluations externes > Évaluations Pydantic

Présentation

Pydantic est un framework open source qui fournit des évaluations prêtes à l’emploi et permet des évaluations LLM personnalisables. Pour plus d’informations, consultez la documentation de Pydantic.

Vous pouvez utiliser Agent Observability pour exécuter des évaluations Pydantic et des évaluations de rapport Pydantic scalaires dans Experiments. Les résultats de l’évaluation Pydantic apparaissent en tant que résultats d’évaluateur liés à chaque instance dans un jeu de données Agent Observability. Les évaluations de rapport Pydantic s’exécutent sur un jeu de données Agent Observability complet et rapportent un résultat scalaire pour celui-ci.

Configuration

Configurez une expérience Agent Observability et un jeu de données Agent Observability.
Fournissez un évaluateur Pydantic au paramètre evaluators dans un Experiment LLMObs comme illustré dans l’exemple de code suivant. (Facultatif) Fournissez un évaluateur de rapport Pydantic au paramètre summary_evaluators dans un Experiment LLMObs. Remarque : Seuls les évaluateurs de rapport Pydantic qui renvoient un ScalarResult sont pris en charge.


from pydantic_evals.evaluators import (
    EqualsExpected,
    EvaluationReason,
    Evaluator,
    EvaluatorContext,
    EvaluatorOutput,
    LLMJudge,
    ReportEvaluator,
    ReportEvaluatorContext,
)
from pydantic_evals.reporting.analyses import ScalarResult

from ddtrace.llmobs import LLMObs


LLMObs.enable(
    api_key="<YOUR_API_KEY>",  # defaults to DD_API_KEY environment variable
    app_key="<YOUR_APP_KEY>",  # defaults to DD_APP_KEY environment variable
    site="datadoghq.com",      # defaults to DD_SITE environment variable
    project_name="<YOUR_PROJECT>"  # defaults to DD_LLMOBS_PROJECT_NAME environment variable, or "default-project" if the environment variable is not set
)


# this can be any Pydantic evaluator
@dataclass
class ComprehensiveCheck(Evaluator): 
    def evaluate(self, ctx: EvaluatorContext) -> EvaluatorOutput:
        format_valid = self._check_format(ctx.output)

        to_return = {
            'valid_format': EvaluationReason(
                value=format_valid,
                reason='Valid JSON format' if format_valid else 'Invalid JSON format',
            ),
            'quality_score': self._score_quality(ctx.output),  
            'category': self._classify(ctx.output),  
        }
        return to_return

    def _check_format(self, output: str) -> bool:
        return output.startswith('{') and output.endswith('}')

    def _score_quality(self, output: str) -> float:
        return len(output) / 100.0

    def _classify(self, output: str) -> str:
        return 'short' if len(output) < 50 else 'long'

# This can be any Pydantic ReportEvaluator that returns ScalarResult
class TotalCasesEvaluator(ReportEvaluator):
    def evaluate(self, ctx: ReportEvaluatorContext) -> ScalarResult:
        return ScalarResult(
            title='Total',
            value=len(ctx.report.cases),
            unit='cases',
        )

dataset = LLMObs.create_dataset(
    dataset_name="capitals-of-the-world",
    project_name="capitals-project",  # optional, defaults to project_name used in LLMObs.enable
    description="Questions about world capitals",
    records=[
        {
            "input_data": {
                "question": "What is the capital of China?"
            },  # required, JSON or string
            "expected_output": "Beijing",  # optional, JSON or string
            "metadata": {"difficulty": "easy"},  # optional, JSON
        },
        {
            "input_data": {
                "question": "Which city serves as the capital of South Africa?"
            },
            "expected_output": "Pretoria",
            "metadata": {"difficulty": "medium"},
        },
    ],
)

def task(input_data: Dict[str, Any], config: Optional[Dict[str, Any]] = None, metadata: Optional[Dict[str, Any]] = None) -> str:
    question = input_data['question']
    # Your LLM or processing logic here
    return "Beijing" if "China" in question else "Unknown"


llm_judge = LLMJudge(
    rubric='Response provides the same answer as expected, possibly with explanation',
    include_input=True,
    include_expected_output=True,
)

experiment = LLMObs.experiment(
    name="<EXPERIMENT_NAME>",
    task=my_task, 
    dataset=dataset,
    evaluators=[EqualsExpected(), ComprehensiveCheck(), llm_judge],
    summary_evaluators=[TotalCasesEvaluator()],
    description="<EXPERIMENT_DESCRIPTION>",
)


results = experiment.run(jobs=4, raise_errors=True)

print(f"View experiment: {experiment.url}")

Pour un exemple fonctionnel, consultez la démo Pydantic de Datadog sur GitHub.

Utilisation

Après avoir exécuté une expérience avec une évaluation Pydantic, vous pouvez consulter les résultats de l’évaluation Pydantic par instance dans l’exécution de l’expérience correspondante dans Datadog. Dans l’expérience suivante, deux évaluations Pydantic (un évaluateur Pydantic personnalisé nommé « ComprehensiveCheck » et un évaluateur intégré nommé « EqualsExpected ») et un évaluateur de rapport Pydantic (un évaluateur de rapport Pydantic personnalisé nommé « TotalCasesEvaluator ») ont été exécutés :