Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

CI/CD pour l'IA : Évaluations automatisées

Paskaita 18 iš 20 Atnaujinta 2026 m. lapkričio 3 d. Pažengusiems
Šiame puslapyje
  1. Intégrer les évaluations dans votre pipeline CI/CD
  2. Le principe : une barrière, pas un rapport
  3. Tout connecter dans GitHub Actions
  4. Comparer plutôt que juger en termes absolus
  5. Svarbiausi punktai

Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI : temperature et top_p ne sont acceptés qu’avec un effort de raisonnement de none, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifier reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Sources : Utilisation de GPT-6 · GPT-5.6 Terra.

Intégrer les évaluations dans votre pipeline CI/CD

Déployer une modification de prompt en production sans évaluation revient à déployer du code sans tests. La comparaison est plus juste qu’il n’y paraît : dans les deux cas, le changement semble anodin, il a été vérifié manuellement sur un ou deux exemples, et l’effet secondaire apparaît trois jours plus tard pour un utilisateur qui ne vous en parlera pas. La différence, c’est qu’une régression de prompt ne lève pas d’exception : l’application continue de répondre, juste moins bien.

L’objectif est de faire de l’évaluation automatisée une étape obligatoire de votre processus de déploiement, garantissant que chaque changement maintient ou améliore la qualité. C’est exactement ce que nous allons voir maintenant.

Le principe : une barrière, pas un rapport

Le pipeline d’évaluation s’intègre à votre flux de déploiement via un mécanisme familier. Un développeur modifie un prompt ou un paramètre, le commit déclenche le pipeline CI, et les évaluations s’exécutent automatiquement sur le jeu de données de référence. Si les scores atteignent les seuils, le déploiement se poursuit ; sinon, il est bloqué, accompagné d’un rapport détaillé indiquant quelle évaluation a échoué et dans quelle mesure.

Le point critique est ce comportement de blocage. Une CI qui produit un joli rapport sans arrêter le pipeline devient un artefact que personne ne consulte après deux semaines. Seul un code de sortie non nul transforme la mesure en garde-fou.

Le script ci-dessous lit une configuration, charge chaque jeu de données, exécute les cas et compare le score moyen au seuil déclaré. La méthode de notation — simple inclusion de mots-clés — est volontairement rudimentaire : une vérification CI doit être rapide, déterministe et indépendante d’un juge dont le score pourrait varier d’une exécution à l’autre.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Charge la configuration d'évaluation."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Charge un jeu de données JSONL."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Exécute les évaluations pour la CI."""
    results = {}

    for eval_config in config["evaluations"]:
        name = eval_config["name"]
        dataset = load_dataset(eval_config["dataset"])
        threshold = eval_config["min_threshold"]
        model = eval_config["model"]
        prompt = Path(eval_config["prompt_file"]).read_text()

        scores = []
        for case in dataset:
            response = client.responses.create(
                model=model,
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt,
                input=case["input"],
                temperature=0.0,
            )

            # Évaluation simple par inclusion de mots-clés
            if "keywords" in case:
                response_lower = response.output_text.lower()
                found = sum(
                    1 for word in case["keywords"]
                    if word.lower() in response_lower
                )
                score = found / len(case["keywords"])
            else:
                score = 1.0  # Aucun critère spécifique

            scores.append(score)

        avg_score = sum(scores) / len(scores)
        passed = avg_score >= threshold

        results[name] = {
            "score": avg_score,
            "threshold": threshold,
            "passed": passed,
            "num_cases": len(dataset),
        }

    return results

def ci_report(results: dict) -> tuple[str, bool]:
    """Génère un rapport pour la CI et indique si tout est OK."""
    lines = ["# Rapport d'évaluation IA\n"]
    all_pass = True

    for name, r in results.items():
        status = "PASS" if r["passed"] else "FAIL"
        if not r["passed"]:
            all_pass = False
        lines.append(
            f"- [{status}] {name}: {r['score']:.2%} "
            f"(seuil : {r['threshold']:.0%}, {r['num_cases']} cas)"
        )

    report = "\n".join(lines)
    return report, all_pass

Notez que le prompt est lu depuis un fichier plutôt qu’écrit directement dans le script. C’est ce qui rend le déclenchement possible : une version du prompt dans le dépôt produit un diff, et un diff peut déclencher une évaluation. Tant que vos prompts vivent sous forme de littéraux de chaînes dispersés dans le code de votre application, une automatisation correcte est impossible.

La configuration déclare une évaluation par tâche, chacune avec son propre seuil.

{
  "evaluations": [
    {
      "name": "ticket-classification",
      "dataset": "evals/datasets/classification.jsonl",
      "prompt_file": "prompts/classification.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.90
    },
    {
      "name": "resume-generation",
      "dataset": "evals/datasets/resumes.jsonl",
      "prompt_file": "prompts/resume.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.75
    }
  ]
}

L’écart entre ces deux seuils est au cœur de la méthode. La classification de tickets est une tâche fermée : en dessous de 0,90, la fonctionnalité ne rend pas le service attendu. La génération de résumés est une tâche ouverte, jugée sur des mots-clés qu’un bon texte pourrait légitimement formuler différemment ; exiger 0,90 bloquerait chaque déploiement et conduirait rapidement à désactiver la vérification. Calibrez chaque seuil en fonction des scores observés en production plutôt que sur un nombre rond qui semble rassurant.

Tout connecter dans GitHub Actions

Le workflow ne se déclenche que sur les chemins pertinents — prompts, évaluations, code d’intégration IA — afin qu’un changement de feuille de style ne consomme pas d’appels API.

# .github/workflows/eval-ai.yml
name: AI Evaluation

on:
  pull_request:
    paths:
      - "prompts/**"
      - "evals/**"
      - "src/ai/**"

jobs:
  evaluate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - run: pip install openai

      - name: Run evals
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evals/run_ci.py

      - name: Publish report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: evals/report.md

Deux détails méritent attention. La clé API passe par les secrets du dépôt, jamais par le fichier de workflow, qui est lisible par quiconque ayant accès au code. Et la publication du rapport utilise if: always(), sinon l’artefact ne serait pas produit en cas d’échec des évaluations — ce qui est précisément le seul cas où vous avez besoin de le lire.

Le script d’entrée relie le tout : il écrit le rapport sur le disque pour l’artefact, l’affiche dans les journaux et définit le code de sortie qui autorise ou bloque le reste du pipeline.

#!/usr/bin/env python3
"""Script d'évaluation pour la CI — evals/run_ci.py"""

import sys
from pathlib import Path

def main():
    config = load_eval_config("evals/config.json")
    results = run_ci_evals(config)
    report, all_pass = ci_report(results)

    # Écriture du rapport
    Path("evals/report.md").write_text(report)
    print(report)

    # Code de sortie pour la CI
    if not all_pass:
        print("\nCertaines évaluations ont échoué. Déploiement bloqué.")
        sys.exit(1)
    else:
        print("\nToutes les évaluations sont validées.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Comparer plutôt que juger en termes absolus

Un seuil fixe répond à la question « Est-ce assez bon ? ». Il ne répond pas à « Est-ce mieux qu’avant ? », ce qui est souvent la vraie question. Un prompt réécrit peut rester au-dessus du seuil tout en perdant trois points par rapport à la version précédente : la CI passe au vert et la dégradation entre en production sans que personne ne s’en aperçoive.

Le test de régression exécute donc les deux versions sur le même jeu de données, dans la même campagne, et compare les moyennes. Une tolérance de 5 % absorbe le bruit inhérent aux sorties génératives ; au-delà, le verdict est explicite.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Vérifie qu'un nouveau prompt ne dégrade pas les performances."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Évaluation avec le prompt actuel
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Évaluation avec le prompt précédent
        r2 = client.responses.create(
            model=model, instructions=previous_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )

        s1 = evaluate_response(r1.output_text, case)
        s2 = evaluate_response(r2.output_text, case)
        scores_current.append(s1)
        scores_previous.append(s2)

    avg_current = sum(scores_current) / len(scores_current)
    avg_previous = sum(scores_previous) / len(scores_previous)
    delta = avg_current - avg_previous

    return {
        "current_score": avg_current,
        "previous_score": avg_previous,
        "delta": delta,
        "regression": delta < -degradation_threshold,
        "verdict": "OK" if delta >= -degradation_threshold else "REGRESSION",
    }

Ce test double le nombre d’appels, et donc le coût et la durée. Réservez-le aux modifications de prompts, en le gardant hors du chemin des commits ordinaires, et exécutez-le sur un sous-ensemble représentatif plutôt que sur l’intégralité de votre jeu de données de référence.

Svarbiausi punktai

  • Intégrez les évaluations dans votre pipeline CI/CD comme des tests unitaires
  • Versionnez les prompts dans des fichiers : sans diff, aucun déclenchement n’est possible
  • Définissez des seuils minimaux par type d’évaluation, calibrés sur les données de production
  • Bloquez les déploiements via un code de sortie lorsque les scores chutent sous les seuils
  • Testez les régressions en comparant les nouveaux et anciens prompts sur le même jeu de données