Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

CI/CD pre AI: Automatizované hodnotenia

Lekcia 18 z 20 Aktualizované 3. novembra 2026 Pokročilý
Na tejto strane
  1. Integrácia hodnotení (Evals) do vášho CI/CD pipeline
  2. Princíp: Brána, nie správa
  3. Prepojenie všetkého v GitHub Actions
  4. Porovnávaj namiesto absolútneho hodnotenia
  5. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Používanie GPT-6 · GPT-5.6 Terra.

Integrácia hodnotení (Evals) do vášho CI/CD pipeline

Nasadenie zmeny promptu do produkcie bez hodnotenia je ako nasadenie kódu bez testov. Toto prirovnanie je presnejšie, než by sa mohlo zdať: v oboch prípadoch sa zmena javí ako triviálna, bola manuálne overená na jednom či dvoch príkladoch a vedľajší účinok sa prejaví o tri dni u používateľa, ktorý vám o tom nepovie. Rozdiel je v tom, že regresia promptu nevyhodí výnimku – aplikácia stále odpovedá, len horšie.

Cieľom je urobiť z automatizovaného hodnotenia povinnú bránu vo vašom procese nasadzovania, ktorá zabezpečí, že každá zmena udrží alebo zlepší kvalitu. Presne tomu sa budeme venovať ďalej.

Princíp: Brána, nie správa

Pipeline hodnotení sa integruje do vášho nasadzovacieho toku pomocou známeho mechanizmu. Vývojár upraví prompt alebo parameter, commit spustí CI pipeline a hodnotenia sa automaticky spustia proti referenčnej množine dát. Ak skóre dosiahnu prahové hodnoty, nasadenie pokračuje; inak je zablokované a poskytne sa podrobná správa ukazujúca, ktoré hodnotenie zlyhalo a o koľko.

Kritickým bodom je práve toto blokovacie správanie. CI, ktoré vyprodukuje peknú správu, ale nezastaví pipeline, sa stane artefaktom, ktorý po dvoch týždňoch nikto nekontroluje. Len nenulový exit kód premení meranie na ochrannú bariéru.

Skript nižšie číta konfiguráciu, načíta každú množinu dát, spustí prípady a porovná priemerné skóre s deklarovaným prahom. Metóda bodovania – jednoduchá inklúzia kľúčových slov – je zámerne rudimentárna: kontrola CI musí byť rýchla, deterministická a nezávislá od hodnotiteľa (judge), ktorého skóre sa môže líšiť od jedného spustenia k druhému.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Načíta konfiguráciu hodnotenia."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Načíta dataset vo formáte 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í hodnotenia pre 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 vyžaduje effort none
                instructions=prompt,
                input=case["input"],
                temperature=0.0,
            )

            # Jednoduché hodnotenie podľa inklúzie kľúč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  # Žiadne špecifické 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]:
    """Generuje správu pre CI a indikuje, či je všetko v poriadku."""
    lines = ["# Správa o hodnotení 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']} prípadov)"
        )

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

Všimni si, že prompt sa číta zo súboru, namiesto toho, aby bol napísaný priamo v skripte. To je to, čo umožňuje spúšťanie: prompt verzionovaný v repozitári vytvorí diff a diff môže spustiť hodnotenie. Pokiaľ tvoje prompty existujú ako reťazcové literály roztrúsené po celom kóde aplikácie, správna automatizácia nie je možná.

Konfigurácia deklaruje jedno hodnotenie na úlohu, každé s vlastným prahom.

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

Rozdiel medzi týmito dvoma prahmi je srdcom tejto metódy. Klasifikácia ticketov je uzavretá úloha: pod 0,90 funkcia neposkytuje očakávanú službu. Zhrnutie je otvorená úloha, hodnotená podľa kľúčových slov, ktoré dobrý text môže legitímne formulovať inak; požiadavka na 0,90 by zablokovala každé nasadenie a rýchlo by viedla k vypnutiu kontroly. Každý prah kalibruj na základe skóre pozorovaných v produkcii, nie na základe zaokrúhleného čísla, ktoré pôsobí upokojujúco.

Prepojenie všetkého v GitHub Actions

Workflow sa spustí len pri relevantných cestách – prompty, hodnotenia, kód integrácie AI – aby zmena štýlového listu nezbytočne nespotrebúvala volania 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

Dva detaily stoja za zmienku. Kľúč API prechádza cez tajomstvá repozitára (secrets), nikdy nie cez súbor workflow, ktorý je čitateľný pre každého s prístupom ku kódu. A publikovanie správy používa if: always(), inak by sa artefakt nevytvoril, keď hodnotenia zlyhajú – čo je presne ten jediný prípad, kedy si ho potrebuješ prečítať.

Vstupný skript všetko spája: zapíše správu na disk pre artefakt, vypíše ju do logov a nastaví exit kód, ktorý umožní alebo zablokuje zvyšok pipeline.

#!/usr/bin/env python3
"""Skript hodnotenia pre 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 správy
    Path("evals/report.md").write_text(report)
    print(report)

    # Exit kód pre CI
    if not all_pass:
        print("\nNiektoré hodnotenia zlyhali. Nasadenie zablokované.")
        sys.exit(1)
    else:
        print("\nVšetky hodnotenia prešli.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Porovnávaj namiesto absolútneho hodnotenia

Pevný prah odpovedá na otázku „Je toto dostatočne dobré?“. Neodpovedá však na otázku „Je toto lepšie ako predtým?“, čo je často tá skutočná otázka. Prepísaný prompt môže zostať nad prahom, ale stratiť tri body oproti predchádzajúcej verzii: CI sa sfarbí na zeleno a degradácia sa dostane do produkcie, aniž by si to niekto všimol.

Test regresie preto spustí obe verzie na tej istej množine dát, v rámci tej istej kampane, a porovná priemery. Tolerancia 5 % absorbuje šum inherentný generatívnym výstupom; nad touto hranicou je verdikt explicitný.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Overí, že nový prompt nezhoršuje výkon."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Hodnotenie s aktuálnym promptom
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature vyžaduje effort none
            input=case["input"], temperature=0.0,
        )
        # Hodnotenie s predchádzajúcim promptom
        r2 = client.responses.create(
            model=model, instructions=previous_prompt,
            reasoning={"effort": "none"},  # temperature vyžaduje 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 "REGRESIA",
    }

Tento test zdvojnásobí počet volaní, a tým aj náklady a trvanie. Vyhradzuj ho pre zmeny promptov, nechaj ho mimo cesty bežných commitov a spúšťaj ho na reprezentatívnej podmnožine, nie na celej tvojej referenčnej množine dát.

Kľúčové poznatky

  • Integruj hodnotenia do svojho CI/CD pipeline ako unit testy
  • Verzionuj prompty v súboroch: bez diffu nie je možné spúšťanie
  • Definuj minimálne prahy pre každý typ hodnotenia, kalibrované na dátach z produkcie
  • Blokuj nasadenia pomocou exit kódu, keď skóre klesnú pod prahy
  • Testuj regresie porovnaním nových a starých promptov na tej istej množine dát