Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vyhodnocení vašeho doladěného modelu

Lekce 10 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Proč je evaluace nezbytná
  2. Vytvoření testovací sady
  3. Automatizovaná evaluace
  4. Specializované metriky
  5. Lidská evaluace
  6. Evaluační zpráva
  7. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Dostupnost doladění. Služba pro vlastní doladění od OpenAI je postupně ukončována: od 7. května 2026 ji organizace, které ji nikdy nepoužily, nemohou nově spustit; od 2. července musíte mít doladěný model použitý v posledních 60 dnech; a počínaje 6. lednem 2027 žádný zákazník nebude moci spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz je stále užitečný pro pochopení a využití stávajícího modelu; u nových projektů dejte přednost inženýrství promptů, RAG a evaluacím.

Proč je evaluace nezbytná

Úspěšné doladění se neměří pouze ztrátovou funkcí (loss). Skutečná otázka zní: je váš doladěný model pro váš případ použití skutečně lepší než základní model? Čistě klesající křivka pouze dokazuje, že se model naučil reprodukovat vaše příklady; nic neříká o jeho chování u neviděných požadavků. Tato lekce vám ukáže, jak vybudovat rigorózní evaluační protokol kombinující automatizované metriky, hodnocení pomocí LLM a lidskou revizi.

Vytvoření testovací sady

Vaše testovací sada musí být oddělená od trénovacích i validačních dat. Tento rozdíl je zásadní: validační sada slouží k monitorování tréninku, a tím ovlivňuje vaše rozhodnutí o hyperparametrech, což ji postupně kontaminuje. Testovací sada se naproti tomu otevře až po zmrazení modelu. Reprezentuje reálné situace, se kterými se model setká v produkci, včetně stejného poměru jednoduchých a záludných případů. Rozdělení 80/10/10 na dříve zamíchaném korpusu je rozumným výchozím bodem.

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")

Automatizovaná evaluace

Evaluace založená na metrikách

Princip je jednoduchý: u každého testovacího příkladu odstraňte zprávu asistenta – to je očekávaná odpověď, kterou model nesmí vidět – odešlete zbytek a ponechte si vstup, referenční odpověď a vygenerovanou odpověď vedle sebe. Tato třísloupcová struktura je základem pro vše, co následuje; její využití pro výpočet metrik nebo kvalitativní posouzení je jen otázkou dalšího zpracování.

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

Evaluace typu LLM-as-a-Judge

Výkonnou technikou je použití vysoce výkonného modelu k posouzení kvality odpovědí. Porovnávání slovo od slova s referencí se stává nepoužitelným, jakmile je přijatelných více formulací; soudce však ocení podstatu. Kvalita jeho verdiktu závisí výhradně na přesnosti promptu: čtyři kritéria hodnocená 1 až 5, vynucený výstup ve formátu JSON a komentář v volném textu, který později využijete k pochopení selhání. Naplánujte si případy, kdy výstup není parsitelný, místo abyste nechali výjimku přerušit celou kampaň.

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

Specializované metriky

Dva předchozí přístupy fungují dobře pro psané odpovědi. Jakmile má výstup vašeho modelu pevnou strukturu, jsou možné přímější míry, které vám ušetří okliku přes soudce.

Pro klasifikaci

Když očekávaný výstup patří do uzavřené množiny – kategorie ticketu, sentiment, kód produktu – opět získává smysl přesná shoda (exact match). Před porovnáním normalizujte velká/malá písmena a mezery; jinak se „Urgent“ versus „urgent“ započítá jako chyba a zkreslí vaši míru úspěšnosti.

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}

Pro volání funkcí

Volání funkcí se hodnotí ve dvou osách, které je třeba měřit odděleně. Model, který vybere správnou funkci, ale špatně vyplní parametr, selhává jinak než ten, který zavolá zcela špatný nástroj: první problém se řeší příklady extrakce, druhý příklady diskriminace. Jediné globální skóre by tento rozdíl zamaskovalo a nechalo by vás pracovat naslepo.

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

Lidská evaluace

Automatizovaná evaluace nezachytí vše. Mírně povýšený tón, fráze, která neladí vašim zákazníkům, technicky správná, ale nepoužitelná odpověď: tyto chyby odhalí pouze lidské oko. Protokol je přímočarý. Náhodně vyberte dvacet až padesát odpovědí, nikdy ne ty případy, které jste již označili jako problematické, jinak budete měřit pouze vlastní selektivní zkreslení. Následně definujte jasná, měřitelná kritéria a formalizujte je do standardizované hodnoticí rubriky, aby dva recenzenti hodnotili totéž.

Nakonec nechte hodnotit více lidí a vypočítejte shodu mezi hodnotiteli (inter-rater agreement). Silný nesoulad nutně neznamená špatný model: nejčastěji odhaluje, že vaše rubrika zůstává nejednoznačná a potřebuje upřesnění, než budete moci cokoli uzavřít.

Ukázková hodnoticí rubrika

Kritérium 1 (Špatné) 3 (Přijatelné) 5 (Výborné)
Relevance Mimo téma Částečně relevantní Perfektně cílené
Tón Nevhodný Přijatelný, ale fádní Perfektně sladěný
Formát Nedodržen Částečně dodržen Perfektně dodržen

Evaluační zpráva

Jeden poslední reflex odděluje pouhou evaluaci od rozhodnutí: zaznamenejte obě rodiny výsledků do jedné zprávy doprovázené explicitním doporučením. Prahovou hodnotu, kterou si stanovíte – zde lidský průměr 4 pro nasazení do produkce, 3 pro iteraci na datech – musíte zvolit před spuštěním kampaně. Pokud ji stanovíte až afterward, vždy se přizpůsobí výsledku, který jste doufali získat.

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")

Klíčové poznatky

  • Vždy mějte oddělenou nezávislou testovací sadu (ani trénink, ani validace)
  • Kombinujte automatizovanou a lidskou evaluaci
  • Evaluace typu LLM-as-a-judge je dobrým kompromisem mezi oběma přístupy
  • Před začátkem definujte měřitelná kritéria
  • Nízká hodnota ztráty (loss) nezaručuje kvalitu pro produkci