RousselTMLEARNING

Observabilité

Évaluer une application LLM avec Phoenix : LLM juges, code et annotations

Mettre en place des évaluations : évaluateurs par code, LLM juge (create_classifier, evaluate_dataframe), évaluateurs prêts à l'emploi, annotations humaines, calibration du juge et enregistrement des résultats dans Phoenix.

1. Les trois familles d'évaluations #

Choisir la bonne pour chaque critère.

Comparaison #

Trois façons d'évaluer une application LLM
FamillePourCoûtLimite
CodeFormat (JSON valide), présence d'un mot, longueur, appel d'outil attenduQuasi nulNe juge pas le sens
LLM jugePertinence, fidélité au contexte (hallucination), ton, toxicitéUn appel de modèle par évaluationPeut se tromper : à calibrer
HumainCas ambigus, référence pour calibrer le jugeÉlevéLent, ne passe pas à l'échelle
Bonne Pratique : Commencez par les évaluations par code : elles sont gratuites, déterministes et attrapent déjà beaucoup de régressions (format, refus, réponses vides).

2. Un LLM juge avec Phoenix Evals #

create_classifier.

Créer un évaluateur #

pip install "arize-phoenix-evals>=2.0" openai
from phoenix.evals import create_classifier, evaluate_dataframe
from phoenix.evals.llm import LLM

judge = LLM(provider="openai", model="gpt-4.1")      # ou un modèle local via OPENAI_BASE_URL

relevance = create_classifier(
    name="relevance",
    prompt_template=(
        "Tu évalues un assistant de support.\n"
        "Question : {input}\nRéponse : {output}\n"
        "La réponse traite-t-elle la question posée ? Réponds relevant ou irrelevant."),
    llm=judge,
    choices={"relevant": 1.0, "irrelevant": 0.0},
)

print(relevance.evaluate({"input": "Vos horaires ?", "output": "Nous sommes ouverts de 9 h à 18 h."}))
À savoir : create_classifier s'appuie sur les sorties structurées (appel d'outil) du modèle juge : préférez un modèle qui les gère bien. L'ancienne fonction llm_classify est dépréciée au profit de create_classifier et evaluate_dataframe.

Évaluer les traces #

from phoenix.client import Client

px = Client(base_url="http://localhost:6006")
spans = px.spans.get_spans_dataframe(project_identifier="support-bot")
roots = spans[spans["parent_id"].isna()]            # une ligne par requête

results = evaluate_dataframe(
    dataframe=roots,
    evaluators=[relevance],
    input_mapping={"input": "attributes.input.value", "output": "attributes.output.value"},
)

Les résultats (label, score, explication) se renvoient ensuite dans Phoenix comme annotations de spans, pour filtrer les traces jugées non pertinentes et les ajouter à un dataset.

À savoir : Les noms de colonnes et l'utilitaire de conversion en annotations dépendent de la version de Phoenix : affichez results.columns et reportez-vous à la documentation de votre version.

3. Faire confiance au juge #

Un juge non calibré est un risque.

Calibrer #

  1. Annotez à la main 50 à 100 réponses représentatives.
  2. Faites-les évaluer par le juge.
  3. Mesurez l'accord (précision, rappel sur les réponses « mauvaises »).
  4. Ajustez le prompt du juge (définitions, exemples) jusqu'à un accord suffisant, puis gardez ce jeu annoté comme test de non-régression du juge.
Erreur Courante : Faire juger un modèle par lui-même, avec le même prompt système, gonfle les scores. Utilisez un juge différent ou au moins un prompt d'évaluation indépendant, et demandez une explication pour pouvoir relire les décisions.

Articles liés

Arize AI : observabilité et évaluation des applications LLM et des agents

Comprendre Arize AI : Phoenix (open source) et Arize AX (plateforme), traces OpenInference, évaluations par L…

OpenInference : les conventions OpenTelemetry pour tracer les applications d'IA

Guide détaillé d'OpenInference : conventions sémantiques et instrumentations OpenTelemetry pour LLM, RAG et a…

Installer Phoenix et tracer sa première application LLM

Installer Arize Phoenix (pip, Docker), envoyer ses premières traces OpenInference depuis une application Open…

Pour aller plus loin