Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

CI/CD za AI: Evaluacije automatizirane

Lekcija 18 od 20 Ažurirano 3. studenoga 2026. Napredno
Na ovoj stranici
  1. Integracija evaluacija u tvoj CI/CD pipeline
  2. Načelo: Prolaz, a ne izvješće
  3. Povezivanje svega u GitHub Actions
  4. Uspoređuj umjesto da sudiš u apsolutnim izrazima
  5. Ključne točke

Lekcija ažurirana 3. studenog 2026. na temelju OpenAI dokumentacije: parametri temperature i top_p prihvaćeni su samo uz napor rezoniranja (reasoning effort) vrijednosti none, dok modeli GPT-5.6 prema zadanim postavkama rezoniraju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificirati reasoning={"effort": "none"} (Responses API) ili reasoning_effort="none" (Chat Completions). Izvori: Korištenje GPT-6 · GPT-5.6 Terra.

Integracija evaluacija u tvoj CI/CD pipeline

Objavljivanje promjene prompta u produkciju bez evaluacije isto je što i objavljivanje koda bez testova. Ta je usporedba točnija nego što se čini: u oba slučaja promjena djeluje trivijalno, ručno je provjerena na jednom ili dva primjera, a nuspojava se pojavi tri dana kasnije kod korisnika koji ti to neće javiti. Razlika je u tome što regresija prompta ne baca iznimku – aplikacija nastavlja odgovarati, samo lošije.

Cilj je učiniti automatiziranu evaluaciju obaveznim prolazom u tvom procesu objavljivanja, osiguravajući da svaka promjena zadrži ili poboljša kvalitetu. Upravo ćemo to sada pokriti.

Načelo: Prolaz, a ne izvješće

Pipeline evaluacija integrira se u tvoj tijek objavljivanja koristeći poznati mehanizam. Programer modificira prompt ili parametar, commit pokreće CI pipeline, a evaluacije se automatski pokreću na referentnom skupu podataka. Ako rezultati zadovolje pragove, objavljivanje se nastavlja; u suprotnom je blokirano, uz detaljno izvješće koje pokazuje koja je evaluacija pala i za koliko.

Kritična točka je to ponašanje blokiranja. CI koji proizvodi lijepo izvješće, a ne zaustavlja pipeline, postaje artefakt koji nitko ne provjerava nakon dva tjedna. Samo kod izlaza različit od nule pretvara mjerenje u zaštitnu ogradu.

Skripta u nastavku čita konfiguraciju, učitava svaki skup podataka, pokreće slučajeve i uspoređuje prosječni rezultat s deklariranim pragom. Metoda bodovanja – jednostavna uključenost ključnih riječi – namjerno je rudimentarna: CI provjera mora biti brza, deterministička i neovisna o sucu čiji bi se rezultat mogao mijenjati iz pokretanja u pokretanje.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Učitava konfiguraciju evaluacije."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Učitava JSONL skup podataka."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Pokreće evaluacije za 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,
            )

            # Jednostavna evaluacija putem uključenosti ključnih riječi
            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  # Nema specifičnog kriterija

            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]:
    """Generira izvješće za CI i označava je li sve u redu."""
    lines = ["# Izvješće o AI evaluaciji\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"(prag: {r['threshold']:.0%}, {r['num_cases']} slučajeva)"
        )

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

Primijeti da se prompt čita iz datoteke umjesto da je zapisan izravno u skripti. To je ono što omogućuje okidanje: prompt verzioniran u repozitoriju proizvodi diff, a diff može okinuti evaluaciju. Dokle god tvoji promptovi žive kao string literali raspršeni kroz kod tvoje aplikacije, pravilna automatizacija nije moguća.

Konfiguracija deklarira jednu evaluaciju po zadatku, svaku s vlastitim pragom.

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

Jaz između ova dva praga srce je metode. Klasifikacija tiketa zatvoren je zadatak: ispod 0,90 značajka ne isporučuje očekivanu uslugu. Sažimanje je otvoren zadatak, procijenjen na ključnim riječima koje dobar tekst legitimno može drugačije formulirati; zahtijevanje 0,90 blokiralo bi svako objavljivanje i brzo dovelo do isključivanja provjere. Kalibriraj svaki prag na temelju rezultata uočenih u produkciji, a ne na temelju okruglog broja koji djeluje umirujuće.

Povezivanje svega u GitHub Actions

Tijek rada okida se samo na relevantnim putanjama – promptovi, evaluacije, kod za AI integraciju – tako da promjena stilskog lista ne troši API pozive.

# .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

Vrijedna su dva detalja. API ključ prolazi kroz tajne repozitorija, nikada kroz datoteku tijeka rada, koju može čitati svatko tko ima pristup kodu. A objava izvješća koristi if: always(), inače artefakt ne bi bio proizveden kada evaluacije padnu – što je upravo jedini slučaj kada ga trebaš pročitati.

Ulazna skripta povezuje sve: piše izvješće na disk za artefakt, ispisuje ga u logove i postavlja kod izlaza koji omogućuje ili blokira ostatak pipelinea.

#!/usr/bin/env python3
"""Skripta za evaluaciju za 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)

    # Zapiši izvješće
    Path("evals/report.md").write_text(report)
    print(report)

    # Kod izlaza za CI
    if not all_pass:
        print("\nNeke evaluacije nisu prošle. Objavljivanje blokirano.")
        sys.exit(1)
    else:
        print("\nSve evaluacije su prošle.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Uspoređuj umjesto da sudiš u apsolutnim izrazima

Fiksni prag odgovara na pitanje „Je li ovo dovoljno dobro?“. Ne odgovara na pitanje „Je li ovo bolje nego prije?“, što je često pravo pitanje. Prepisani prompt može ostati iznad praga dok gubi tri boda u odnosu na prethodnu verziju: CI postaje zelen, a degradacija ulazi u produkciju, a da nitko to ne primijeti.

Test regresije stoga pokreće obje verzije na istom skupu podataka, u istoj kampanji, i uspoređuje prosjeke. Tolerancija od 5% apsorbira šum svojstven generativnim izlazima; iznad toga, presuda je eksplicitna.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Provjerava da novi prompt ne degradira performanse."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Evaluiraj s trenutnim promptom
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Evaluiraj s prethodnim promptom
        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 "REGRESIJA",
    }

Ovaj test udvostručuje broj poziva, a time i trošak te trajanje. Rezerviraj ga za promjene prompta, držeći ga izvan puta običnih commita, i pokreni ga na reprezentativnom podskupu, a ne na cijelom referentnom skupu podataka.

Ključne točke

  • Integriraj evaluacije u svoj CI/CD pipeline poput jediničnih testova
  • Verzioniraj promptove u datotekama: bez differa, okidanje nije moguće
  • Definiraj minimalne pragove po vrsti evaluacije, kalibrirane na podacima iz produkcije
  • Blokiraj objavljivanja putem koda izlaza kada rezultati padnu ispod pragova
  • Testiraj regresije usporedbom novih i starih promptova na istom skupu podataka