Lähe põhisisu juurde
Eesti— Vali keel
Menüü

CI/CD AI jaoks: automatiseeritud hindamised

Õppetund 18 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Hindamiste integreerimine CI/CD torustikku
  2. Põhimõte: värav, mitte raport
  3. Kõige ühendamine GitHub Actionsis
  4. Võrdle pigem kui hindad absoluutväärtustes
  5. Peamised punktid

Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid temperature ja top_p aktsepteeritakse ainult siis, kui arutluse jõupingutus (reasoning effort) on määratud väärtusega none, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Seetõttu peavad need parameetrid määravad päringud sisaldama seadet reasoning={"effort": "none"} (Responses API) või reasoning_effort="none" (Chat Completions). Allikad: GPT-6 kasutamine · GPT-5.6 Terra.

Hindamiste integreerimine CI/CD torustikku

Viipe (prompt) muudatuse tootmisse viimine ilma hindamiseta on sama, kui viiksid koodi tootmisse ilma testideta. Võrdlus on täpsem, kui esmapilgul tundub: mõlemal juhul tundub muudatus tühine, see on käsitsi kontrollitud ühe või kahe näite põhjal ja kõrvalmõju avaldub kolm päeva hiljem kasutajale, kes sellest sulle ei räägi. Erinevus seisneb selles, et viipe regressioon ei tekita erindit – rakendus vastab edasi, lihtsalt halvemini.

Eesmärk on muuta automatiseeritud hindamine sinu kasutuselevõtuprotsessi kohustuslikuks väravaks, tagades, et iga muudatus säilitab või parandab kvaliteeti. Täpselt sellega tegelemegi edasi.

Põhimõte: värav, mitte raport

Hindamistorustik integreeritakse sinu kasutuselevõtuvoo tuttava mehhanismi kaudu. Arendaja muudab viipet või parameetrit, commit käivitab CI torustiku ja hindamised jooksevad automaatselt vastu võrdlusandmestikku. Kui tulemused ületavad lävendeid, jätkub kasutuselevõtt; vastasel juhul see blokeeritakse, esitades üksikasjaliku raporti, mis näitab, milline hindamine ebaõnnestus ja kui palju.

Kriitiline punkt on just see blokeeriv käitumine. CI, mis toodab ilusa raporti, kuid torustikku ei peata, muutub artefaktiks, mida keegi kahe nädala pärast enam ei kontrolli. Ainult nullist erinev väljumiskood muudab mõõtmise kaitseraudseks.

Allpool olev skript loeb konfiguratsiooni, laadib iga andmestiku, käivitab juhtumid ja võrdleb keskmist tulemust deklareeritud lävendiga. Hindamismeetod – lihtne märksõnade olemasolu kontroll – on tahtlikult rudimentaarne: CI kontroll peab olema kiire, deterministlik ja sõltumatu hindajast, kelle skoor võib ühest käivitusest teiseni muutuda.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Laadib hindamise konfiguratsiooni."""
    with open(path) as f:
        return json.load(f)

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

def run_ci_evals(config: dict) -> dict:
    """Käivitab hindamised CI jaoks."""
    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 nõuab effort none
                instructions=prompt,
                input=case["input"],
                temperature=0.0,
            )

            # Lihtne hindamine märksõnade olemasolu põhjal
            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  # Spetsiifiline kriteerium puudub

            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]:
    """Genereerib raporti CI jaoks ja näitab, kas kõik on korras."""
    lines = ["# AI hindamise raport\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"(lävend: {r['threshold']:.0%}, {r['num_cases']} juhtumit)"
        )

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

Pane tähele, et viipe loetakse failist, mitte ei kirjutata otse skripti. See võimaldabki käivitamist: repositooriumis versioonitud viipe tekitab diff-i ja diff saab käivitada hindamise. Niikaua kui su viiped eksisteerivad stringiliteralidena laiali hajutatuna rakenduse koodis, pole korralik automatiseerimine võimalik.

Konfiguratsioon deklareerib iga ülesande kohta ühe hindamise, üks oma lävendiga.

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

Nende kahe lävendi vaheline erinevus on meetodi tuum. Piletite klassifitseerimine on suletud ülesanne: alla 0,90 ei paku funktsioon oodatud teenust. Kokkuvõtete tegemine on avatud ülesanne, mida hinnatakse märksõnade põhjal, mida hea tekst võib õigustatult sõnastada teisiti; 0,90 nõudmine blokeeriks iga kasutuselevõtu ja viiks kiiresti kontrolli väljalülitamiseni. Kalibreeri iga lävend tootmises täheldatud tulemuste põhjal, mitte ümardatud numbri järgi, mis lihtsalt tundub turvaline.

Kõige ühendamine GitHub Actionsis

Töövoog käivitub ainult asjakohaste radade muutumisel – viiped, hindamised, AI integratsiooni kood –, et stiililehe muutus ei tarbiks API kõnesid.

# .github/workflows/eval-ai.yml
name: AI hindamine

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: Käivita hindamised
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evals/run_ci.py

      - name: Avalda raport
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: evals/report.md

Kaks detaili väärib märkimist. API võti edastatakse repositooriumi saladuste (secrets) kaudu, mitte kunagi töövoogu faili, mis on loetav kõigile, kellel on koodile juurdepääs. Raporti avaldamine kasutab if: always(), vastasel juhul artefakti ei loodaks, kui hindamised ebaõnnestuvad – mis ongi ainus juhus, kui sul seda lugeda vaja on.

Sissejuhatav skript seob kõik kokku: see kirjutab raporti kettale artefakti jaoks, trükib selle logidesse ja määrab väljumiskoodi, mis lubab või blokeerib ülejäänud torustiku.

#!/usr/bin/env python3
"""Hindamisskript CI jaoks — 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)

    # Kirjuta raport
    Path("evals/report.md").write_text(report)
    print(report)

    # Väljumiskood CI jaoks
    if not all_pass:
        print("\nMõned hindamised ebaõnnestusid. Kasutuselevõtt blokeeritud.")
        sys.exit(1)
    else:
        print("\nKõik hindamised õnnestusid.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Võrdle pigem kui hindad absoluutväärtustes

Fikseeritud lävend vastab küsimusele „Kas see on piisavalt hea?“. See ei vasta küsimusele „Kas see on parem kui varem?“, mis on sageli tegelik küsimus. Ümberkirjutatud viipe võib jääda üle lävendi, kaotades eelmise versiooniga võrreldes kolm punkti: CI muutub roheliseks ja halvenemine jõuab tootmisse, ilma et keegi seda märkaks.

Seetõttu käivitab regressioonitest mõlemat versiooni samal andmestikul, samas kampaanias, ja võrdleb keskmisi tulemusi. 5% tolerants neelab genereerivate väljundite olemusliku müra; sellest kaugemal on verdict selge.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Kontrollib, et uus viipe ei halvendaks jõudlust."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Hindamine praeguse viipega
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature nõuab effort none
            input=case["input"], temperature=0.0,
        )
        # Hindamine eelmise viipega
        r2 = client.responses.create(
            model=model, instructions=previous_prompt,
            reasoning={"effort": "none"},  # temperature nõuab 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 "REGRESSIOON",
    }

See test kahekordistab kõnede arvu ja seega ka kulusid ning kestust. Kasuta seda ainult viipe muudatuste jaoks, hoides seda tavaliste commit’ide teelt eemal, ja käivita see esinduslikul alamhulgal, mitte kogu võrdlusandmestikku.

Peamised punktid

  • Integreeri hindamised oma CI/CD torustikku nagu ühiktestid
  • Versioneeri viiped failidena: ilma diff-ita pole käivitamine võimalik
  • Määra iga hindamistüübi jaoks miinimumlävendid, kalibreeritud tootmisandmete põhjal
  • Blokeeri kasutuselevõtud väljumiskoodi kaudu, kui tulemused langevad alla lävendite
  • Testi regressioone, võrreldes uusi ja vanu viipeid samal andmestikul