Przejdź do głównej treści
Polski— Wybierz język
Menu

CI/CD dla AI: Automatyczne Ewaluacje

Lekcja 18 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Integracja ewaluacji z potokiem CI/CD
  2. Zasada: Bramka, a nie raport
  3. Podpięcie wszystkiego w GitHub Actions
  4. Porównuj, zamiast oceniać w kategoriach bezwzględnych
  5. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Integracja ewaluacji z potokiem CI/CD

Wdrożenie zmiany w prompcie do produkcji bez ewaluacji jest jak wdrożenie kodu bez testów. Porównanie to jest trafniejsze, niż mogłoby się wydawać: w obu przypadkach zmiana wydaje się błaha, została ręcznie zweryfikowana na jednym czy dwóch przykładach, a skutek uboczny wychodzi trzy dni później u użytkownika, który Ci o tym nie powie. Różnica polega na tym, że regresja promptu nie zgłasza wyjątku – aplikacja nadal odpowiada, tylko gorzej.

Celem jest uczynienie z automatycznej ewaluacji obowiązkowej bramki w procesie wdrażania, zapewniającej, że każda zmiana utrzymuje lub poprawia jakość. Właśnie tym zajmiemy się dalej.

Zasada: Bramka, a nie raport

Potok ewaluacji integruje się z przepływem wdrażania przy użyciu znanego mechanizmu. Deweloper modyfikuje prompt lub parametr, commit uruchamia potok CI, a ewaluacje uruchamiają się automatycznie wobec zbioru danych referencyjnych. Jeśli wyniki spełniają progi, wdrożenie trwa dalej; w przeciwnym razie zostaje zablokowane, a szczegółowy raport wskazuje, która ewaluacja zawiodła i o ile.

Kluczowy jest mechanizm blokujący. CI, które generuje ładny raport, ale nie zatrzymuje potoku, staje się artefaktem, którego nikt nie sprawdza po dwóch tygodniach. Tylko kod wyjścia różny od zera zamienia pomiar w barierę ochronną.

Poniższy skrypt odczytuje konfigurację, ładuje każdy zbiór danych, uruchamia przypadki testowe i porównuje średni wynik z zadeklarowanym progiem. Metoda oceniania – proste sprawdzenie obecności słów kluczowych – jest celowo prymitywna: sprawdzenie CI musi być szybkie, deterministyczne i niezależne od sędziego, którego ocena mogłaby się różnić między uruchomieniami.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Ładuje konfigurację ewaluacji."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Ładuje zbiór danych 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:
    """Uruchamia ewaluacje dla 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,
            )

            # Prosta ewaluacja poprzez obecność słów kluczowych
            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  # Brak konkretnego kryterium

            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]:
    """Generuje raport dla CI i wskazuje, czy wszystko jest w porządku."""
    lines = ["# Raport ewaluacji 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"(próg: {r['threshold']:.0%}, {r['num_cases']} przypadków)"
        )

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

Zauważ, że prompt jest odczytywany z pliku, a nie zapisywany bezpośrednio w skrypcie. To właśnie umożliwia wyzwalanie: prompt wersjonowany w repozytorium generuje diff, a diff może wyzwolić ewaluację. Dopóki Twoje prompty żyją jako literały stringowe rozrzucone po kodzie aplikacji, właściwa automatyzacja nie jest możliwa.

Konfiguracja deklaruje jedną ewaluację na zadanie, każda z własnym progiem.

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

Różnica między tymi dwoma progami jest sednem metody. Klasyfikacja zgłoszeń to zadanie zamknięte: poniżej 0,90 funkcja nie dostarcza oczekiwanego serwisu. Podsumowanie to zadanie otwarte, oceniane na podstawie słów kluczowych, które dobry tekst może legalnie ująć inaczej; wymaganie 0,90 zablokowałoby każde wdrożenie i szybko doprowadziłoby do wyłączenia sprawdzenia. Skalibruj każdy próg na podstawie wyników obserwowanych w produkcji, a nie na podstawie zaokrąglonej liczby, która wydaje się uspokajająca.

Podpięcie wszystkiego w GitHub Actions

Przepływ pracy uruchamia się tylko na odpowiednich ścieżkach – prompty, ewaluacje, kod integracji AI – więc zmiana arkusza stylów nie zużywa wywołań 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

Warto zwrócić uwagę na dwa szczegóły. Klucz API przechodzi przez sekrety repozytorium, nigdy przez plik przepływu pracy, który jest czytelny dla każdego mającego dostęp do kodu. Publikacja raportu używa if: always(), w przeciwnym razie artefakt nie zostałby wygenerowany, gdy ewaluacje zawiodą – a to właśnie jedyny przypadek, kiedy musisz go przeczytać.

Skrypt wejściowy scala wszystko: zapisuje raport na dysku dla artefaktu, wypisuje go do logów i ustawia kod wyjścia, który pozwala lub blokuje resztę potoku.

#!/usr/bin/env python3
"""Skrypt ewaluacji dla 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)

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

    # Kod wyjścia dla CI
    if not all_pass:
        print("\nNiektóre ewaluacje nie powiodły się. Wdrożenie zablokowane.")
        sys.exit(1)
    else:
        print("\nWszystkie ewaluacje zakończone sukcesem.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Porównuj, zamiast oceniać w kategoriach bezwzględnych

Stały próg odpowiada na pytanie „Czy to wystarczająco dobre?“. Nie odpowiada na pytanie „Czy to lepsze niż wcześniej?“, co często jest prawdziwym pytaniem. Przepisany prompt może pozostać powyżej progu, tracąc trzy punkty w porównaniu z poprzednią wersją: CI świeci się na zielono, a degradacja trafia do produkcji, nikogo nie alarmując.

Test regresji uruchamia zatem obie wersje na tym samym zbiorze danych, w tej samej kampanii, i porównuje średnie. Tolerancja 5% pochłania szum nieodłączny od wyjść generatywnych; powyżej tego poziomu werdykt jest jednoznaczny.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Weryfikuje, czy nowy prompt nie pogarsza wydajności."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Ewaluacja z bieżącym promptem
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Ewaluacja z poprzednim promptem
        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 "REGRESJA",
    }

Test ten podwaja liczbę wywołań, a tym samym koszt i czas. Rezerwuj go dla zmian w promptach, trzymając go z dala od ścieżki zwykłych commitów, i uruchamiaj go na reprezentatywnym podzbiorze, a nie na całym zbiorze danych referencyjnych.

Kluczowe wnioski

  • Integruj ewaluacje z potokiem CI/CD tak jak testy jednostkowe
  • Wersjonuj prompty w plikach: bez diffa nie ma możliwości wyzwalania
  • Definiuj minimalne progi dla każdego typu ewaluacji, kalibrując je na danych produkcyjnych
  • Blokuj wdrożenia poprzez kod wyjścia, gdy wyniki spadną poniżej progów
  • Testuj regresje, porównując nowe i stare prompty na tym samym zbiorze danych