Automatyczna ewaluacja promptów
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane wyłącznie 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.
Automatyczna ewaluacja promptów
Automatyczna ewaluacja to kamień węgielny dojrzałego procesu inżynierii promptów. Pozwala wykrywać regresje, porównywać modele i walidować zmiany przed wdrożeniem. Bez niej każda modyfikacja promptu jest ślepym zakładem.
Rodzaje ewaluacji
Trzy rodziny ewaluatorów dzielą pracę w zależności od natury oczekiwanego wyniku i niemal zawsze będziesz łączyć kilka z nich.
Ewaluacja dokładnego dopasowania (Exact Match)
W zadaniach, gdzie istnieje tylko jedna oczekiwana odpowiedź, wystarczy bezpośrednie porównanie. Funkcja eval_exact_match normalizuje wielkość liter i odstępy przed porównaniem: bez tego środka ostrożności „Bug“ i „bug“ zostałyby uznane za błąd, zmuszając cię do naprawiania problemu, który nie istnieje.
Funkcja eval_set_match obsługuje przypadki, gdy odpowiedź jest zbiorem – np. encje znalezione w dokumencie czy kategorie przypisane do artykułu. Wyprowadza ona precyzję i recall (czułość), dwie wartości opowiadające różne historie: wysoka precyzja przy niskim recallu sygnalizuje zbyt ostrożny model, który ekstrahuje tylko to, co jest pewne; odwrotna sytuacja zdradza model halucynujący, by wypełnić luki. Miara F1 wygodnie je podsumowuje, ale nie zastępuje ich w diagnostyce.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Exact match after normalization."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Set match (entities, categories)."""
tp = len(prediction & reference)
fp = len(prediction - reference)
fn = len(reference - prediction)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = (2 * precision * recall / (precision + recall)
if (precision + recall) > 0 else 0)
return {"precision": precision, "recall": recall, "f1": f1}
Ewaluacja semantyczna (Embedding)
W przypadku odpowiedzi tekstowych, gdzie sformułowanie może się różnić, dokładne dopasowanie staje się absurdalne: „Twoje zamówienie zostanie dostarczone jutro“ i „Dostawa zaplanowana jest na jutro“ mówią to samo, a jednak otrzymałyby wynik zero. Podobieństwo kosinusowe między embeddingami mierzy bliskość semantyczną, a nie dopasowanie znaków, zwracając wynik ciągły.
Ustalasz próg, powyżej którego odpowiedź jest uznawana za akceptowalną. Skalibruj go na kilkudziesięciu parach ręcznie sklasyfikowanych jako „równoważne“ lub „różne“, a następnie wybierz wartość, która najlepiej rozdziela te dwie grupy: próg wybrany „na czuja“ daje wyniki tak samo arbitralne, jak brak jakiegokolwiek pomiaru, z dodatkową iluzją rygoru.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Cosine similarity between embeddings."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[prediction, reference]
)
emb_pred = np.array(response.data[0].embedding)
emb_ref = np.array(response.data[1].embedding)
similarity = float(
np.dot(emb_pred, emb_ref) /
(np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
)
return similarity
Ewaluacja przez LLM (LLM-as-Judge)
Model ocenia jakość odpowiedzi. Jest to jedyne sensowne podejście, gdy nie istnieje żaden wzorzec odniesienia: nikt nie napisze ręcznie „poprawnej“ odpowiedzi wsparcia dla dwustu zgłoszeń.
O tym, czy sędzia jest użyteczny, decyduje kilka rzeczy. Po pierwsze, użyty model: wybierasz model bardziej zaawansowany jako sędziego, tutaj gpt-5.6-sol, ponieważ sędzia na tym samym poziomie co oceniany model tenduje do walidowania własnych błędów. Po drugie, wymóg uzasadnienia: motywowanie każdej oceny stabilizuje osąd i pozwala wykryć ewaluatora używającego złego kryterium – uzasadnienie dyskutujące długość, gdy kryterium była jasność, to czerwona flaga. Na koniec, temperature ustawione na 0.1 zapewnia stabilność wyników między uruchomieniami.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Evaluation by a judge model."""
criteria_text = "\n".join(
f"- {c}: score from 1 to 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # More capable model as judge
reasoning={"effort": "none"}, # temperature requires effort none
instructions="You are an expert, impartial evaluator.",
input=f"""Evaluate this response according to the following criteria:
Question asked: {question}
Response to evaluate: {prediction}
Criteria:
{criteria_text}
For each criterion, give a score from 1 to 5 with justification.""",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"scores": {
"type": "array",
"items": {
"type": "object",
"properties": {
"criterion": {"type": "string"},
"score": {"type": "integer"},
"justification": {"type": "string"}
},
"required": ["criterion", "score",
"justification"],
"additionalProperties": False
}
},
"overall_score": {"type": "number"},
"verdict": {"type": "string"}
},
"required": ["scores", "overall_score", "verdict"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Kompletny potok ewaluacji
EvalPipeline składa te elementy w całość: ładuje zestaw testowy, uruchamia prompt dla każdego przypadku, stosuje wszystkie dostarczone ewaluatory i agreguje wyniki. Ewaluatory są przekazywane jako lista funkcji, wszystkie wywoływane z tym samym podpisem; dodanie nowej metryki nie wymaga więc modyfikacji potoku, a ty możesz uruchomić dokładne dopasowanie, podobieństwo semantyczne i sędziego na tym samym wykonaniu, nie płacąc trzykrotnie za generowanie.
Metoda summary również akumuluje zużyte tokeny. Ta pozornie drugorzędna linijka chroni cię przed powszechną pułapką: wersja promptu, która zyskuje dwa punkty wyniku, ale potraja rachunek, niekoniecznie jest właściwym wyborem i lepiej dowiedzieć się o tym na etapie analizy kompromisów, niż gdy przyjdzie miesięczna faktura.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""A test case for evaluation."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Automated evaluation pipeline."""
def __init__(self, test_suite_path: str):
"""Loads the test suite from a JSON file."""
data = json.loads(Path(test_suite_path).read_text())
self.test_cases = [TestCase(**tc) for tc in data]
self.results = []
def run(self, prompt_config: dict,
evaluators: list[callable]) -> dict:
"""Runs all tests and evaluates results."""
self.results = []
for tc in self.test_cases:
# Generate response
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature requires effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Evaluate with each evaluator
scores = {}
for evaluator in evaluators:
score = evaluator(
question=tc.input_text,
prediction=prediction,
reference=tc.expected_output
)
scores[evaluator.__name__] = score
self.results.append({
"input": tc.input_text,
"expected": tc.expected_output,
"prediction": prediction,
"scores": scores,
"tokens": {
"input": response.usage.input_tokens,
"output": response.usage.output_tokens
}
})
return self.summary()
def summary(self) -> dict:
"""Summarizes evaluation results."""
if not self.results:
return {"error": "No results"}
# Aggregate scores by evaluator
all_scores = {}
for result in self.results:
for eval_name, score in result["scores"].items():
if eval_name not in all_scores:
all_scores[eval_name] = []
if isinstance(score, (int, float)):
all_scores[eval_name].append(score)
elif isinstance(score, dict) and "f1" in score:
all_scores[eval_name].append(score["f1"])
summary = {
"total_tests": len(self.results),
"average_scores": {
name: sum(scores) / len(scores)
for name, scores in all_scores.items()
if scores
},
"total_token_cost": sum(
r["tokens"]["input"] + r["tokens"]["output"]
for r in self.results
)
}
return summary
Zestaw testowy: format
Format zestawu testowego jest celowo minimalistyczny: dane wejściowe, oczekiwany wynik i metadane w dowolnej formie. Te metadane są bardziej użyteczne, niż się wydaje – tagując każdy przypadek kategorią, rozbijasz wyniki i odkrywasz, że twój klasyfikator nie zawodzi losowo, lecz w przypadku konkretnej rodziny żądań, czego nie ujawni globalna średnia wynosząca 88%. Trzy poniższe przykłady pokazują również, co powinien zawierać dobry zestaw: przypadki jasne, jak awaria przy starcie, ale także takie, które graniczą z inną kategorią – pytanie o brakującą funkcję wygląda bardzo podobnie do raportu o błędzie i to właśnie na tej granicy decyduje się jakość klasyfikatora.
[
{
"input_text": "My package hasn't arrived",
"expected_output": "complaint",
"metadata": {"category": "delivery"}
},
{
"input_text": "How do I enable dark mode?",
"expected_output": "question",
"metadata": {"category": "feature"}
},
{
"input_text": "The app crashes on startup on iOS 18",
"expected_output": "bug",
"metadata": {"category": "technical"}
}
]
Integracja z CI/CD
Uruchamiaj ewaluację przy każdej zmianie promptu. Funkcja ci_eval_check zamienia pomiar w barierę ochronną: uruchamia potok, porównuje średni wynik do progu i zwraca wartość logiczną, którą twój łańcuch integracji interpretuje jako sukces lub porażkę buildu. Zmiana, która obniża precyzję poniżej 85%, nie trafia już do produkcji, tak samo jak nieudany test jednostkowy blokuje scalenie.
Ustaw próg w oparciu o wynik już osiągnięty przez aktualną wersję, a nie jakiś ideał. Ustaw go zbyt wysoko, a skazujesz zespół na omijanie weryfikacji poprzez tymczasowe wyłączenia, które stają się trwałe; ustaw go zbyt nisko, a nie sprawdzasz niczego, wyświetlając jedynie zieloną odznakę. Pamiętaj wreszcie, że zestaw musi pozostać reprezentatywny dla rzeczywistego ruchu: próg spełniony na dwudziestu przypadkach napisanych dwa lata temu niczego nie dowodzi w odniesieniu do dzisiejszych żądań.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""CI/CD gate: checks that the prompt meets the minimum score."""
pipeline = EvalPipeline(test_suite)
def accuracy(question, prediction, reference):
return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0
results = pipeline.run(prompt_config, [accuracy])
avg_score = results["average_scores"].get("accuracy", 0)
print(f"Average score: {avg_score:.2%}")
print(f"Minimum threshold: {min_score:.2%}")
if avg_score < min_score:
print("FAILURE: score below threshold")
return False
print("SUCCESS: prompt validated")
return True
Panel ewaluacji
Śledź ewolucję wyników w czasie. Pojedynczy wynik nic nie mówi; seria opowiada historię twojego promptu i odpowiada na pytanie, które zawsze pada na spotkaniach: czy robimy postępy? Poniższa funkcja generuje tabelę Markdown, zestawiającą obok siebie dla każdej wersji: średni wynik, zużyte tokeny i szacowany koszt. Format nie jest przypadkowy: wkleja się go bezpośrednio do pull requesta, czyniąc porównanie czytelnym dla osób, które nigdy nie otworzą twojego kodu.
def comparison_report(results: dict[str, dict]) -> str:
"""Generates a comparative report between prompt versions."""
report = "# Comparative Evaluation Report\n\n"
report += "| Version | Average Score | Average Tokens | Cost |\n"
report += "|---------|---------------|----------------|------|\n"
for version, data in results.items():
score = data.get("average_scores", {})
score_val = list(score.values())[0] if score else 0
tokens = data.get("total_token_cost", 0)
report += (f"| {version} | {score_val:.2%} | "
f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")
return report
Skonstruuj swoje bariery ochronne
Zbuduj zestaw dwudziestu przypadków testowych dla rzeczywistego promptu, umieszczając w nim garść przypadków brzegowych, a nie dwadzieścia wygodnych przykładów: zestaw, który przechodzi w 100% za pierwszym razem, niczego cię nie uczy. Zaimplementuj trzy typy ewaluatorów i uruchom je razem na dwóch wersjach swojego promptu. Dokładne dopasowanie daje czystą liczbę, podobieństwo semantyczne wyłapuje uzasadnione przeredagowania, a sędzia rzuca światło na przypadki, gdzie pierwsze dwa się nie zgadzają – te niezgodności są najbogatsze w wnioski dotyczące tego, czego tak naprawdę oczekujesz od modelu.
Porównaj, zidentyfikuj wersję wygrywającą, a następnie skonfiguruj skrypt CI, który blokuje wdrożenie, jeśli wynik spadnie. Dowiesz się, że system działa, w dniu, w którym odrzuci zmianę, którą uważałeś za oczywistą.
Kluczowe wnioski
- Automatyczna ewaluacja jest niezbędna do iteracji z pełnym przekonaniem
- Łącz w miarę potrzeb ewaluację dokładną, semantyczną i typu LLM-as-judge
- Utrzymuj zestaw testowy, który ewoluuje wraz z twoją aplikacją
- Zintegruj ewaluację z CI/CD, ustalając minimalny próg
- Używaj bardziej zaawansowanego modelu jako sędziego do oceny tańszego modelu
- Dokumentuj wyniki każdej wersji, aby śledzić ewolucję
Sprawdź swoją wiedzę
Zaawansowane techniki i industrializacja: finałowy sprawdzian.
1. Co zawiera skuteczny prompt systemowy?
Odpowiedź: Rolę, zakres, zasady zachowania, format wyjścia i obsługę przypadków brzegowych – napisany jak specyfikacja, testowany jak kod.
2. Kiedy należy stosować self-consistency?
Odpowiedź: W problemach wymagających rozumowania z weryfikowalnymi odpowiedziami: generuj wiele niezależnych toków rozumowania i zachowaj odpowiedź większości – wariancja staje się sojusznikiem.
3. Co gwarantuje tryb JSON z wymuszaniem schematu?
Odpowiedź: Wyjście ściśle zgodne ze schematem (typy, wymagane pola, enumeracje) – walidowane po stronie API i ponownie walidowane w kodzie (JSON Schema, Zod) dla łańcucha wolnego od niespodzianek.
4. Czym jest grounding?
Odpowiedź: Zakotwiczeniem odpowiedzi w dostarczonych faktach (dokumenty, pobrane dane), a nie w pamięci modelu – z wymogiem cytowania lub powstrzymania się od źródeł zewnętrznych.
5. Jaki jest cel katalogu promptów z wersjonowaniem?
Odpowiedź: Traktowanie promptów jako artefaktów: wersje, testy A/B, automatyczne ewaluacje przy każdej zmianie – wiesz, co działa w produkcji i dlaczego.
Ostatnia pętla kursu – wersjonuj, testuj, ewaluuj automatycznie – przekształca rzemieślniczą inżynierię promptów w praktykę zespołową.