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

Automatyczna ewaluacja promptów

Lekcja 16 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Automatyczna ewaluacja promptów
  2. Rodzaje ewaluacji
  3. Kompletny potok ewaluacji
  4. Zestaw testowy: format
  5. Integracja z CI/CD
  6. Panel ewaluacji
  7. Skonstruuj swoje bariery ochronne
  8. Kluczowe wnioski
  9. Sprawdź swoją wiedzę

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie 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.

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