Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

CI/CD az AI-hoz: Automatizált értékelések

18. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Az értékelések integrálása a CI/CD folyamatodba
  2. Az elv: Kapu, nem pedig jelentés
  3. Minden összekötése GitHub Actionsben
  4. Összehasonlítás az abszolút megítélés helyett
  5. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none erőfeszítési szintű következtetés (reasoning) esetén fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) következtetnek. Az ezeket a paramétereket beállító hívásoknak ezért expliciten meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

Az értékelések integrálása a CI/CD folyamatodba

Prompt-módosításokat tesztelés nélkül éles környezetbe deployolni olyan, mint kódolást teszt nélkül deployolni. Az összehasonlítás talán pontosabb, mint gondolnád: mindkét esetben a változtatás triviálisnak tűnik, manuálisan ellenőrizted egy-két példán, a mellékhatás pedig három nap múlva jelentkezik egy olyan felhasználónál, aki nem fog szólni neked. A különbség az, hogy egy prompt-regresszió nem dob kivételt – az alkalmazás továbbra is válaszol, csak rosszabbul.

A cél az, hogy az automatizált értékelést a deployolási folyamatod kötelező kapujává tedd, biztosítva, hogy minden változtatás fenntartsa vagy javítsa a minőséget. Pontosan ezt fogjuk most tárgyalni.

Az elv: Kapu, nem pedig jelentés

Az értékelési (eval) pipeline egy ismerős mechanizmus segítségével illeszkedik a deployolási folyamatodba. Egy fejlesztő módosít egy promptot vagy paramétert, a commit elindítja a CI pipeline-t, és az értékelések automatikusan lefutnak a referencia adathalmazon. Ha a pontszámok elérik a küszöbértékeket, a deployolás folytatódik; ellenkező esetben a rendszer blokkolja azt, egy részletes jelentést mellékelve, amely jelzi, melyik értékelés bukott meg, és mennyivel.

A kritikus pont a blokkoló viselkedés. Egy CI, amely csak egy szép jelentést generál anélkül, hogy megállítaná a pipeline-t, két hét után olyan artefaktummá válik, amelyet senki sem néz meg. Csak a nem nulla kilépési kód (exit code) teszi a mérést valódi védőkorláttá.

Az alábbi szkript beolvas egy konfigurációt, betölti az egyes adathalmazokat, lefuttatja az eseteket, és összehasonlítja az átlagos pontszámot a deklarált küszöbértékkel. A pontozási módszer – az egyszerű kulcsszó-ellenőrzés – szándékosan rudimentáris: egy CI-ellenőrzésnek gyorsnak, determinisztikusnak és függetlennek kell lennie egy bírótól (judge), whose pontszáma futtatásról futtatásra változhat.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Betölti az értékelési konfigurációt."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Betölt egy JSONL adathalmazt."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Lefuttatja az értékeléseket CI számára."""
    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,
            )

            # Egyszerű értékelés kulcsszavak alapján
            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  # Nincs specifikus kritérium

            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]:
    """Jelentést generál CI számára, és jelzi, ha minden rendben van."""
    lines = ["# AI Értékelési Jelentés\n"]
    all_pass = True

    for name, r in results.items():
        status = "SIKER" if r["passed"] else "HIBA"
        if not r["passed"]:
            all_pass = False
        lines.append(
            f"- [{status}] {name}: {r['score']:.2%} "
            f"(küszöb: {r['threshold']:.0%}, {r['num_cases']} eset)"
        )

    report = "\n".join(lines)
    return report, all_pass

Vedd észre, hogy a promptot egy fájlból olvassuk be, ahelyett, hogy közvetlenül a szkriptbe írnánk. Ez teszi lehetővé a triggerelést: egy verziókezelt prompt diffet eredményez, a diff pedig kiválthat egy értékelést. Amíg a promptjaid string literálokként szétszórva élnek az alkalmazáskódban, addig a megfelelő automatizálás lehetetlen.

A konfiguráció feladatonként egy-egy értékelést deklarál, mindegyiket saját küszöbértékkel.

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

E két küszöbérték közötti különbség a módszer szíve-lelke. A jegyosztályozás (ticket classification) egy zárt feladat: 0,90 alatt a funkció nem nyújtja a várt szolgáltatást. Az önéletrajz-generálás egy nyílt feladat, amelyet kulcsszavak alapján ítélnek meg, amelyeket egy jó szöveg jogosan fogalmazhat másképp; ha 0,90-et követelnénk, az minden deployolást blokkolna, és gyorsan ahhoz vezetne, hogy kikapcsolják az ellenőrzést. Minden küszöbértéket a productionben megfigyelt pontszámok alapján kalibrálj, ne pedig egy megnyugtatónak tűnő kerek szám alapján.

Minden összekötése GitHub Actionsben

A workflow csak a releváns útvonalakon indul el – promptok, értékelések, AI integrációs kód –, így egy stíluslap (stylesheet) módosítása nem fogyaszt API-hívásokat.

# .github/workflows/eval-ai.yml
name: AI Értékelés

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: Értékelések futtatása
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evals/run_ci.py

      - name: Jelentés közzététele
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: evals/report.md

Két részletet érdemes kiemelni. Az API-kulcs a tároló titkaiból (secrets) kerül átadásra, soha nem a workflow fájlból, amely bárki számára olvasható, aki hozzáfér a kódhoz. A jelentés közzététele pedig az if: always() feltételt használja; ellenkező esetben az artefaktum nem jönne létre, ha az értékelések megbuknának – pedig pontosan ez az egyetlen eset, amikor el kell olvasnod azt.

A belépő szkript fogja össze az egészet: lemezen írja a jelentést az artefaktum számára, kiírja a naplókba, és beállítja azt a kilépési kódot, amely engedélyezi vagy blokkolja a pipeline további részét.

#!/usr/bin/env python3
"""Értékelő szkript CI-hez — 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)

    # Jelentés írása
    Path("evals/report.md").write_text(report)
    print(report)

    # Kilépési kód CI számára
    if not all_pass:
        print("\nNéhány értékelés sikertelen volt. A deployolás blokkolva.")
        sys.exit(1)
    else:
        print("\nMinden értékelés sikeres.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Összehasonlítás az abszolút megítélés helyett

Egy fix küszöbérték arra a kérdésre ad választ, hogy „Ez elég jó?“. Arra nem, hogy „Ez jobb, mint az előző volt?“, pedig gyakran ez az igazi kérdés. Egy átírt prompt maradhat a küszöbérték felett, miközben három pontot veszít az előző verzióhoz képest: a CI zöldre vált, és a romlás észrevétlenül kerül éles környezetbe.

A regressziós teszt ezért mindkét verziót lefuttatja ugyanazon az adathalmazon, ugyanabban a kampányban, és összehasonlítja az átlagokat. Egy 5%-os tolerancia elnyeli a generatív kimenetekben rejlő zajt; efelett az ítélet egyértelmű.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Ellenőrzi, hogy egy új prompt nem rontja-e a teljesítményt."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Értékelés az aktuális prompttal
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Értékelés az előző prompttal
        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": "RENDBEN" if delta >= -degradation_threshold else "REGRESSZIÓ",
    }

Ez a teszt megduplázza a hívások számát, és ezzel együtt a költséget és az időtartamot is. Csak prompt-változtatásokra tartogasd, tartsd távol a hétköznapi commitok útjától, és egy reprezentatív részhalmazon futtasd a teljes referencia adathalmaz helyett.

Főbb megállapítások

  • Integráld az értékeléseket a CI/CD pipeline-odba, akárcsak az egységteszteket
  • Verziókezd a promptokat fájlokban: diff nélkül nincs triggerelés
  • Határozz meg minimális küszöbértékeket értékeléstípusonként, production adatok alapján kalibrálva
  • Blokkold a deployolásokat kilépési kóddal, ha a pontszámok a küszöbérték alá csökkennek
  • Tesztelj regressziót az új és régi promptok összehasonlításával ugyanazon az adathalmazon