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

Vytvářejte vlastní evaluace

Lekce 16 z 20 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Přizpůsobení evaluací vaší doméně
  2. Převod obchodního požadavku na hodnoticí schéma
  3. Když stroj hodnotí lépe než člověk
  4. Zajistěte opakovatelnost evaluace
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (API Responses) nebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Aktualizace platformy Evals ze 2. listopadu 2026. OpenAI oznámila ukončení své platformy Evals: stávající evaluace jsou od 31. října 2026 pouze pro čtení a jak dashboard, tak API, včetně hodnotitelů (graders), budou uzavřeny 30. listopadu 2026. OpenAI zveřejnila migrační příručku pro nástroj Promptfoo. Principy evaluace v této lekci zůstávají v platnosti; mění se pouze nástroj.

Přizpůsobení evaluací vaší doméně

Obecní hodnotitelé nestačí k posouzení kvality ve vaší specifické doméně. Zdravotní chatbot, právní asistent a nástroj pro marketingové psaní mají každá jiná kritéria kvality a tato kritéria nejsou jen početnější – jsou také různě prioritizována. Nevhodný tón v newsletteru je otravný; stejná nepřesnost v instrukcích k dávkování léků je vážnou chybou. Obecný hodnotitel zachází s oběma případy stejně, což v podstatě znamená, že neevaluujete vůbec nic.

Proto potřebujete vlastní evaluace postavené na explicitním hodnoticím schématu (rubrice), které převádí vaše obchodní priority na váhy. Právě toto schéma nyní vytvoříme.

Převod obchodního požadavku na hodnoticí schéma

Hodnoticí schéma je seznam vážených kritérií, jejichž součet se rovná 1. Nejužitečnější částí není nakódování struktury, což zabere asi patnáct řádků, ale její naplnění: rozhodnutí, že benefity pro zákazníka mají váhu 0,25, zatímco délka pouze 0,10, vynutí explicitní konverzaci s vlastníky produktu. Výsledkem je sdílená definice „dobré odpovědi“, o které nikdo nemůže následně diskutovat.

from dataclasses import dataclass

@dataclass
class Kritérium:
    název: str
    popis: str
    váha: float  # 0 až 1, součet vah = 1

@dataclass
class Schéma:
    název: str
    kritéria: list[Kritérium]

    def ověřit(self) -> bool:
        celkem = sum(k.váha for k in self.kritéria)
        return abs(celkem - 1.0) < 0.01

# Příklad: schéma pro marketingového asistenta psaní
schéma_marketing = Schéma(
    název="Kvalita marketingového textu",
    kritéria=[
        Kritérium("tón", "Tón je profesionální a poutavý", 0.20),
        Kritérium("cta", "Obsahuje jasnou výzvu k akci", 0.15),
        Kritérium("benefity", "Zdůrazňuje benefity pro klienta", 0.25),
        Kritérium("délka", "Respektuje požadovanou délku", 0.10),
        Kritérium("gramatika", "Žádné gramatické ani pravopisné chyby", 0.15),
        Kritérium("značka", "Respektuje guideliny značky", 0.15),
    ],
)

Metodu ověřit stojí za to volat v testech, nejen ji napsat. Schémata se vyvíjejí: přidáte kritérium compliance, odstraníte jedno, které již není užitečné, a součet se nenápadně posune na 1,15, aniž by cokoli signalizovalo anomálii. Skóre zůstávají vypočitatelná, jen jsou špatná, a při porovnávání mezi verzemi vás dovedou k chybným závěrům.

Hodnotitel poté převede schéma do promptu, požádá o skóre 0–5 pro každé kritérium a znovu složí vážené globální skóre. Každé skóre je doprovázeno krátkým komentářem: to vám umožní při revizi špatných případů pochopit, zda model odpověděl špatně, nebo zda bylo vaše kritérium špatně formulováno.

import openai
import json

client = openai.OpenAI()

def evaluovat_více_kritérií(
    otázka: str,
    odpověď: str,
    schéma: Schéma,
) -> dict:
    """Evaluuje odpověď podle více-kriteriálního schématu."""

    text_kritérií = "\n".join(
        f"- {k.název} (váha: {k.váha}): {k.popis}"
        for k in schéma.kritéria
    )

    prompt = (
        "Ohodnoťte tuto odpověď podle následujících kritérií.\n"
        "Pro každé kritérium udělejte skóre od 0 do 5.\n\n"
        f"Položená otázka: {otázka}\n"
        f"Hodnocená odpověď: {odpověď}\n\n"
        f"Kritéria:\n{text_kritérií}\n\n"
        "Odpovězte v JSON s objektem scores obsahujícím pro každé kritérium "
        "skóre (0-5) a krátký komentář."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        input=prompt,
        temperature=0.0,
    )

    try:
        výsledek = json.loads(response.output_text)
        skóre = výsledek.get("scores", {})

        # Výpočet váženého skóre
        vážené_skóre = 0
        for kritérium in schéma.kritéria:
            if kritérium.název in skóre:
            surové_skóre = skóre[kritérium.název]["skóre"] / 5.0
                vážené_skóre += surové_skóre * kritérium.váha

        return {
            "globální_skóre": vážené_skóre,
            "detaily_skóre": skóre,
            "schéma": schéma.název,
        }
    except (json.JSONDecodeError, KeyError):
        return {"globální_skóre": 0, "chyba": "Parsování selhalo"}

Dejte si pozor na výpočetní smyčku: pokud v odpovědi hodnotitele chybí nějaké kritérium, je tiše ignorováno a přispívá nulou k váženému skóre. Vynikající odpověď by se tak mohla zastavit na 0,75 pouze proto, že hodnotitel zapomněl na klíč. Pokud se vaše skóre zdají být zaseknutá pod nevysvětlitelným stropem, zkontrolujte detaily_skóre dříve, než začnete obviňovat hodnocený model.

Když stroj hodnotí lépe než člověk

Nechat LLM hodnotit kód je nákladná zkratka: jediný verdikt, na kterém záleží, je provedení. Níže uvedený hodnotitel spojí vygenerovaný kód a test, zapíše jej do dočasného souboru, spustí jej a spočítá úspěchy. Výsledné skóre nepotřebuje interpretaci – test buď projde, nebo ne.

import subprocess
import tempfile

def evaluovat_python_kód(
    vygenerovaný_kód: str,
    testy: list[str],
) -> dict:
    """Evaluuje Python kód jeho spuštěním proti testům."""
    výsledky_testů = []

    for i, test in enumerate(testy):
        kompletní_kód = f"{vygenerovaný_kód}\n\n{test}"

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            f.write(kompletní_kód)
            f.flush()

            try:
                výsledek = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                úspěch = výsledek.returncode == 0
                výsledky_testů.append({
                    "test": i,
                    "úspěch": úspěch,
                    "výstup": výsledek.stdout[:200],
                    "chyba": výsledek.stderr[:200] if not úspěch else "",
                })
            except subprocess.TimeoutExpired:
                výsledky_testů.append({
                    "test": i,
                    "úspěch": False,
                    "chyba": "Timeout (10s)",
                })

    počet_úspěchů = sum(1 for r in výsledky_testů if r["úspěch"])
    return {
        "skóre": počet_úspěchů / len(testy) if testy else 0,
        "prošlé_testy": počet_úspěchů,
        "celkem_testů": len(testy),
        "detaily": výsledky_testů,
    }

Parametr timeout=10 není jen preventivní opatření pro komfort: modely pravidelně produkují nekonečné smyčky a bez tohoto omezení by se vaše evaluační kampaň zasekla na prvním selhavším případě. Také mějte na paměti, že spouštíte kód, který jste nenapsali vy – mimo izolované vývojové prostředí vyžaduje tato funkce sandbox.

Shrnutí ilustruje smíšený případ, kde je část hodnocení mechanická a část nikoli. Délka je měřitelná: vypočítaný poměr penalizuje shrnutí, které je příliš krátké, i to, které je příliš dlouhé, symetricky, což zabraňuje triku modelu kopírovat zdrojový text, aby nic nevynechal. Věrnost naopak nelze měřit pravidlem a vrací se k LLM hodnotiteli s přímou otázkou ohledně vymyšlených informací.

def evaluovat_shrnutí(
    původní_text: str,
    shrnutí: str,
    cílová_délka: int = 100,
) -> dict:
    """Evaluuje kvalitu shrnutí."""
    slova_shrnutí = len(shrnutí.split())
    poměr_délky = min(
        slova_shrnutí / cílová_délka,
        cílová_délka / max(slova_shrnutí, 1),
    )

    # Věrnost přes LLM
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Je následující shrnutí věrné původnímu textu? "
            f"Obsahuje vymyšlené informace?\n\n"
            f"Původní text (úryvek): {původní_text[:2000]}\n\n"
            f"Shrnutí: {shrnutí}\n\n"
            f"Odpovězte v JSON s klíči: věrnost (0-5), "
            f"halucinace (ano/ne), komentář (krátký)."
        ),
        temperature=0.0,
    )

    try:
        věrnost = json.loads(response.output_text)
    except json.JSONDecodeError:
        věrnost = {"věrnost": 0, "halucinace": "neznámo"}

    return {
        "skóre_délka": poměr_délky,
        "skóre_věrnost": věrnost.get("věrnost", 0) / 5.0,
        "halucinace": věrnost.get("halucinace", "neznámo"),
        "slova_shrnutí": slova_shrnutí,
        "cílová_délka": cílová_délka,
    }

Zajistěte opakovatelnost evaluace

Evaluace, kterou opakujete ručně, se dříve či později přestane opakovat. Pipeline zapouzdřuje schéma a uchovává historii kampaní, čímž mění jednorázové měření na časovou řadu: uvidíte, že průměrné skóre kleslo z 0,81 na 0,79 po úterní změně promptu, což je informace, kterou vám žádné izolované spuštění nemohlo poskytnout.

class PipelineEval:
    """Opakovaně použitelné evaluační pipeline."""

    def __init__(self, název: str, schéma: Schéma):
        self.název = název
        self.schéma = schéma
        self.historie: list[dict] = []

    def evaluovat_dávku(
        self,
        dataset: list[dict],
        model: str,
        systémový_prompt: str,
    ) -> dict:
        """Evaluuje celou dávku a vrací metriky."""
        výsledky = []

        for případ in dataset:
            response = client.responses.create(
                model=model,
                instructions=systémový_prompt,
                input=případ["input"],
            )

            eval_výsledek = evaluovat_více_kritérií(
                případ["input"],
                response.output_text,
                self.schéma,
            )
            výsledky.append(eval_výsledek)

        skóre = [r["globální_skóre"] for r in výsledky]
        zpráva = {
            "pipeline": self.název,
            "model": model,
            "počet_případů": len(dataset),
            "průměrné_skóre": sum(skóre) / len(skóre),
            "min_skóre": min(skóre),
            "max_skóre": max(skóre),
        }

        self.historie.append(zpráva)
        return zpráva

Jeden tip pro začátek: vytvořte své první schéma pouze na dvaceti případech, nechte jej ohodnotit paralelně LLM hodnotitelem a doménovým expertem a poté obě série porovnejte. Rozdíly vám řeknou, která kritéria jsou špatně popsána, dlouho předtím, než vám řeknou cokoli o kvalitě modelu.

Klíčové poznatky

  • Vytvářejte hodnoticí schémata specifická pro vaši obchodní doménu s explicitními vahami
  • Ověřujte, že součet vah zůstává roven 1, jak se schéma vyvíjí
  • Kombinujte automatizovanou evaluaci (kód, délka) a LLM-as-Judge (kvalita)
  • Testujte generovaný kód jeho spuštěním s timeoutem a v izolovaném prostředí
  • Vybudujte opakovaně použitelné pipeline, které uchovávají historii kampaní