CI/CD az AI-hoz: Automatizált értékelések
Ezen az oldalon
Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a
temperatureés atop_pparaméterek csaknoneerő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 areasoning={"effort": "none"}(Responses API) vagyreasoning_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