CI/CD pour l'IA : Évaluations automatisées
Šiame puslapyje
Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, tandis 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 : 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