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

Oceniaj swoje prompty: metody, oceniające i migracja do Promptfoo

Lekcja 15 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Dlaczego musisz przeprowadzać ewaluację systematycznie
  2. Stwórz zbiór danych odzwierciedlający rzeczywistość
  3. Wybierz właściwego oceniającego
  4. Złożenie pełnej ewaluacji
  5. Uprzemysłowienie z Promptfoo
  6. 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.

Aktualizacja z 2 listopada 2026 — Platforma Evals. OpenAI ogłosiło zakończenie działania swojej platformy Evals: istniejące ewaluacje są tylko do odczytu od 31 października 2026 r., a panel sterowania wraz z API zostanie zamknięty 30 listopada 2026 r., łącznie z modułami oceniającymi (graders). OpenAI opublikowało przewodnik migracyjny do narzędzia Promptfoo. Zasady ewaluacji przedstawione w tej lekcji pozostają ważne; zmienia się jedynie narzędzie.

Dlaczego musisz przeprowadzać ewaluację systematycznie

Nie poprawisz tego, czego nie mierzysz. Gdy zmieniasz prompt, model lub parametr, skąd wiesz, że jakość faktycznie wzrosła? Spontaniczną metodą jest przetestowanie trzech czy czterech przykładów, znalezienie lepszych odpowiedzi i wdrożenie zmiany. Metoda ta regularnie zawodzi, ponieważ testowane przykłady to właśnie te, które powodowały problemy w zeszłym tygodniu: mierzysz poprawę tam, gdzie jej szukałeś, a przeoczysz regresje wprowadzone w przypadkach, które wcześniej działały poprawnie.

Ewaluacje (evals) zamieniają tę intuicję w obiektywny pomiar. Do 2026 roku OpenAI oferowało w tym celu zintegrowaną platformę Evals; jest ona dostępna tylko do odczytu od 31 października i zostanie zamknięta 30 listopada. OpenAI rekomenduje obecnie Promptfoo, narzędzie open source do ewaluacji i testów typu red teaming. Dobra wiadomość jest taka, że oba rozwiązania opierają się na tych samych elementach: danych testowych, promptach, modelach i kryteriach oceniania. Wiedza, którą zdobędziesz tutaj w kodzie Python, przekłada się bezpośrednio, a ostatnia część lekcji pokazuje, jak przejść do Promptfoo.

Trzy koncepcje strukturyzują cały proces. Zbiór danych (dataset) to zestaw przypadków testowych z danymi wejściowymi i oczekiwanymi wynikami: jest to Twój punkt odniesienia, odpowiednik suite’u testów jednostkowych. Oceniający (grader) to kryterium ewaluacji – dokładne dopasowanie, LLM-as-judge, punktacja – które decyduje, czy dana odpowiedź jest dobra. Uruchomienie (run) to wykonanie ewaluacji na zbiorze danych przy użyciu konkretnego modelu i promptu; jest to jednostka, którą porównujesz między kolejnymi wersjami.

Stwórz zbiór danych odzwierciedlający rzeczywistość

Przypadek testowy składa się z danych wejściowych, oczekiwanego wyniku i metadanych. Te ostatnie nie są ozdobnikiem: to dzięki nim zorientujesz się post factum, że ogólny wynik 87% ukrywa załamanie w kategorii „kod“, skompensowane doskonałymi rezultatami w geografii. Bez kategorii czy poziomu trudności masz tylko zagregowaną liczbę, a taka liczba nigdy nie powie Ci, gdzie należy interweniować.

import json

# Zbiór danych to lista przypadków testowych
dataset = [
    {
        "input": "What is the capital of France?",
        "expected": "Paris",
        "metadata": {"category": "geography", "difficulty": "easy"},
    },
    {
        "input": "Explain Bayes' theorem in one sentence.",
        "expected": "Bayes' theorem calculates the probability "
                    "of an event based on known conditional probabilities.",
        "metadata": {"category": "mathematics", "difficulty": "medium"},
    },
    {
        "input": "Write a Python function that reverses a list.",
        "expected": "def reverse_list(lst): return lst[::-1]",
        "metadata": {"category": "code", "difficulty": "easy"},
    },
]

# Zapisz jako JSONL
with open("eval_dataset.jsonl", "w") as f:
    for case in dataset:
        f.write(json.dumps(case, ensure_ascii=False) + "\n")

Zbiór danych wymyślony w biurze ocenia Twoją wyobraźnię, a nie działanie aplikacji. Twoi użytkownicy formułują zapytania inaczej niż Ty: literówki, pytania zadane w połowie, ukryty kontekst. Najlepszym źródłem przypadków testowych są więc Twoje własne dane produkcyjne, pod warunkiem, że człowiek zweryfikuje odpowiedzi referencyjne – w przeciwnym razie utrwalisz obecne błędy jako normę.

import openai
import random

client = openai.OpenAI()

def create_dataset_from_logs(
    production_logs: list[dict],
    sample_size: int = 100,
) -> list[dict]:
    """Tworzy zbiór danych ewaluacyjnych na podstawie logów produkcyjnych."""
    # Pobranie próby
    sample = random.sample(
        production_logs,
        min(sample_size, len(production_logs)),
    )

    dataset = []
    for log in sample:
        dataset.append({
            "input": log["prompt"],
            "expected": log["validated_response"],  # Odpowiedź zweryfikowana przez człowieka
            "metadata": {
                "source": "production",
                "date": log["date"],
                "original_model": log["model"],
            },
        })

    return dataset

Wybierz właściwego oceniającego

Oceniający typu „dokładne dopasowanie“ (exact match) jest najbardziej rygorystyczny i najszybszy. Nadaje się tylko do zadań, w których wynik jest ściśle określony: klasyfikacja trzykategorialna, ekstrakcja numeru faktury, odpowiedź tak/nie. Użyty na swobodnym tekście, przyznałby zero punktów idealnej odpowiedzi, sformułowanej jedynie inaczej niż wzorzec.

def exact_grader(response: str, expected: str) -> dict:
    """Ocena, czy odpowiedź dokładnie pasuje."""
    score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
    return {"score": score, "type": "exact"}

Oceniający typu „zawieranie“ (inclusion) łagodzi to ograniczenie: sprawdza obecność oczekiwanych słów kluczowych i zwraca wynik cząstkowy. To właściwe narzędzie dla odpowiedzi, które muszą obejmować obowiązkowe punkty, niezależnie od formulacji – np. odpowiedź wsparcia, która musi wspomnieć o okresie zwrotu i adresie do odsyłki. Jego słabość jest dobrze znana: tekst zawierający właściwe słowa w absurdalnej kolejności otrzymałby maksymalną notę.

def inclusion_grader(response: str, keywords: list[str]) -> dict:
    """Sprawdza, czy odpowiedź zawiera oczekiwane słowa kluczowe."""
    response_lower = response.lower()
    found = sum(1 for word in keywords if word.lower() in response_lower)
    score = found / len(keywords) if keywords else 0.0
    return {
        "score": score,
        "found": found,
        "total": len(keywords),
        "type": "inclusion",
    }

Następnie mamy najpotężniejszą opcję: inny model LLM ocenia jakość odpowiedzi. Oceniający LLM-as-Judge docenia to, czego żadna mechaniczna reguła nie chwyci: jasność, kompletność, trafność tonu. Dwa szczegóły implementacyjne czynią go praktycznym. Po pierwsze, temperature=0.0: bez tego ten sam sędzia przyznawałby różne oceny tej samej odpowiedzi przy kolejnych uruchomieniach, a Twój benchmark straciłby wszelką wartość porównawczą. Po drugie, obsługa wyjątku json.JSONDecodeError: sędzia, który zamiast zwrócić JSON, zaczyna komentować, nie powinien powodować awarii całej kampanii.

def llm_judge_grader(
    question: str,
    response: str,
    expected: str,
    criteria: str = "accuracy, completeness, clarity",
) -> dict:
    """Wykorzystuje LLM do oceny jakości odpowiedzi."""
    judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.

Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}

Criteria: {criteria}

Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""

    response_obj = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature wymaga effort none
        input=judge_prompt,
        temperature=0.0,
    )

    import json
    try:
        result = json.loads(response_obj.output_text)
        result["normalized_score"] = result["score"] / 5.0
        return result
    except json.JSONDecodeError:
        return {"score": 0, "justification": "Parsing error", "normalized_score": 0}

Złożenie pełnej ewaluacji

Orkiestracja nie stanowi trudności koncepcyjnej: iterujesz po zbiorze danych, wywołujesz model z testowanym promptem systemowym, stosujesz oceniającego i agregujesz wyniki. Istotny jest fakt, że funkcja oceniająca jest przekazywana jako parametr, co pozwala uruchomić ten sam zbiór danych z różnymi kryteriami w zależności od kampanii – zawieranie dla szybkiej проверки podczas rozwoju, sędzia LLM dla walidacji przed produkcją.

async def run_eval(
    dataset: list[dict],
    model: str,
    system_prompt: str,
    grader_fn,
) -> dict:
    """Przeprowadza pełną ewaluację na zbiorze danych."""
    results = []

    for case in dataset:
        response = client.responses.create(
            model=model,
            instructions=system_prompt,
            input=case["input"],
        )

        score = grader_fn(response.output_text, case["expected"])
        results.append({
            "input": case["input"],
            "expected": case["expected"],
            "obtained": response.output_text,
            **score,
        })

    # Obliczanie zagregowanych metryk
    scores = [r["score"] for r in results if "score" in r]
    return {
        "model": model,
        "num_cases": len(dataset),
        "average_score": sum(scores) / len(scores) if scores else 0,
        "min_score": min(scores) if scores else 0,
        "max_score": max(scores) if scores else 0,
        "results": results,
    }

Raport zachowuje min_score i szczegóły każdego przypadku, i jest to zamierzone. Średnia mówi Ci, czy idziesz do przodu; przypadki z najgorszym wynikiem mówią Ci, dlaczego. Weź sobie za nawyk czytanie pięciu najgorszych odpowiedzi z każdego uruchomienia, zanim skomentujesz średnią: to tam, i rzadko gdzie indziej, znajdziesz kolejną rzecz do naprawienia.

Uprzemysłowienie z Promptfoo

Ręczne pisanie ewaluacji w Pythonie jest pouczające; ich utrzymywanie w czasie jest wygodniejsze dzięki dedykowanemu narzędziu. Przewodnik migracyjny OpenAI opisuje logikę Promptfoo: ewaluacja żyje w pliku konfiguracyjnym promptfooconfig.yaml, który łączy prompty, model(e), przypadki testowe i kryteria – zwane tutaj asercjami. Narzędzie uruchamia się z wiersza poleceń, lokalnie lub w ciągłej integracji (CI), i współistnieje z kodem aplikacji.

description: Support ticket classification
prompts:
  - "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
  - openai:gpt-6.1-sol
tests:
  - vars:
      ticket: "My card was charged twice this month."
    assert:
      - type: icontains
        value: billing
  - vars:
      ticket: "The app crashes when I open a PDF."
    assert:
      - type: icontains
        value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml   # in case of configuration error

Oceniający z tej lekcji pojawiają się ponownie jako asercje: dokładne dopasowanie, zawieranie słów kluczowych i osąd modelu. OpenAI ostrzega w tym ostatnim punkcie: odtworzony oceniający, zwłaszcza LLM judge, musi zostać ponownie zwalidowany przed użyciem do decydowania o regresji, ponieważ wyniki niekoniecznie będą identyczne przy przejściu z jednego narzędzia na drugie.

Kluczowe wnioski

  • Ewaluacje zamieniają intuicję w obiektywny pomiar jakości
  • Twórz swoje zbiory danych na podstawie rzeczywistych przypadków produkcyjnych, zweryfikowanych przez człowieka
  • Dobieraj oceniającego do zadania: dokładny dla zadań ograniczonych, zawieranie dla obowiązkowych punktów, LLM-as-Judge dla niuansów
  • Ustaw temperature=0.0 u sędziego, aby wyniki były powtarzalne
  • Uruchamiaj ewaluacje przed każdą zmianą promptu lub modelu
  • Platforma Evals od OpenAI zostanie zamknięta 30 listopada 2026 r.: Promptfoo, rekomendowany przez OpenAI, przejmuje zbiory danych, prompty, modele i kryteria w pliku konfiguracyjnym