CI/CD pour l'IA : Évaluations automatisées
Tällä sivulla
Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, alors que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.
Intégrer les évaluations dans ton 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 te le signalera 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 ton 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 à ton 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:
"""Loads the evaluation configuration."""
with open(path) as f:
return json.load(f)
def load_dataset(path: str) -> list[dict]:
"""Loads a JSONL dataset."""
cases = []
with open(path) as f:
for line in f:
cases.append(json.loads(line))
return cases
def run_ci_evals(config: dict) -> dict:
"""Runs evaluations for 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,
)
# Simple evaluation by keyword inclusion
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 # No specific criterion
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]:
"""Generates a report for CI and indicates if it's OK."""
lines = ["# AI Evaluation Report\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"(threshold: {r['threshold']:.0%}, {r['num_cases']} cases)"
)
report = "\n".join(lines)
return report, all_pass
Remarque 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 tes prompts vivent sous forme de littéraux de chaînes dispersés dans ton code applicatif, 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. Calibre 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 transite via les secrets du dépôt, jamais via 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ù tu as 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 logs et définit le code de sortie qui autorise ou bloque la suite du pipeline.
#!/usr/bin/env python3
"""Evaluation script for 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)
# Write the report
Path("evals/report.md").write_text(report)
print(report)
# Exit code for CI
if not all_pass:
print("\nSome evaluations failed. Deployment blocked.")
sys.exit(1)
else:
print("\nAll evaluations pass.")
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:
"""Verifies that a new prompt does not degrade performance."""
scores_current = []
scores_previous = []
for case in dataset:
# Evaluate with current prompt
r1 = client.responses.create(
model=model, instructions=current_prompt,
reasoning={"effort": "none"}, # temperature requires effort none
input=case["input"], temperature=0.0,
)
# Evaluate with previous prompt
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éserve-le aux modifications de prompts, en le gardant hors du chemin des commits ordinaires, et exécute-le sur un sous-ensemble représentatif plutôt que sur l’intégralité de ton jeu de données de référence.
Keskeiset asiat
- Intègre les évaluations dans ton pipeline CI/CD comme des tests unitaires
- Versionne les prompts dans des fichiers : sans diff, aucun déclenchement n’est possible
- Définis des seuils minimaux par type d’évaluation, calibrés sur les données de production
- Bloque les déploiements via un code de sortie lorsque les scores chutent sous les seuils
- Teste les régressions en comparant les nouveaux et anciens prompts sur le même jeu de données