Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

CI/CD voor AI: Geautomatiseerde Evals

Les 18 van 20 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Evals integreren in uw CI/CD-pipeline
  2. Het principe: een poort, geen rapport
  3. Alles koppelen in GitHub Actions
  4. Vergelijk in plaats van absoluut te beoordelen
  5. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (Responses API) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Evals integreren in uw CI/CD-pipeline

Het implementeren van een wijziging in een prompt naar productie zonder evaluatie is vergelijkbaar met het deployen van code zonder tests. De vergelijking is accurater dan het misschien lijkt: in beide gevallen lijkt de wijziging triviaal, is deze handmatig geverifieerd aan de hand van een of twee voorbeelden, en manifesteert het neveneffect zich drie dagen later bij een gebruiker die u er niet over zal informeren. Het verschil is dat een regressie in een prompt geen uitzondering veroorzaakt; de applicatie blijft reageren, alleen slechter.

Het doel is om geautomatiseerde evaluatie tot een verplichte poort in uw deployproces te maken, zodat elke wijziging de kwaliteit behoudt of verbetert. Dat is precies wat we hierna behandelen.

Het principe: een poort, geen rapport

De eval-pipeline integreert in uw deployflow via een vertrouwd mechanisme. Een ontwikkelaar wijzigt een prompt of parameter, de commit activeert de CI-pipeline en de evals worden automatisch uitgevoerd tegen de referentieset. Als de scores aan de drempelwaarden voldoen, gaat de implementatie door; anders wordt deze geblokkeerd, vergezeld van een gedetailleerd rapport dat aangeeft welke evaluatie is mislukt en met hoeveel.

Het cruciale punt is dit blokkerende gedrag. Een CI die een mooi rapport produceert zonder de pipeline te stoppen, wordt binnen twee weken een artefact dat niemand meer controleert. Alleen een exitcode ongelijk aan nul verandert meting in een vangrail.

Het onderstaande script leest een configuratie, laadt elke dataset, voert de cases uit en vergelijkt de gemiddelde score met de opgegeven drempelwaarde. De scoremethode – eenvoudige trefwoordopname – is bewust rudimentair: een CI-check moet snel, deterministisch en onafhankelijk zijn van een judge wiens score per uitvoering kan variëren.

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

Merk op dat de prompt uit een bestand wordt gelezen in plaats van direct in het script te worden geschreven. Dit maakt triggering mogelijk: een prompt die versiebeheerd is in de repository genereert een diff, en een diff kan een evaluatie activeren. Zolang uw prompts als string-literals verspreid door uw applicatiecode staan, is goede automatisering niet mogelijk.

De configuratie declareert één evaluatie per taak, elk met een eigen drempelwaarde.

{
  "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
    }
  ]
}

Het verschil tussen deze twee drempelwaarden vormt de kern van de methode. Ticketclassificatie is een gesloten taak: onder de 0,90 levert de functie niet de verwachte service. Samenvatten is een open taak, beoordeeld op trefwoorden die een goede tekst legitiem anders zou kunnen formuleren; een vereiste van 0,90 zou elke implementatie blokkeren en snel leiden tot het uitschakelen van de check. Kalibreer elke drempelwaarde op basis van scores die in productie zijn waargenomen, in plaats van op een rond getal dat geruststellend aanvoelt.

Alles koppelen in GitHub Actions

De workflow wordt alleen geactiveerd op relevante paden – prompts, evals, AI-integratiecode – zodat een wijziging in een stylesheet geen API-calls verbruikt.

# .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

Twee details zijn het vermelden waard. De API-sleutel wordt via repository-secrets doorgegeven, nooit via het workflow-bestand, dat leesbaar is voor iedereen met toegang tot de code. En de publicatie van het rapport gebruikt if: always(), anders zou het artefact niet worden geproduceerd wanneer evals mislukken – wat precies het enige geval is waarin u het moet lezen.

Het entry-script bindt alles samen: het schrijft het rapport naar schijf voor het artefact, print het naar de logs en stelt de exitcode in die de rest van de pipeline toelaat of blokkeert.

#!/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()

Vergelijk in plaats van absoluut te beoordelen

Een vaste drempelwaarde beantwoordt de vraag “Is dit goed genoeg?”. Het beantwoordt niet de vraag “Is dit beter dan eerder?”, wat vaak de echte vraag is. Een herschreven prompt kan boven de drempelwaarde blijven terwijl deze drie punten verliest ten opzichte van de vorige versie: de CI wordt groen en de degradatie belandt in productie zonder dat iemand het merkt.

De regressietest voert daarom beide versies uit op dezelfde dataset, in dezelfde campagne, en vergelijkt de gemiddelden. Een tolerantie van 5% absorbeert de ruis die inherent is aan generatieve outputs; daarbeyond is het oordeel expliciet.

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",
    }

Deze test verdubbelt het aantal calls, en dus de kosten en duur. Reserveer dit voor wijzigingen in prompts, houd het buiten het pad van gewone commits, en voer het uit op een representatieve subset in plaats van uw volledige referentieset.

Belangrijkste punten

  • Integreer evals in uw CI/CD-pipeline zoals unit tests
  • Beheer prompts in bestanden: zonder diff is triggering niet mogelijk
  • Definieer minimumdrempels per evaluatietype, gekalibreerd op productiedata
  • Blokkeer implementaties via exitcode wanneer scores onder de drempels zakken
  • Test op regressies door nieuwe en oude prompts op dezelfde dataset te vergelijken