Oceniaj swoje prompty: metody, oceniające i migracja do Promptfoo
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.
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.0u 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