Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

CI/CD za AI: Avtomatizirane evalvacije

Lekcija 18 od 20 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Integracija evalvacij v vaš cevovod CI/CD
  2. Načelo: Zapornica, ne poročilo
  3. Povezava vsega v GitHub Actions
  4. Primerjaj namesto absolutnega ocenjevanja
  5. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra temperature in top_p sta sprejeta le pri naporu razmišljanja (reasoning effort) vrednosti none, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določiti reasoning={"effort": "none"} (Responses API) ali reasoning_effort="none" (Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Integracija evalvacij v vaš cevovod CI/CD

Uvedba spremembe poziva (prompt) v proizvodno okolje brez evalvacije je kot uvedba kode brez testov. Primerjava je bolj natančna, kot se morda zdi: v obeh primerih se sprememba zdi trivialna, ročno je bila preverjena na enem ali dveh primerih, stranski učinek pa se pokaže tri dni kasneje pri uporabniku, ki vam tega ne bo sporočil. Razlika je v tem, da regresija poziva ne vrže izjeme – aplikacija še naprej odgovarja, le slabše.

Cilj je narediti avtomatizirano evalvacijo obvezen korak v vašem postopku uvajanja, ki zagotavlja, da vsaka sprememba ohranja ali izboljša kakovost. Točno to bomo obravnavali v nadaljevanju.

Načelo: Zapornica, ne poročilo

Cevovod evalvacij se v vaš postopek uvajanja vključi z uporabo znanega mehanizma. Razvijalec spremeni poziv ali parameter, potrditev (commit) sproži cevovod CI in evalvacije se samodejno zaženejo na referenčnem naboru podatkov. Če rezultati dosežejo pragove, se uvajanje nadaljuje; v nasprotnem primeru je blokirano, podrobno poročilo pa navede, katera evalvacija je spodletela in za koliko.

Ključna točka je vedenje blokiranja. CI, ki ustvari lepo poročilo, a ne ustavi cevovoda, postane artefakt, ki ga po dveh tednih nihče ne preveri. Le koda izhoda, različna od nič, spremeni merjenje v varovalko.

Spodnja skripta prebere konfiguracijo, naloži vsak nabor podatkov, zažene primere in povprečni rezultat primerja z deklariranim pragom. Metoda ocenjevanja – preprosta vključitev ključnih besed – je namerno osnovna: preverjanje CI mora biti hitro, deterministično in neodvisno od sodnika, katerega ocena se lahko od zagona do zagona razlikuje.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Naloži konfiguracijo evalvacije."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Naloži nabor podatkov 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:
    """Zažene evalvacije 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,
            )

            # Preprosta evalvacija z vključitvijo ključnih besed
            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  # Ni specifičnega merila

            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]:
    """Ustvari poročilo za CI in označi, ali je vse v redu."""
    lines = ["# Poročilo o evalvaciji 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"(prag: {r['threshold']:.0%}, {r['num_cases']} primerov)"
        )

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

Opazi, da se poziv prebere iz datoteke in ni zapisan neposredno v skripti. To omogoča sprožanje: različica poziva v repozitoriju ustvari razliko (diff), razlika pa lahko sproži evalvacijo. Dokler so vaši pozivi kot nizni literali razpršeni po kodi vaše aplikacije, ustrezna avtomatizacija ni mogoča.

Konfiguracija za vsako nalogo določi eno evalvacijo, vsako z lastnim 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
    }
  ]
}

Razlika med tema dvema pragovoma je bistvo metode. Klasifikacija vstopnic je zaprta naloga: pod 0,90 funkcija ne zagotavlja pričakovane storitve. Povzemanje je odprta naloga, ocenjena na podlagi ključnih besed, ki jih lahko dobro besedilo upravičeno oblikuje drugače; zahteva 0,90 bi blokirala vsako uvedbo in hitro pripeljala do izklopa preverjanja. Vsak prag umerite glede na rezultate, opažene v proizvodnem okolju, in ne glede na okroglo število, ki deluje pomirjujoče.

Povezava vsega v GitHub Actions

Delovni tok se sproži le na ustreznih poteh – pozivi, evalvacije, koda za integracijo AI – tako da sprememba slogovne predloge ne porabi klicev 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

Omeniti velja dve podrobnosti. Ključ API se prenese preko skrivnosti repozitorija, nikoli preko datoteke delovnega toka, ki je berljiva za vsakogar z dostopom do kode. Objava poročila uporablja if: always(), sicer artefakt ne bi bil ustvarjen, ko evalvacije spodletijo – kar je ravno edini primer, ko ga potrebujete prebrati.

Vstopna skripta vse poveže: poročilo zapiše na disk za artefakt, ga izpiše v dnevnike in nastavi kodo izhoda, ki omogoča ali blokira preostanek cevovoda.

#!/usr/bin/env python3
"""Skripta za evalvacijo 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 poročilo
    Path("evals/report.md").write_text(report)
    print(report)

    # Koda izhoda za CI
    if not all_pass:
        print("\nNekatere evalvacije so spodletele. Uvajanje blokirano.")
        sys.exit(1)
    else:
        print("\nVse evalvacije so uspešne.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Primerjaj namesto absolutnega ocenjevanja

Fiksni prag odgovori na vprašanje „Ali je to dovolj dobro?”. Ne odgovori pa na vprašanje „Ali je to bolje kot prej?”, kar je pogosto pravo vprašanje. Na novo napisan poziv lahko ostane nad pragom, a izgubi tri točke v primerjavi s prejšnjo različico: CI se obarva zeleno in poslabšanje pride v proizvodno okolje, ne da bi kdo opazil.

Test regresije zato zažene obe različici na istem naboru podatkov, v isti kampanji, in primerja povprečja. Toleranca 5 % absorbira šum, neločljiv od generativnih izhodov; onkraj tega je sodba izrecna.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Preveri, ali nov poziv ne poslabša zmogljivosti."""
    scores_current = []
    scores_previous = []

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

Ta test podvoji število klicev in s tem stroške ter trajanje. Rezerviraj ga za spremembe pozivov, odstrani ga iz poti običajnih potrditev (commitov) in ga zaženi na reprezentativnem podnaboru, ne na celotnem referenčnem naboru podatkov.

Ključne ugotovitve

  • Integriraj evalvacije v svoj cevovod CI/CD kot enotske teste
  • Različici pozivov v datotekah: brez razlike (diff) sprožanje ni mogoče
  • Določi minimalne pragove za vsako vrsto evalvacije, umerjene na podatkih iz proizvodnje
  • Blokiraj uvajanja preko kode izhoda, ko rezultati padejo pod pragove
  • Testiraj regresije s primerjavo novih in starih pozivov na istem naboru podatkov