CI/CD för AI: Automatiserade utvärderingar
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI-dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Integrera utvärderingar i din CI/CD-pipeline
Att distribuera en promptändring till produktion utan utvärdering är som att distribuera kod utan tester. Jämförelsen är mer träffsäker än den kanske verkar: i båda fallen verkar ändringen trivial, den har verifierats manuellt på ett eller två exempel, och biverkningen dyker upp tre dagar senare för en användare som inte berättar om det för dig. Skillnaden är att en promptregression inte kastar ett undantag – applikationen fortsätter svara, bara sämre.
Målet är att göra automatiserad utvärdering till en obligatorisk grind i din distributionsprocess, så att varje ändring behåller eller förbättrar kvaliteten. Det är exakt vad vi ska gå igenom härnäst.
Principen: En grind, inte en rapport
Utvärderingspipelinen integreras i ditt distributionsflöde med en bekant mekanism. En utvecklare ändrar en prompt eller parameter, commiten triggar CI-pipelinen och utvärderingar körs automatiskt mot referensdatasetet. Om poängen når tröskelvärdena fortsätter distributionen; annars blockeras den, med en detaljerad rapport som visar vilken utvärdering som misslyckades och med hur mycket.
Den avgörande punkten är detta blockerande beteende. En CI som producerar en snygg rapport utan att stoppa pipelinen blir en artefakt som ingen kontrollerar efter två veckor. Endast en exit-kod skild från noll gör mätningen till ett skyddsräcke.
Skriptet nedan läser en konfiguration, laddar varje dataset, kör fallen och jämför medelpoängen med den deklarerade tröskeln. Poängsättningsmetoden – enkel nyckelordsinkludering – är avsiktligt rudimentär: en CI-kontroll måste vara snabb, deterministisk och oberoende av en domare vars poäng kan variera från körning till körning.
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
Lägg märke till att prompten läses från en fil istället för att skrivas direkt i skriptet. Det är detta som möjliggör triggring: en prompt versionshanterad i arkivet skapar en diff, och en diff kan trigga en utvärdering. Så länge dina prompter lever som stränglitteraler utspridda i din applikationskod är korrekt automatisering inte möjlig.
Konfigurationen deklarerar en utvärdering per uppgift, var och en med sin egen tröskel.
{
"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
}
]
}
Gapet mellan dessa två trösklar är kärnan i metoden. Ticket-klassificering är en sluten uppgift: under 0,90 levererar funktionen inte den förväntade tjänsten. Sammanfattning är en öppen uppgift, bedömd på nyckelord som en bra text legitimt kan formulera annorlunda; att kräva 0,90 skulle blockera varje distribution och snabbt leda till att kontrollen inaktiveras. Kalibrera varje tröskel baserat på poäng observerade i produktion snarare än på ett runt tal som känns tryggt.
Koppla ihop allt i GitHub Actions
Workflow:en triggar endast på relevanta sökvägar – prompter, utvärderingar, AI-integrationskod – så att en ändring i en stilmall inte förbrukar API-anrop.
# .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
Två detaljer är värda att notera. API-nyckeln skickas via arkivhemligheter (secrets), aldrig genom workflow-filen, som är läsbar för alla med tillgång till koden. Och publiceringen av rapporten använder if: always(), annars skulle artefakten inte produceras när utvärderingar misslyckas – vilket är precis det enda fallet då du behöver läsa den.
Entréskriptet binder ihop allt: det skriver rapporten till disk för artefakten, skriver ut den i loggarna och sätter den exit-kod som tillåter eller blockerar resten av pipelinen.
#!/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()
Jämför snarare än att bedöma i absoluta termer
En fast tröskel svarar på frågan “Är detta bra nog?”. Den svarar inte på “Är detta bättre än tidigare?”, vilket ofta är den verkliga frågan. En omskriven prompt kan ligga kvar över tröskeln medan den tappar tre poäng jämfört med föregående version: CI blir grön och försämringen hamnar i produktion utan att någon märker det.
Regressionstestet kör därför båda versionerna på samma dataset, i samma kampanj, och jämför medelvärdena. En tolerans på 5 % absorberar det brus som är inneboende i generativa utdata; bortom det är domen explicit.
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",
}
Detta test fördubblar antalet anrop, och därmed kostnaden och varaktigheten. Reservera det för promptändringar, håll det borta från vägen för vanliga commits, och kör det på ett representativt urval snarare än hela ditt referensdataset.
Viktiga punkter
- Integrera utvärderingar i din CI/CD-pipeline som enhetstester
- Versionshantera prompter i filer: utan en diff är ingen triggring möjlig
- Definiera minimitrösklar per utvärderingstyp, kalibrerade på produktionsdata
- Blockera distributioner via exit-kod när poängen faller under trösklarna
- Testa efter regressioner genom att jämföra nya och gamla prompter på samma dataset