Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

CI/CD priekš AI: Automatizēti vērtējumi

Nodarbība 18 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Vērtējumu integrēšana CI/CD konveijerā
  2. Princips: Slieksnis, nevis ziņojums
  3. Viss savienots GitHub Actions vidē
  4. Salīdzini, nevis vērtē absolūtos terminos
  5. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek pieņemti tikai ar spriešanas piepūli none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros iestatīti šie parametri, ir jānorāda reasoning={"effort": "none"} (Responses API) vai reasoning_effort="none" (Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.

Vērtējumu integrēšana CI/CD konveijerā

Uzvednes (prompt) izmaiņu izvēršana produkcionā bez vērtēšanas ir līdzīga koda izvēršanai bez testiem. Šis salīdzinājums ir precīzāks, nekā varētu šķist: abos gadījumos izmaiņas šķiet triviālas, tās ir manuāli pārbaudītas uz viena vai diviem piemēriem, un blakusefekts parādās trīs dienas vēlāk lietotājam, kurš tev par to nepaziņos. Atšķirība ir tāda, ka uzvednes regresija neizraisa izņēmumu – lietotne turpina atbildēt, tikai sliktāk.

Mērķis ir padarīt automatizētu vērtēšanu par obligātu slieksni izvēršanas procesā, nodrošinot, ka katra izmaiņa saglabā vai uzlabo kvalitāti. Tieši to mēs aplūkosim tālāk.

Princips: Slieksnis, nevis ziņojums

Vērtējumu konveijers integrējas tavā izvēršanas plūsmā, izmantojot pazīstamu mehānismu. Izstrādātājs modificē uzvedni vai parametru, commits iedarbina CI konveijeru, un vērtējumi tiek automātiski veikti pret atsauces datu kopu. Ja rezultāti sasniedz sliekšņus, izvēršana turpinās; pretējā gadījumā tā tiek bloķēta, sniedzot detalizētu ziņojumu, kurš norāda, kurš vērtējums neizdevās un par cik.

Kritiskais punkts ir šī bloķējošā uzvedība. CI, kas ģenerē skaistu ziņojumu, bet neaptur konveijeru, pēc divām nedēļām kļūst par artefaktu, ko neviens nepārbauda. Tikai nullei atšķirīgs izejas kods pārvērš mērījumus aizsargbarjerā.

Zemāk esošais skripts nolasa konfigurāciju, ielādē katru datu kopu, izpilda gadījumus un salīdzina vidējo rezultātu ar deklarēto slieksni. Vērtēšanas metode – vienkārša atslēgvārdu iekļaušana – ir apzināti primitīva: CI pārbaudei ir jābūt ātrai, determinētai un neatkarīgai no tiesneša, kura vērtējums var atšķirties no viena izpildes reizes uz otru.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Loads the evaluation configuration."""
    with open(path) as f:
        return json.load(f)

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

def run_ci_evals(config: dict) -> dict:
    """Runs evaluations for 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,
            )

            # Simple evaluation by keyword inclusion
            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  # No specific criterion

            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]:
    """Generates a report for CI and indicates if it's OK."""
    lines = ["# AI Evaluation Report\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"(threshold: {r['threshold']:.0%}, {r['num_cases']} cases)"
        )

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

Ņem vērā, ka uzvedne tiek nolasīta no faila, nevis rakstīta tieši skriptā. Tas ir tas, kas padara iedarbināšanu iespējamu: uzvedne, kas ir versijota repozitorijā, rada atšķirību (diff), un atšķirība var iedarbināt vērtējumu. Kamēr tavas uzvednes eksistē kā virkņu literāļi, kas izkaisīti pa lietotnes kodu, pareiza automatizācija nav iespējama.

Konfigurācija deklarē vienu vērtējumu katram uzdevumam, katram ar savu slieksni.

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

Atstarpe starp šiem diviem sliekšņiem ir metodes būtība. Biļešu klasifikācija ir slēgts uzdevums: zem 0,90 funkcija nenodrošina paredzēto servisu. Kopsavilkuma veidošana ir atvērts uzdevums, ko vērtē pēc atslēgvārdiem, ko labs teksts var likumīgi formulēt citādi; prasība pēc 0,90 bloķētu katru izvēršanu un ātri novestu pie pārbaudes atslēgšanas. Kalibrē katru slieksni, balstoties uz produkcionā novērotajiem rezultātiem, nevis uz noapaļotu skaitli, kas šķiet nomierinošs.

Viss savienots GitHub Actions vidē

Darbplūsma iedarbojas tikai uz attiecīgajiem ceļiem – uzvednēm, vērtējumiem, AI integrācijas kodu –, tāpēc stila lapas izmaiņas netērē API izsaukumus.

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

Ir vērts atzīmēt divas detaļas. API atslēga tiek nodota caur repozitorija noslēpumiem, nekad caur darbplūsmas failu, kas ir lasāms ikvienam ar piekļuvi kodam. Un ziņojuma publicēšana izmanto if: always(), pretējā gadījumā artefakts netiktu ģenerēts, ja vērtējumi neizdotos – kas ir tieši vienīgais gadījums, kad tev tas ir jālasa.

Ievades skripts visu savieno vienotā veselumā: tas ieraksta ziņojumu diskā artefaktam, izdrukā to žurnālos un iestata izejas kodu, kas ļauj vai bloķē pārējo konveijera daļu.

#!/usr/bin/env python3
"""Evaluation script for 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)

    # Write the report
    Path("evals/report.md").write_text(report)
    print(report)

    # Exit code for CI
    if not all_pass:
        print("\nSome evaluations failed. Deployment blocked.")
        sys.exit(1)
    else:
        print("\nAll evaluations pass.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Salīdzini, nevis vērtē absolūtos terminos

Fiksēts slieksnis atbild uz jautājumu „Vai tas ir pietiekami labs?”. Tas neatbild uz jautājumu „Vai tas ir labāks nekā iepriekš?”, kas bieži vien ir īstais jautājums. Pārrakstīta uzvedne var palikt virs sliekšņa, vienlaikus zaudējot trīs punktus salīdzinājumā ar iepriekšējo versiju: CI iedegas zaļš, un degradācija nonāk produkcionā, nevienam to nepamanot.

Tādēļ regresijas tests izpilda abas versijas uz vienas un tās pašas datu kopas, vienā un tajā pašā kampaņā, un salīdzina vidējos rādītājus. 5% pielaide absorbē troksni, kas raksturīgs ģeneratīvajām izejām; pārsniedzot to, spriedums ir skaidrs.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Verifies that a new prompt does not degrade performance."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Evaluate with current prompt
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Evaluate with previous prompt
        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",
    }

Šis tests dubulto izsaukumu skaitu, un līdz ar to arī izmaksas un ilgumu. Rezervē to uzvedņu izmaiņām, izvairoties no tā parasto commitu ceļā, un izpildi to uz reprezentatīvas apakškopas, nevis uz visas atsauces datu kopas.

Galvenās atziņas

  • Integrē vērtējumus savā CI/CD konveijerā tāpat kā vienības testus.
  • Versionē uzvednes failos: bez atšķirībām (diff) iedarbināšana nav iespējama.
  • Definē minimālos sliekšņus katram vērtējuma tipam, kalibrējot tos uz produkciona datiem.
  • Bloķē izvēršanas, izmantojot izejas kodu, ja rezultāti nokrītas zem sliekšņiem.
  • Testē regresijas, salīdzinot jaunās un vecās uzvednes uz vienas un tās pašas datu kopas.