Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

CI/CD pro AI: Automatizovaná evaluace

Lekce 18 z 20 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Integrace evaluací do tvého CI/CD pipeline
  2. Princip: Brána, nikoliv report
  3. Propojení všeho v GitHub Actions
  4. Porovnávej, místo abys soudil v absolutních číslech
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (Responses API) nebo reasoning_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