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

Oceń swój dostrojony model

Lekcja 10 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Dlaczego ewaluacja jest niezbędna
  2. Budowanie zestawu testowego
  3. Ewaluacja zautomatyzowana
  4. Metryki specjalistyczne
  5. Ewaluacja ludzka
  6. Raport z ewaluacji
  7. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy z niej nie korzystały, nie mogą już tworzyć zadań; od 2 lipca konieczne jest użycie dostrojonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchomić nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal przydaje się do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetem powinno być inżynieria promptów, RAG oraz ewaluacje.

Dlaczego ewaluacja jest niezbędna

O sukcesie dostrajania nie decyduje sama wartość funkcji straty. Prawdziwe pytanie brzmi: czy Twój dostrojony model faktycznie radzi sobie lepiej niż model bazowy w Twoim przypadku użycia? Gładko spadająca krzywa dowodzi jedynie, że model nauczył się odtwarzać Twoje przykłady; nie mówi nic o jego zachowaniu wobec niewidzianych wcześniej zapytań. Ta lekcja pokaże Ci, jak zbudować rygorystyczny protokół ewaluacji, łączący zautomatyzowane metryki, ocenę przez LLM oraz przegląd ludzki.

Budowanie zestawu testowego

Twój zestaw testowy musi być oddzielny zarówno od danych treningowych, jak i walidacyjnych. To rozróżnienie ma znaczenie: zestaw walidacyjny służy do monitorowania treningu, a więc wpływa na decyzje dotyczące hiperparametrów, co stopniowo go „zanieczyszcza“. Zestaw testowy otwierasz dopiero wtedy, gdy model jest już zamrożony. Reprezentuje on sytuacje z rzeczywistego świata, z jakimi model spotka się w produkcji, zachowując te same proporcje przypadków prostych i trudnych. Podział 80/10/10 wcześniej potasowanego korpusu to rozsądny punkt wyjścia.

import json
import random

def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
    """Splits data into train/validation/test."""
    with open(file, "r") as f:
        examples = [json.loads(l) for l in f]

    random.shuffle(examples)
    n = len(examples)
    i1 = int(n * ratios[0])
    i2 = int(n * (ratios[0] + ratios[1]))

    datasets = {
        "train": examples[:i1],
        "validation": examples[i1:i2],
        "test": examples[i2:]
    }

    for name, data in datasets.items():
        with open(f"{name}.jsonl", "w") as f:
            for ex in data:
                f.write(json.dumps(ex, ensure_ascii=False) + "\n")
        print(f"{name}: {len(data)} examples")

    return datasets

prepare_datasets("all_data.jsonl")

Ewaluacja zautomatyzowana

Ewaluacja oparta na metrykach

Zasada jest prosta: dla każdego przykładu testowego usuwasz wiadomość asystenta – to oczekiwana odpowiedź, której model nie może zobaczyć – przesyłasz resztę i zestawiasz obok siebie dane wejściowe, odpowiedź referencyjną oraz wygenerowaną odpowiedź. Ta trzykolumnowa struktura stanowi fundament wszystkiego, co następuje; wykorzystanie jej do obliczania metryk lub oceny jakościowej to jedynie kwestia dalszego przetwarzania.

from openai import OpenAI

client = OpenAI()

def evaluate_model(model: str, test_examples: list[dict]) -> dict:
    """Evaluates a model on a test set."""
    results = []

    for ex in test_examples:
        # Extract the question (without the expected answer)
        input_messages = [
            m for m in ex["messages"] if m["role"] != "assistant"
        ]
        expected_answer = next(
            m["content"] for m in ex["messages"] if m["role"] == "assistant"
        )

        # Get the model's response
        response = client.responses.create(
            model=model,
            input=input_messages
        )
        model_answer = response.output_text

        results.append({
            "input": input_messages[-1]["content"],
            "expected": expected_answer,
            "obtained": model_answer
        })

    return results

Ewaluacja typu „LLM jako sędzia“

Potężną techniką jest wykorzystanie wysoko wydajnego modelu do oceny jakości odpowiedzi. Porównywanie słowo w słowo z wzorcem staje się bezużyteczne, gdy akceptowalnych jest wiele sformułowań; sędzia natomiast docenia sedno sprawy. Jakość jego werdyktu zależy wyłącznie od precyzji promptu: cztery kryteria oceniane w skali 1–5, wymuszony wynik w formacie JSON oraz komentarz tekstowy, który później pomoże Ci zrozumieć przyczyny niepowodzeń. Zaplanuj obsługę przypadków, w których wynik nie daje się przetworzyć, zamiast pozwalać, by wyjątek przerwał całą kampanię.

def evaluate_with_judge(results: list[dict]) -> list[dict]:
    """Uses gpt-5.6-sol as a judge to evaluate responses."""
    evaluations = []

    for r in results:
        judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.

Question: {r['input']}

Expected response: {r['expected']}

Obtained response: {r['obtained']}

Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?

Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""

        response = client.responses.create(
            model="gpt-5.6-sol",
            input=judge_prompt
        )

        try:
            evaluation = json.loads(response.output_text)
            evaluations.append(evaluation)
        except json.JSONDecodeError:
            evaluations.append({"error": "Response not parseable"})

    return evaluations

Metryki specjalistyczne

Dwa poprzednie podejścia sprawdzają się dobrze w przypadku odpowiedzi tekstowych. Gdy tylko wyjście Twojego modelu ma ustaloną strukturę, możliwe stają się bardziej bezpośrednie miary, które oszczędzają Ci obejścia przez sędziego.

Dla klasyfikacji

Gdy oczekiwane wyjście należy do domkniętego zbioru – kategoria zgłoszenia, sentyment, kod produktu – ponownie istotne staje się dokładne dopasowanie (exact match). Przed porównaniem znormalizuj wielkość liter i spacje; w przeciwnym razie „Urgent“ versus „urgent“ zostanie policzone jako błąd i zniekształci Twój wskaźnik.

def classification_metrics(results: list[dict]) -> dict:
    """Calculates precision, recall, and F1 for a classification task."""
    correct = sum(
        1 for r in results
        if r["expected"].strip().lower() == r["obtained"].strip().lower()
    )
    total = len(results)
    precision = correct / total if total > 0 else 0

    print(f"Precision: {precision:.2%} ({correct}/{total})")
    return {"precision": precision, "correct": correct, "total": total}

Dla wywoływania funkcji

Wywoływanie funkcji oceniane jest w dwóch osiach, które należy mierzyć osobno. Model, który wybiera właściwą funkcję, ale myli się w parametrze, zawodzi inaczej niż ten, który wywołuje całkowicie niewłaściwe narzędzie: pierwszy problem rozwiązuje się przykładami ekstrakcji, drugi – przykładami dyskryminacji. Pojedynczy wynik globalny zatarłby to rozróżnienie i pozostawił Cię pracującym po omacku.

def function_calling_metrics(results: list[dict]) -> dict:
    """Evaluates the quality of function calls."""
    stats = {"correct_function": 0, "correct_params": 0, "total": 0}

    for r in results:
        stats["total"] += 1
        if r.get("expected_function") == r.get("obtained_function"):
            stats["correct_function"] += 1
        if r.get("expected_params") == r.get("obtained_params"):
            stats["correct_params"] += 1

    print(f"Correct function: {stats['correct_function']}/{stats['total']}")
    print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
    return stats

Ewaluacja ludzka

Ewaluacja zautomatyzowana nie wychwytuje wszystkiego. Lekko protekcjonalny ton, fraza, która nie spodoba się Twoim klientom, odpowiedź technicznie poprawna, ale nieużyteczna: te wady ujawniają się tylko ludzkiemu oku. Protokół jest prosty. Wylosuj od dwudziestu do pięćdziesięciu odpowiedzi, nigdy nie wybierając przypadków, które wcześniej już oznaczyłeś jako problematyczne, bo zmierzysz wtedy jedynie własne obciążenie selekcją. Następnie zdefiniuj jasne, mierzalne kryteria i sformalizuj je w standaryzowanej rubryce ocen, aby dwaj recenzenci oceniali to samo.

Na koniec powierz ocenę kilku osobom i oblicz zgodność między ocenianiającymi (inter-rater agreement). Silna niezgodność niekoniecznie sygnalizuje słaby model: najczęściej ujawnia, że Twoja rubryka pozostaje niejednoznaczna i wymaga doprecyzowania, zanim będziesz mógł wyciągnąć jakieś wnioski.

Przykładowa rubryka oceny

Kryterium 1 (Słabo) 3 (Akceptowalnie) 5 (Doskonale)
Trafność Nie na temat Częściowo trafna Idealnie dopasowana
Ton Niewłaściwy Akceptowalny, ale banalny Idealnie dopasowany
Format Niezgodny Częściowo zgodny Idealnie zgodny

Raport z ewaluacji

Jeden ostatni odróżnia ewaluację od decyzji: zapisz obie rodziny wyników w jednym raporcie, opatrzonym wyraźną rekomendacją. Próg, który ustalasz – tutaj średnia ludzka 4 oznacza gotowość do produkcji, 3 oznacza konieczność iteracji na danych – musi być wybrany przed uruchomieniem kampanii. Ustalony afterward, zawsze dostosowuje się do wyniku, na który liczyłeś.

def evaluation_report(auto_results: dict, human_results: dict):
    """Generates a combined evaluation report."""
    print("=" * 60)
    print("FINE-TUNED MODEL EVALUATION REPORT")
    print("=" * 60)

    print(f"\nAutomated metrics:")
    for k, v in auto_results.items():
        print(f"  {k}: {v}")

    print(f"\nHuman evaluation:")
    for k, v in human_results.items():
        print(f"  {k}: {v}")

    print(f"\nRecommendation:")
    average_score = sum(human_results.values()) / len(human_results)
    if average_score >= 4:
        print("  Model is ready for production")
    elif average_score >= 3:
        print("  Improvements needed—iterate on data")
    else:
        print("  Insufficient results—rethink your approach")

Kluczowe wnioski

  • Zawsze wydzielaj niezależny zestaw testowy (ani treningowy, ani walidacyjny)
  • Łącz ewaluację zautomatyzowaną z ludzką
  • Ewaluacja typu „LLM jako sędzia“ to dobry kompromis między obiema metodami
  • Zdefiniuj mierzalne kryteria przed rozpoczęciem pracy
  • Niski wynik straty nie gwarantuje jakości produkcyjnej