Spring til hovedindhold
Dansk— Vælg et sprog
Menu

CI/CD til AI: Automatiserede evalueringskørsler

Lektion 18 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Integrering af evalueringskørsler i din CI/CD-pipeline
  2. Princippet: En gate, ikke en rapport
  3. Samling af det hele i GitHub Actions
  4. Sammenlign frem for at dømme i absolutte tal
  5. Vigtige pointer

Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres 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 specificere reasoning={"effort": "none"} (Responses API) eller reasoning_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