Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kurkite individualius vertinimus

Paskaita 16 iš 20 Atnaujinta 2026 m. lapkričio 3 d. Pažengusiems
Šiame puslapyje
  1. Pritaikykite vertinimus savo sričiai
  2. Verslo reikalavimą paversk rubrika
  3. Kai mašina vertina geriau nei žmogus
  4. Padaryk vertinimą pakartojamą
  5. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ dokumentaciją: parametrai temperature ir top_p priimami tik esant none lygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodyti reasoning={"effort": "none"} (API Responses) arba reasoning_effort="none" (Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.

2026 m. lapkričio 2 d. naujiena — „Evals“ platforma. „OpenAI“ paskelbė apie savo „Evals“ platformos veiklos pabaigą: esami vertinimai nuo 2026 m. spalio 31 d. yra tik skaitymo režimu, o tiek skydelis, tiek API, įskaitant vertintojus, bus uždaryti 2026 m. lapkričio 30 d. „OpenAI“ paskelbė migracijos į „Promptfoo“ gidą. Šioje pamokoje pateikti vertinimo principai lieka galioti; keičiasi tik įrankis.

Pritaikykite vertinimus savo sričiai

Bendrieji vertintojai nepakankami kokybei įvertinti jūsų specifinėje srityje. Medicininis pokalbių robotas, teisinis asistentas ir rinkodaros rašymo įrankis turi skirtingus kokybės kriterijus, ir šie kriterijai yra ne tik gausesni – jie prioritetizuojami skirtingai. Tonas, neatitinkantis naujienlaiškio, yra tik nepatogumas; tas pats netikslumas dozavimo instrukcijoje yra rimta klaida. Bendrasis vertintojas abu atvejus traktuoja vienodai, o tai reiškia, kad jis iš tikrųjų nieko nevertina.

Štai kodėl tau reikia individualių vertinimų, pagrįstų aiškia rubrika, kuri tavo verslo prioritetus paverčia svoriais. Būtent tokią rubriką ir kursime.

Verslo reikalavimą paversk rubrika

Rubrika – tai pasvertų kriterijų sąrašas, kurio suma lygi 1. Naudingiausia užduotis – ne struktūros kodavimas (tam užtenka apie penkiolikos eilučių), o jos užpildymas: sprendimas, kad kliento nauda sveria 0,25, o ilgis – tik 0,10, verčia aiškiai pasikalbėti su produkto savininkais. Galutinis rezultatas – bendras „gero atsakymo“ apibrėžimas, dėl kurio niekas negalės ginčytis 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),
    ],
)

Metodą valider verta kviesti testuose, o ne tik parašyti. Rubrikos keičiasi: pridėjus atitikties kriterijų arba pašalinus nebenaudojamą, suma gali nukrypti iki 1,15, ir niekas nepastebės anomalijos. Balai vis dar bus apskaičiuojami, tik bus neteisingi, o lyginant juos tarp versijų, padarysi klaidingas išvadas.

Tada vertintojas rubriką paverčia užklausa, paprašo 0–5 balo už kiekvieną kriterijų ir perskaičiuoja pasvertą bendrą balą. Kiekvienas balas pateikiamas su trumpu komentaru: tai leis tau, peržiūrint blogus atvejus, suprasti, ar modelis atsakė prastai, ar tavo kriterijus buvo suformuluotas netiksliai.

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

Atkreipk dėmesį į skaičiavimo ciklą: jei vertintojo atsakyme trūksta kriterijaus, jis tyliai ignoruojamas ir pasvertam balui suteikia nulį. Todėl puikus atsakymas gali gauti tik 0,75 balo vien todėl, kad vertintojas pamiršo vieną punktą. Jei tavo balai, atrodo, sustingo nepaaiškinamose lubose, prieš kaltinant vertinamą modelį, patikrink scores_details.

Kai mašina vertina geriau nei žmogus

LLM kodui vertinti yra brangus trumpinys: vienintelis svarbus verdiktas yra vykdymas. Toliau pateiktas vertintojas sujungia sugeneruotą kodą ir testą, įrašo juos į laikiną failą, įvykdo ir suskaičiuoja sėkmes. Gautam balui nereikia interpretacijos – testas arba pavyksta, arba ne.

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 nėra šiaip sau atsargumo priemonė: modeliai reguliariai kuria begalines kilpas, ir be šios ribos tavo vertinimo kampanija įstrigtų ties pirmuoju nepavykusiu atveju. Taip pat atmink, kad vykdai kodą, kurio nerašei – už izoliuotos kūrimo aplinkos ribų šiai funkcijai reikia smėlio dėžės (sandbox).

Santrauka iliustruoja mišrų atvejį, kai dalis vertinimo yra mechaninė, o dalis – ne. Ilgį galima išmatuoti: apskaičiuotas santykis baudžia tiek per trumpą, tiek per ilgą santrauką simetriškai, taip išvengiant modelio gudrybės kopijuoti šaltinio tekstą, kad nieko nepraleistų. Tuo tarpu tikslumo negalima išmatuoti taisykle, todėl tenka grįžti prie LLM vertintojo, tiesiogiai klausiant apie sugalvotą informaciją.

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

Padaryk vertinimą pakartojamą

Vertinimas, kurį kartoji rankiniu būdu, ilgainiui nustoja būti kartojamas. Vamzdynas (pipeline) inkapsuliuoja rubriką ir saugo kampanijų istoriją, paviesdamas vienkartinį matavimą į laiko eilutę: matai, kad vidutinis balas sumažėjo nuo 0,81 iki 0,79 po antradienio užklausos pakeitimo – informacija, kurios negalėtum gauti iš vienkartinio vykdymo.

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

Patarimas pradedantiesiems: sukurk savo pirmąją rubriką tik dvidešimčiai atvejų, leisk ją įvertinti lygiagrečiai LLM vertintojui ir srities ekspertui, tada palygink abi eilutes. Skirtumai parodys, kurie kriterijai aprašyti netiksliai, gerokai anksčiau nei jie ką nors pasakys apie modelio kokybę.

Svarbiausi punktai

  • Kurk vertinimo rubrikas, specifines tavo verslo sričiai, su aiškiais svoriais
  • Patikrink, ar svorių suma lieka lygi 1, rubrikai evoliucionuojant
  • Derink automatinį vertinimą (kodas, ilgis) ir LLM kaip vertintoją (kokybė)
  • Testuok sugeneruotą kodą jį vykdydami, naudodami laiko limitą ir izoliuotą aplinką
  • Sukurk pakartotinai naudojamą vamzdyną, kuris saugo kampanijų istoriją