Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ustvari prilagojena vrednotenja

Lekcija 16 od 20 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Prilagodi vrednotenja svoji domeni
  2. Poslovno zahtevo prevedi v rubriko
  3. Ko stroj ocenjuje bolje od človeka
  4. Poskrbi za ponovljivost vrednotenja
  5. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra temperature in top_p sta sprejeta le pri naporu razmišljanja (reasoning effort) vrednosti none, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določiti reasoning={"effort": "none"} (API Responses) ali reasoning_effort="none" (Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Posodobitev platforme Evals z dne 2. novembra 2026. OpenAI je napovedal konec svoje platforme Evals: obstoječa vrednotenja so samo za branje od 31. oktobra 2026, nadzorna plošča in API, vključno z ocenjevalci, pa bodo zaprti 30. novembra 2026. OpenAI je objavil vodnik za selitev na Promptfoo. Načela vrednotenja v tej lekciji ostajajo veljavna; spreminja se le orodje.

Prilagodi vrednotenja svoji domeni

Splošni ocenjevalci niso dovolj za oceno kakovosti v tvoji specifični domeni. Medicinski klepetalni bot, pravni pomočnik in orodje za pisanje marketinških vsebin imajo vsak svoja merila kakovosti, ki se ne razlikujejo le po številu, temveč tudi po prioritetah. Neskladje tona v novičniku je nadležno; enaka približnost v navodilih za odmerjanje pa je resna napaka. Splošni ocenjevalec obravnava oboje enako, kar pomeni, da pravzaprav ne ocenjuje ničesar.

Zato potrebuješ prilagojena vrednotenja, zgrajena na eksplicitni rubriki, ki tvoje poslovne prioritete prevede v uteži. To je rubrika, ki jo bomo zdaj zgradili.

Poslovno zahtevo prevedi v rubriko

Rubrika je seznam tehtanih meril, katerih vsota znaša 1. Najkoristnejši del ni kodiranje strukture, kar traja približno petnajst vrstic, temveč njeno izpolnjevanje: odločitev, da koristi za stranko tehtajo 0,25, dolžina pa le 0,10, prisili k eksplicitnemu pogovoru z lastniki izdelka. Rezultat je skupna opredelitev „dobrega odgovora”, o kateri nihče ne more razpravljati naknadno.

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),
    ],
)

Metodo valider je vredno klicati v testih, ne le zapisati. Rubrike se razvijajo: dodaš merilo za skladnost, odstraniš tisto, ki ni več uporabno, in vsota zdrsi na 1,15, ne da bi karkoli opozorilo na anomalijo. Rezultati ostanejo izračunljivi, a napačni, in ko jih primerjaš med različicami, te bodo pripeljali do napačnih zaključkov.

Ocenjevalec nato rubriko prevede v poziv, zahteva oceno od 0 do 5 za vsako merilo in ponovno sestavi tehtani globalni rezultat. Vsaka ocena ima kratek komentar: to ti bo omogočilo, da pri pregledovanju slabih primerov razumeš, ali je model slabo odgovoril ali pa je bilo tvoje merilo slabo oblikovano.

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é"}

Pazi na zanko za izračun: merilo, ki manjka v odgovoru sodnika, je tiho prezrto in prispeva ničlo k tehtanemu rezultatu. Odličen odgovor bi se zato lahko ustavil pri 0,75 preprosto zato, ker je sodnik pozabil ključ. Če se tvoji rezultati zdi, da so obtičali pod nepojasnjeno zgornjo mejo, najprej preveri scores_details, preden okriviš ocenjevani model.

Ko stroj ocenjuje bolje od človeka

Imeti LLM, ki ocenjuje kodo, je draga bližnjica: edina sodba, ki šteje, je izvedba. Spodnji ocenjevalec združi generirano kodo in test, jo zapiše v začasno datoteko, izvede in prešteje uspehe. Nastali rezultat ne potrebuje razlage – test je opravljen ali pa ni.

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,
    }

timeout=10 ni zgolj previdnostni ukrep: model redno proizvaja neskončne zanke in brez te omejitve se tvoja kampanja vrednotenja zatakne že pri prvem neuspelem primeru. Prav tako se spomni, da izvajaš kodo, ki je nisi napisal sam – zunaj izoliranega razvojnega okolja ta funkcija zahteva peskovnik.

Povzetek ponazarja mešani primer, kjer je del sodbe mehanski, del pa ne. Dolžina je merljiva: izračunano razmerje kaznuje povzetek, ki je prekratek, in tistega, ki je predolg, simetrično, kar prepreči trik modela s kopiranjem izvornega besedila, da ne bi kaj izpustil. Zvestoba pa ni merljiva s pravilom in se vrne k sodniku LLM z neposrednim vprašanjem o izmišljenih informacijah.

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,
    }

Poskrbi za ponovljivost vrednotenja

Vrednotenje, ki ga ročno ponavljaš, sčasoma preneha biti ponovljeno. Cevovod encapsulira rubriko in hrani zgodovino kampanj, s čimer enkratno meritev spremeni v časovno vrsto: vidiš, da je povprečni rezultat padel z 0,81 na 0,79 po spremembi poziva v torek, informacije, ki ti je nobena izolirana izvedba ne bi mogla dati.

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

Nasvet za začetek: svojo prvo rubriko zgradi na le dvajsetih primerih, naj jo vzporedno oceni sodnik LLM in strokovnjak s področja, nato pa primerjaj obe seriji. Neskladja ti bodo povedala, katera merila so slabo opisana, dolgo preden ti bodo povedala karkoli o kakovosti modela.

Ključne ugotovitve

  • Ustvari evalvacijske rubrike, specifične za tvojo poslovno domeno, z eksplicitnimi utežmi
  • Preveri, da vsota uteži ostane 1, ko se rubrika razvija
  • Združi avtomatizirano vrednotenje (koda, dolžina) in LLM-as-Judge (kakovost)
  • Testiraj generirano kodo z njeno izvedbo, s časovno omejitvijo in v izoliranem okolju
  • Zgradi ponovno uporaben cevovod, ki hrani zgodovino kampanj