CI/CD dla AI: Automatyczne Ewaluacje
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym nanone, 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) lubreasoning_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