CI/CD til AI: Automatiserede evalueringskørsler
På denne side
Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Integrering af evalueringskørsler i din CI/CD-pipeline
At deploye en prompt-ændring til produktion uden evaluering svarer til at deploye kode uden tests. Sammenligningen er mere præcis, end man måske tror: I begge tilfælde virker ændringen triviel, den er manuelt verificeret på et par eksempler, og bivirkningen viser sig tre dage senere for en bruger, der ikke siger noget om det. Forskellen er, at en prompt-regression ikke udløser en undtagelse – applikationen svarer stadig, bare dårligere.
Målet er at gøre automatiseret evaluering til en obligatorisk gate i din deploymentsproces, så hver eneste ændring bevarer eller forbedrer kvaliteten. Det er præcis det, vi gennemgår nu.
Princippet: En gate, ikke en rapport
Evalueringspipelinen integreres i din deploymentsflow ved hjælp af en velkendt mekanisme. En udvikler ændrer en prompt eller en parameter, commit’en trigge CI-pipelinen, og evalueringskørslerne kører automatisk mod referencesættet. Hvis scorerne opfylder tærskelværdierne, fortsætter deploymentet; ellers blokeres det, og du får en detaljeret rapport over, hvilken evaluering der fejlede, og hvor meget.
Det afgørende punkt er selve blokeringsadfærden. En CI, der producerer en pæn rapport uden at stoppe pipelinen, bliver til et artefakt, som ingen tjekker efter to uger. Kun en exit-kode forskellig fra nul gør målingen til et værn.
Scriptet nedenfor læser en konfiguration, indlæser hvert datasæt, kører testtilfældene og sammenligner gennemsnitsscoren med den deklarerede tærskel. Scoring-metoden – simpel søgning efter nøgleord – er bevidst rudimentær: En CI-tjek skal være hurtig, deterministisk og uafhængig af en dommer, hvis score kan variere fra kørsel til kørsel.
import json
import sys
import openai
from pathlib import Path
client = openai.OpenAI()
def load_eval_config(path: str = "evals/config.json") -> dict:
"""Indlæser evalueringskonfigurationen."""
with open(path) as f:
return json.load(f)
def load_dataset(path: str) -> list[dict]:
"""Indlæser et JSONL-datasæt."""
cases = []
with open(path) as f:
for line in f:
cases.append(json.loads(line))
return cases
def run_ci_evals(config: dict) -> dict:
"""Kører evalueringer til 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 kræver effort none
instructions=prompt,
input=case["input"],
temperature=0.0,
)
# Simpel evaluering via nøgleordsinkludering
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 # Ingen specifikke kriterier
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]:
"""Genererer en rapport til CI og angiver, om alt er OK."""
lines = ["# AI-evalueringsrapport\n"]
all_pass = True
for name, r in results.items():
status = "BESTÅET" if r["passed"] else "IKKE BESTÅET"
if not r["passed"]:
all_pass = False
lines.append(
f"- [{status}] {name}: {r['score']:.2%} "
f"(tærskel: {r['threshold']:.0%}, {r['num_cases']} tilfælde)"
)
report = "\n".join(lines)
return report, all_pass
Bemærk, at prompten læses fra en fil i stedet for at blive skrevet direkte i scriptet. Det er netop det, der muliggør triggering: En prompt, der er versioneret i repository’et, producerer et diff, og et diff kan trigge en evaluering. Så længe dine prompts lever som streng-literaler spredt ud i din applikationskode, er ordentlig automatisering umulig.
Konfigurationen definerer én evaluering per opgave, hver med sin egen tærskel.
{
"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
}
]
}
Gabbet mellem disse to tærskler er metodens kerne. Ticket-klassificering er en lukket opgave: Under 0,90 leverer funktionen ikke den forventede service. Resumé-generering er en åben opgave, bedømt på nøgleord, som en god tekst legitimt kan formulere anderledes; at kræve 0,90 ville blokere ethvert deployment og hurtigt føre til, at tjekket blev deaktiveret. Kalibrer hver tærskel baseret på scorer observeret i produktionen frem for på et rundt tal, der føles beroligende.
Samling af det hele i GitHub Actions
Workflow’et trigges kun ved relevante stier – prompts, evalueringsdata, AI-integrationskode – så en ændring i et stylesheet ikke bruger API-kald.
# .github/workflows/eval-ai.yml
name: AI-evaluering
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: Kør evalueringer
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
run: python evals/run_ci.py
- name: Offentliggør rapport
if: always()
uses: actions/upload-artifact@v4
with:
name: eval-report
path: evals/report.md
To detaljer er værd at bemærke. API-nøglen sendes via repository-secrets, aldrig gennem workflow-filen, som er læsbar for alle med adgang til koden. Og offentliggørelsen af rapporten bruger if: always(), ellers ville artefaktet ikke blive produceret, når evalueringerne fejler – hvilket netop er det eneste tilfælde, hvor du har brug for at læse det.
Entry-scriptet binder det hele sammen: Det skriver rapporten til disk til artefaktet, udskriver den til loggene og sætter den exit-kode, der tillader eller blokerer resten af pipelinen.
#!/usr/bin/env python3
"""Evalueringsscript til 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)
# Skriv rapporten
Path("evals/report.md").write_text(report)
print(report)
# Exit-kode til CI
if not all_pass:
print("\nNogle evalueringer fejlede. Deployment blokeret.")
sys.exit(1)
else:
print("\nAlle evalueringer bestået.")
sys.exit(0)
if __name__ == "__main__":
main()
Sammenlign frem for at dømme i absolutte tal
En fast tærskel besvarer spørgsmålet „Er dette godt nok?”. Den besvarer ikke „Er dette bedre end før?”, hvilket ofte er det egentlige spørgsmål. En omskrevet prompt kan blive over tærsklen, mens den mister tre point sammenlignet med den forrige version: CI bliver grøn, og forringelsen ryger i produktion, uden at nogen lægger mærke til det.
Regressionstesten kører derfor begge versioner på samme datasæt, i samme kampagne, og sammenligner gennemsnittene. En tolerance på 5 % absorberer den støj, der er iboende i generative outputs; ud over det er dommen eksplicit.
def prompt_regression_test(
current_prompt: str,
previous_prompt: str,
dataset: list[dict],
model: str,
degradation_threshold: float = 0.05,
) -> dict:
"""Verificerer, at en ny prompt ikke forringer ydeevnen."""
scores_current = []
scores_previous = []
for case in dataset:
# Evaluér med nuværende prompt
r1 = client.responses.create(
model=model, instructions=current_prompt,
reasoning={"effort": "none"}, # temperature kræver effort none
input=case["input"], temperature=0.0,
)
# Evaluér med tidligere prompt
r2 = client.responses.create(
model=model, instructions=previous_prompt,
reasoning={"effort": "none"}, # temperature kræver 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",
}
Denne test fordobler antallet af kald og dermed også omkostninger og varighed. Reserver den til prompt-ændringer, hold den væk fra stien for almindelige commits, og kør den på et repræsentativt udsnit frem for hele dit referencedatasæt.
Vigtige pointer
- Integrér evalueringskørsler i din CI/CD-pipeline ligesom unit-tests
- Versionér prompts i filer: Uden et diff er triggering umuligt
- Definer minimumstærskler per evalueringstype, kalibreret ud fra produktionsdata
- Blokér deployments via exit-kode, når scorerne falder under tærsklerne
- Test for regressioner ved at sammenligne nye og gamle prompts på samme datasæt