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

Twórz własne ewaluacje

Lekcja 16 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Dostosuj ewaluacje do swojej domeny
  2. Przekład wymogu biznesowego na rubrykę
  3. Kiedy maszyna ocenia lepiej niż człowiek
  4. Uczyń ewaluację powtarzalną
  5. 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 rozumują (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (API Responses) 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, a zarówno panel sterowania, jak i API, włącznie z oceniającymi (graders), zostaną zamknięte 30 listopada 2026. OpenAI opublikowało przewodnik migracyjny do narzędzia Promptfoo. Zasady ewaluacji przedstawione w tej lekcji pozostają ważne; zmienia się jedynie narzędzie.

Dostosuj ewaluacje do swojej domeny

Ogólne oceniające nie wystarczą do oceny jakości w Twojej specyficznej domenie. Chatbot medyczny, asystent prawny i narzędzie do pisania tekstów marketingowych mają różne kryteria jakości, które nie tylko różnią się liczbą, ale też priorytetami. Niedopasowanie tonu w newsletterze to niedogodność; to samo przybliżenie w instrukcji dawkowania to poważny błąd. Ogólny oceniający traktuje oba przypadki tak samo, co w praktyce oznacza brak jakiejkolwiek ewaluacji.

Dlatego potrzebujesz własnych ewaluacji opartych na wyraźnej rubryce, która przekłada Twoje priorytety biznesowe na wagi. Tę rubrykę właśnie zbudujemy.

Przekład wymogu biznesowego na rubrykę

Rubryka to lista ważonych kryteriów, których suma wynosi 1. Najbardziej użytecznym ćwiczeniem nie jest kodowanie struktury (co zajmuje około piętnastu linii), ale jej wypełnianie: decyzja, że korzyści dla klienta ważą 0,25, a długość tylko 0,10, wymusza explicitną rozmowę z właścicielami produktu. Efektem jest wspólna definicja „dobrej odpowiedzi“, której nikt nie zakwestionuje post factum.

from dataclasses import dataclass

@dataclass
class Critere:
    nom: str
    description: str
    poids: float  # 0 to 1, sum of weights = 1

@dataclass
class Rubrique:
    nom: str
    criteres: list[Critere]

    def valider(self) -> bool:
        total = sum(c.poids for c in self.criteres)
        return abs(total - 1.0) < 0.01

# Example: rubric for a marketing writing assistant
rubrique_marketing = Rubrique(
    nom="Qualité rédaction marketing",
    criteres=[
        Critere("ton", "Le ton est professionnel et engageant", 0.20),
        Critere("cta", "Contient un appel à l'action clair", 0.15),
        Critere("benefices", "Met en avant les bénéfices client", 0.25),
        Critere("longueur", "Respecte la longueur demandée", 0.10),
        Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
        Critere("marque", "Respecte les guidelines de la marque", 0.15),
    ],
)

Metoda valider zasługuje na wywołanie w testach, a nie tylko na zapisanie. Rubryki ewoluują: dodajesz kryterium zgodności, usuwasz takie, które nie jest już użyteczne, a suma dryfuje do 1,15 bez żadnego flagowania anomalii. Wyniki pozostają obliczalne, ale są błędne, a porównywane między wersjami doprowadzą Cię do mylnych wniosków.

Oceniający tłumaczy następnie rubrykę na prompt, prosi o ocenę 0–5 dla każdego kryterium i recomponuje ważony wynik globalny. Każda ocena zawiera krótki komentarz: to pozwoli Ci, podczas przeglądania złych przypadków, zrozumieć, czy model odpowiedział źle, czy może Twoje kryterium było źle sformułowane.

import openai
import json

client = openai.OpenAI()

def evaluer_multi_criteres(
    question: str,
    reponse: str,
    rubrique: Rubrique,
) -> dict:
    """Evaluates a response against a multi-criteria rubric."""

    criteres_texte = "\n".join(
        f"- {c.nom} (poids: {c.poids}): {c.description}"
        for c in rubrique.criteres
    )

    prompt = (
        "Évaluez cette réponse selon les critères suivants.\n"
        "Pour chaque critère, donnez un score de 0 à 5.\n\n"
        f"Question posée : {question}\n"
        f"Réponse à évaluer : {reponse}\n\n"
        f"Critères :\n{criteres_texte}\n\n"
        "Répondez en JSON avec un objet scores contenant pour chaque critère "
        "un score (0-5) et un commentaire court."
    )

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

    try:
        resultat = json.loads(response.output_text)
        scores = resultat.get("scores", {})

        # Calculate weighted score
        score_pondere = 0
        for critere in rubrique.criteres:
            if critere.nom in scores:
                score_brut = scores[critere.nom]["score"] / 5.0
                score_pondere += score_brut * critere.poids

        return {
            "score_global": score_pondere,
            "scores_details": scores,
            "rubrique": rubrique.nom,
        }
    except (json.JSONDecodeError, KeyError):
        return {"score_global": 0, "erreur": "Parsing échoué"}

Uważaj na pętlę obliczeniową: kryterium brakujące w odpowiedzi sędziego jest cicho ignorowane i wnosi zero do ważonego wyniku. Doskonała odpowiedź mogłaby więc utknąć na poziomie 0,75 wyłącznie dlatego, że sędzia zapomniał o kluczowym elemencie. Jeśli Twoje wyniki wydają się utykać pod niewyjaśnionym sufitem, sprawdź scores_details, zanim obwinisz oceniany model.

Kiedy maszyna ocenia lepiej niż człowiek

Kazanie LLM oceniać kod to kosztowny skrót: jedynym werdyktem, który się liczy, jest wykonanie. Poniższy oceniający konkatenuje wygenerowany kod i test, zapisuje go w pliku tymczasowym, wykonuje go i zlicza sukcesy. Wynikowy wynik nie wymaga interpretacji – test albo przechodzi, albo nie.

import subprocess
import tempfile

def evaluer_code_python(
    code_genere: str,
    tests: list[str],
) -> dict:
    """Evaluates Python code by executing it against tests."""
    resultats_tests = []

    for i, test in enumerate(tests):
        code_complet = f"{code_genere}\n\n{test}"

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            f.write(code_complet)
            f.flush()

            try:
                resultat = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                succes = resultat.returncode == 0
                resultats_tests.append({
                    "test": i,
                    "succes": succes,
                    "sortie": resultat.stdout[:200],
                    "erreur": resultat.stderr[:200] if not succes else "",
                })
            except subprocess.TimeoutExpired:
                resultats_tests.append({
                    "test": i,
                    "succes": False,
                    "erreur": "Timeout (10s)",
                })

    nb_succes = sum(1 for r in resultats_tests if r["succes"])
    return {
        "score": nb_succes / len(tests) if tests else 0,
        "tests_passes": nb_succes,
        "tests_total": len(tests),
        "details": resultats_tests,
    }

Parametr timeout=10 to nie wygoda: model regularnie produkuje nieskończone pętle i bez tego ograniczenia Twoja kampania ewaluacyjna utknęłaby na pierwszym failing przypadku. Pamiętaj też, że wykonujesz kod, którego nie napisałeś – poza izolowanym środowiskiem deweloperskim ta funkcja wymaga piaskownicy (sandbox).

Podsumowanie ilustruje przypadek mieszany, gdzie część osądu jest mechaniczna, a część nie. Długość jest mierzalna: obliczony współczynnik karze zarówno podsumowanie zbyt krótkie, jak i zbyt długie w sposób symetryczny, co uniknąć sztuczki modelu polegającej na kopiowaniu tekstu źródłowego, by niczego nie pominąć. Wierność z kolei nie jest mierzalna regułą i wraca do sędziego LLM, z bezpośrednim pytaniem o zmyślone informacje.

def evaluer_resume(
    texte_original: str,
    resume: str,
    longueur_cible: int = 100,
) -> dict:
    """Evaluates summary quality."""
    mots_resume = len(resume.split())
    ratio_longueur = min(
        mots_resume / longueur_cible,
        longueur_cible / max(mots_resume, 1),
    )

    # Fidelity via LLM
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Le résumé suivant est-il fidèle au texte original ? "
            f"Contient-il des informations inventées ?\n\n"
            f"Texte original (extrait) : {texte_original[:2000]}\n\n"
            f"Résumé : {resume}\n\n"
            f"Répondez en JSON avec les clés : fidélité (0-5), "
            f"hallucinations (oui/non), commentaire (court)."
        ),
        temperature=0.0,
    )

    try:
        fidelite = json.loads(response.output_text)
    except json.JSONDecodeError:
        fidelite = {"fidelite": 0, "hallucinations": "inconnu"}

    return {
        "score_longueur": ratio_longueur,
        "score_fidelite": fidelite.get("fidelite", 0) / 5.0,
        "hallucinations": fidelite.get("hallucinations", "inconnu"),
        "mots_resume": mots_resume,
        "longueur_cible": longueur_cible,
    }

Uczyń ewaluację powtarzalną

Ewaluacja, którą powtarzasz ręcznie, w końcu przestaje być powtarzana. Potok (pipeline) enkapsuluje rubrykę i utrzymuje historię kampanii, zamieniając jednorazowy pomiar w szereg czasowy: widzisz, że średni wynik spadł z 0,81 do 0,79 po zmianie promptu we wtorek – informacji, której żadne izolowane wykonanie nie mogłoby Ci dać.

class PipelineEval:
    """Reusable evaluation pipeline."""

    def __init__(self, nom: str, rubrique: Rubrique):
        self.nom = nom
        self.rubrique = rubrique
        self.historique: list[dict] = []

    def evaluer_batch(
        self,
        dataset: list[dict],
        modele: str,
        prompt_systeme: str,
    ) -> dict:
        """Evaluates a full batch and returns metrics."""
        resultats = []

        for cas in dataset:
            response = client.responses.create(
                model=modele,
                instructions=prompt_systeme,
                input=cas["input"],
            )

            eval_result = evaluer_multi_criteres(
                cas["input"],
                response.output_text,
                self.rubrique,
            )
            resultats.append(eval_result)

        scores = [r["score_global"] for r in resultats]
        rapport = {
            "pipeline": self.nom,
            "modele": modele,
            "nb_cas": len(dataset),
            "score_moyen": sum(scores) / len(scores),
            "score_min": min(scores),
            "score_max": max(scores),
        }

        self.historique.append(rapport)
        return rapport

Wskazówka na start: zbuduj swoją pierwszą rubrykę na zaledwie dwudziestu przypadkach, każ ją ocenić równolegle przez sędziego LLM i przez eksperta domenowego, a następnie porównaj oba szeregi. Rozbieżności powiedzą Ci, które kryteria są źle opisane, na długo zanim powiedzą Ci cokolwiek o jakości modelu.

Kluczowe wnioski

  • Twórz rubryki ewaluacyjne specyficzne dla Twojej domeny biznesowej, z explicitnymi wagami
  • Weryfikuj, czy suma wag pozostaje równa 1 w miarę ewolucji rubryki
  • Łącz ewaluację zautomatyzowaną (kod, długość) z podejściem LLM-as-Judge (jakość)
  • Testuj generowany kod poprzez jego wykonanie, z limitem czasu i w izolowanym środowisku
  • Buduj wielokrotnego użytku potok, który przechowuje historię kampanii