CI/CD pro AI: Automatizovaná evaluace
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(Responses API) neboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Integrace evaluací do tvého CI/CD pipeline
Nasazení změny promptu do produkce bez evaluace je jako nasazení kódu bez testů. To přirovnání je přesnější, než by se mohlo zdát: v obou případech se změna zdá triviální, byla ručně ověřena na jednom či dvou příkladech a vedlejší efekt se projeví o tři dny později u uživatele, který ti o tom neřekne. Rozdíl je v tom, že regrese promptu nezvedne výjimku – aplikace stále odpovídá, jen hůře.
Cílem je učinit z automatizované evaluace povinnou bránu v tvém nasazovacím procesu, která zajistí, že každá změna udržuje nebo zlepšuje kvalitu. Přesně tím se budeme zabývat dál.
Princip: Brána, nikoliv report
Pipeline evaluace se integruje do tvého nasazovacího toku pomocí známého mechanismu. Vývojář upraví prompt nebo parametr, commit spustí CI pipeline a evaluace se automaticky provedou proti referenční sadě dat. Pokud skóre dosáhnou prahových hodnot, nasazení pokračuje; v opačném případě je zablokováno a podrobný report uvede, která evaluace selhala a o kolik.
Klíčovým bodem je právě toto blokovací chování. CI, které pouze vygeneruje hezký report, ale nezastaví pipeline, se stane artefaktem, který po dvou týdnech nikdo nekontroluje. Pouze nenulový exit kód promění měření v ochranný prvek.
Následující skript načte konfiguraci, načte každou sadu dat, spustí testovací případy a porovná průměrné skóre s deklarovaným prahem. Metoda hodnocení – jednoduchá kontrola přítomnosti klíčových slov – je záměrně rudimentární: kontrola v CI musí být rychlá, deterministická a nezávislá na soudci, jehož hodnocení se může mezi jednotlivými běhy lišit.
import json
import sys
import openai
from pathlib import Path
client = openai.OpenAI()
def load_eval_config(path: str = "evals/config.json") -> dict:
"""Načte konfiguraci evaluace."""
with open(path) as f:
return json.load(f)
def load_dataset(path: str) -> list[dict]:
"""Načte dataset ve formátu JSONL."""
cases = []
with open(path) as f:
for line in f:
cases.append(json.loads(line))
return cases
def run_ci_evals(config: dict) -> dict:
"""Spustí evaluace pro 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,
)
# Jednoduché hodnocení podle přítomnosti klíčových slov
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 # Žádné specifické 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]:
"""Vygeneruje report pro CI a indikuje, zda je vše v pořádku."""
lines = ["# Report z evaluace AI\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"(prah: {r['threshold']:.0%}, {r['num_cases']} případů)"
)
report = "\n".join(lines)
return report, all_pass
Všimni si, že prompt je čten ze souboru, nikoliv zapsán přímo ve skriptu. To je to, co umožňuje spuštění: prompt verzionovaný v repozitáři vytvoří diff a diff může spustit evaluaci. Dokud budou tvoje prompty existovat jako řetězcové literály rozptýlené v kódu aplikace, není řádná automatizace možná.
Konfigurace deklaruje jednu evaluaci na úkol, každou s vlastním prahem.
{
"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
}
]
}
Rozdíl mezi těmito dvěma prahy je jádrem metody. Klasifikace tiketů je uzavřený úkol: pod hodnotou 0,90 funkce neposkytuje očekávanou službu. Shrnutí je otevřený úkol, hodnocený podle klíčových slov, která může dobrý text legitimně formulovat jinak; požadavek na 0,90 by zablokoval každé nasazení a rychle by vedl k vypnutí této kontroly. Každý prah kalibruj na základě skóre pozorovaných v produkci, nikoliv na základě zaokrouhleného čísla, které působí uklidňujícím dojmem.
Propojení všeho v GitHub Actions
Workflow se spouští pouze u relevantních cest – prompty, evaluace, kód integrace AI – takže změna stylesheetu nespotřebovává volání API.
# .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
Stojí za zmínku dva detaily. Klíč API prochází přes tajné proměnné repozitáře, nikdy přes soubor workflow, který je čitelný pro každého, kdo má přístup ke kódu. A publikování reportu používá if: always(), jinak by artefakt nebyl vytvořen, když evaluace selžou – což je přesně ten jediný případ, kdy si ho potřebuješ přečíst.
Vstupní skript vše spojuje: zapíše report na disk pro artefakt, vytiskne ho do logů a nastaví exit kód, který umožní nebo zablokuje zbytek pipeline.
#!/usr/bin/env python3
"""Skript pro evaluaci v 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)
# Zápis reportu
Path("evals/report.md").write_text(report)
print(report)
# Exit kód pro CI
if not all_pass:
print("\nNěkteré evaluace selhaly. Nasazení zablokováno.")
sys.exit(1)
else:
print("\nVšechny evaluace prošly.")
sys.exit(0)
if __name__ == "__main__":
main()
Porovnávej, místo abys soudil v absolutních číslech
Pevný prah odpovídá na otázku „Je to dost dobré?“. Neodpovídá na otázku „Je to lepší než dříve?“, což je často ta skutečná otázka. Přepsaný prompt může zůstat nad prahem, ale ztratit tři body oproti předchozí verzi: CI se zazelená a degradace se dostane do produkce, aniž by si toho někdo všiml.
Test regrese proto spustí obě verze na stejné sadě dat, ve stejné kampani, a porovná průměry. Tolerance 5 % absorbuje šum inherentní generativním výstupům; nad tuto hranici je verdikt explicitní.
def prompt_regression_test(
current_prompt: str,
previous_prompt: str,
dataset: list[dict],
model: str,
degradation_threshold: float = 0.05,
) -> dict:
"""Ověří, že nový prompt nezhoršuje výkon."""
scores_current = []
scores_previous = []
for case in dataset:
# Evaluace s aktuálním promptem
r1 = client.responses.create(
model=model, instructions=current_prompt,
reasoning={"effort": "none"}, # temperature requires effort none
input=case["input"], temperature=0.0,
)
# Evaluace s předchozím promptem
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",
}
Tento test zdvojnásobí počet volání, a tím i náklady a dobu trvání. Vyhraď si jej pro změny promptů, udržuj jej mimo cestu běžných commitů a spouštěj jej na reprezentativní podmnožině, nikoliv na celé referenční sadě dat.
Klíčové poznatky
- Integruj evaluace do svého CI/CD pipeline stejně jako unit testy
- Verzionuj prompty v souborech: bez diffu není možné žádné spuštění
- Definuj minimální prahy pro každý typ evaluace, kalibrované na produkčních datech
- Blokuj nasazení pomocí exit kódu, když skóre klesnou pod prahy
- Testuj regrese porovnáním nových a starých promptů na stejné sadě dat