Salt la conținutul principal
Română— Alege o limbă
Meniu

CI/CD pentru AI: Evaluări automate

Lecția 18 din 20 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Integrarea evaluărilor în pipeline-ul CI/CD
  2. Principiul: O barieră, nu un raport
  3. Conectarea tuturor în GitHub Actions
  4. Comparați mai degrabă decât să judecați în termeni absoluți
  5. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API-ul Responses) sau reasoning_effort="none" (Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Integrarea evaluărilor în pipeline-ul CI/CD

Lansarea unei modificări de prompt în producție fără evaluare este echivalentul lansării unui cod fără teste. Comparația este mai exactă decât pare: în ambele cazuri, modificarea pare trivială, a fost verificată manual pe unul sau două exemple, iar efectul secundar apare trei zile mai târziu pentru un utilizator care nu vă va spune nimic. Diferența este că o regresie de prompt nu aruncă o excepție—aplicația continuă să răspundă, doar că mai prost.

Obiectivul este de a face evaluarea automată o etapă obligatorie în procesul de implementare, asigurându-vă că fiecare modificare menține sau îmbunătățește calitatea. Exact despre asta vom discuta în continuare.

Principiul: O barieră, nu un raport

Pipeline-ul de evaluare se integrează în fluxul de implementare folosind un mecanism familiar. Un dezvoltator modifică un prompt sau un parametru, commit-ul declanșează pipeline-ul CI, iar evaluările rulează automat pe setul de date de referință. Dacă scorurile ating pragurile, implementarea continuă; în caz contrar, este blocată, împreună cu un raport detaliat care indică ce evaluare a eșuat și cu cât.

Punctul critic este comportamentul de blocare. Un CI care produce un raport frumos fără a opri pipeline-ul devine un artefact pe care nimeni nu îl verifică după două săptămâni. Doar un cod de ieșire diferit de zero transformă măsurătoarea într-o gardă de siguranță.

Scriptul de mai jos citește o configurație, încarcă fiecare set de date, rulează cazurile și compară scorul mediu cu pragul declarat. Metoda de scorare—includerea simplă a cuvintelor cheie—este intenționat rudimentară: o verificare CI trebuie să fie rapidă, deterministă și independentă de un judecător al cărui scor ar putea varia de la o rulare la alta.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Încarcă configurația de evaluare."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Încarcă un set de date 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:
    """Rulează evaluările pentru 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,
            )

            # Evaluare simplă prin includerea cuvintelor cheie
            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  # Niciun criteriu specific

            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]:
    """Generează un raport pentru CI și indică dacă este OK."""
    lines = ["# Raport de evaluare 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']} cazuri)"
        )

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

Observați că promptul este citit dintr-un fișier, nu scris direct în script. Acest lucru face posibilă declanșarea: o versiune a promptului gestionată în repository produce un diff, iar un diff poate declanșa o evaluare. Atâta timp cât prompturile dumneavoastră există ca șiruri de caractere împrăștiate în codul aplicației, automatizarea corectă nu este posibilă.

Configurația declară o evaluare per sarcină, fiecare cu propriul său prag.

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

Diferența dintre aceste două praguri este esența metodei. Clasificarea tichetelor este o sarcină închisă: sub 0,90, funcționalitatea nu livrează serviciul așteptat. Rezumarea este o sarcină deschisă, judecată pe cuvinte cheie pe care un text bun le-ar putea formula legitim diferit; cererea unui prag de 0,90 ar bloca fiecare implementare și ar duce rapid la dezactivarea verificării. Calibrați fiecare prag pe baza scorurilor observate în producție, nu pe un număr rotund care pare reconfortant.

Conectarea tuturor în GitHub Actions

Fluxul de lucru se declanșează doar pe căile relevante—prompturi, evaluări, cod de integrare AI—astfel încât o modificare de foaie de stil să nu consume apeluri 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

Două detalii merită menționate. Cheia API trece prin secretele repository-ului, niciodată prin fișierul de flux de lucru, care este accesibil oricui are acces la cod. Iar publicarea raportului folosește if: always(), altfel artefactul nu ar fi produs când evaluările eșuează—ceea ce este tocmai singurul caz în care aveți nevoie să îl citiți.

Scriptul de intrare leagă totul: scrie raportul pe disc pentru artefact, îl afișează în jurnale și setează codul de ieșire care permite sau blochează restul pipeline-ului.

#!/usr/bin/env python3
"""Script de evaluare pentru 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)

    # Scrie raportul
    Path("evals/report.md").write_text(report)
    print(report)

    # Cod de ieșire pentru CI
    if not all_pass:
        print("\nUnele evaluări au eșuat. Implementare blocată.")
        sys.exit(1)
    else:
        print("\nToate evaluările au reușit.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Comparați mai degrabă decât să judecați în termeni absoluți

Un prag fix răspunde la întrebarea „Este acest lucru suficient de bun?“. Nu răspunde la „Este mai bun decât înainte?“, ceea ce este adesea întrebarea reală. Un prompt rescris poate rămâne peste prag pierzând totuși trei puncte față de versiunea anterioară: CI devine verde, iar degradarea intră în producție fără ca nimeni să observe.

Testul de regresie rulează, prin urmare, ambele versiuni pe același set de date, în aceeași campanie, și compară mediile. O toleranță de 5% absoarbe zgomotul inerent ieșirilor generative; dincolo de aceasta, verdictul este explicit.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Verifică faptul că un nou prompt nu degradează performanța."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Evaluare cu promptul curent
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Evaluare cu promptul anterior
        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 "REGRESIE",
    }

Acest test dublează numărul de apeluri și, prin urmare, costul și durata. Rezervați-l pentru modificările de prompt, ținându-l în afara căii commit-urilor obișnuite, și rulați-l pe un subset reprezentativ, nu pe întregul set de date de referință.

Puncte cheie

  • Integrați evaluările în pipeline-ul CI/CD ca pe testele unitare
  • Gestionați versiunile prompturilor în fișiere: fără un diff, nicio declanșare nu este posibilă
  • Definiți praguri minime per tip de evaluare, calibrate pe date din producție
  • Blocați implementările prin cod de ieșire când scorurile scad sub praguri
  • Testați regresia comparând prompturile noi și cele vechi pe același set de date