Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Loo kohandatud hindamisi

Õppetund 16 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Kohanda hindamisi oma valdkonnale
  2. Tõlgi ärinõue hindamismaatriksiks
  3. Kui masin hindab paremini kui inimene
  4. Tee hindamine korratavaks
  5. Peamised punktid

Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid temperature ja top_p aktsepteeritakse ainult siis, kui arutluse jõupingutus on none, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Need parameetrid määravad kõned peavad seetõttu sisaldama reasoning={"effort": "none"} (API Responses) või reasoning_effort="none" (Chat Completions). Allikad: Using GPT-6 · GPT-5.6 Terra.

2. novembri 2026 uuendus — Evals platvorm. OpenAI on teatanud oma Evals platvormi tegevuse lõpetamisest: olemasolevad hindamised on olnud ainult lugemisrežiimis alates 31. oktoobrist 2026 ning nii armatuurlaud kui ka API, sealhulgas hindajad, suletakse 30. novembril 2026. OpenAI on avaldanud migratsioonijuhise Promptfoole. Selles tunnis käsitletud hindamispõhimõtted kehtivad endiselt; muutub vaid tööriist.

Kohanda hindamisi oma valdkonnale

Üldised hindajad ei piisa kvaliteedi hindamiseks sinu konkreetses valdkonnas. Meditsiinilisel vestlusrobotil, juriidilisel assistendil ja turundustekstide tööriistal on erinevad kvaliteedikriteeriumid ning need kriteeriumid pole mitte ainult arvukamad, vaid ka erineva prioriteediga. Tooni mittevastavus uudiskirjas on tüütu; sama ebatäpsus annustamisjuhendis on tõsine viga. Üldine hindaja kohtleb mõlemat samamoodi, mis tähendab sisuliselt seda, et ei hinnata midagi.

Sellepärast vajad kohandatud hindamisi, mis põhinevad selgel hindamismaatriksil (rubric) ja tõlgivad sinu äriprioriteedid kaaludeks. Just sellise maatriksi me nüüd loome.

Tõlgi ärinõue hindamismaatriksiks

Hindamismaatriks on kaalutud kriteeriumide loend, mille summa on 1. Kasulikum tegevus pole struktuuri kodeerimine (see võtab umbes viisteist rida), vaid selle täitmine: otsustamine, et kliendi kasud kaaluvad 0,25, samas kui pikkus vaid 0,10, sunnib pidama selget vestlust tooteomanikega. Tulemuseks on ühine definitsioon sellest, mis on „hea vastus“, mida keegi hiljem vaidlustada ei saa.

from dataclasses import dataclass

@dataclass
class Kriteerium:
    nimi: str
    kirjeldus: str
    kaal: float  # 0 kuni 1, kaalude summa = 1

@dataclass
class Maatriks:
    nimi: str
    kriteeriumid: list[Kriteerium]

    def valideeri(self) -> bool:
        total = sum(k.kaal for k in self.kriteeriumid)
        return abs(total - 1.0) < 0.01

# Näide: turundustekstide assistendi hindamismaatriks
maatriks_turundus = Maatriks(
    nimi="Turundustekstide kvaliteet",
    kriteeriumid=[
        Kriteerium("toon", "Toon on professionaalne ja kaasahaarav", 0.20),
        Kriteerium("cta", "Sisaldab selget tegevuskutset", 0.15),
        Kriteerium("kasud", "Toob esile kliendi kasud", 0.25),
        Kriteerium("pikkus", "Järgib nõutud pikkust", 0.10),
        Kriteerium("grammatika", "Puuduvad grammatika- või õigekirjavead", 0.15),
        Kriteerium("bränd", "Järgib brändi juhiseid", 0.15),
    ],
)

Meetodit valideeri tasub kasutada testides, mitte ainult kirjutada. Maatriksid evolveeruvad: lisad vastavuskriteeriumi, eemaldad mitte enam vajaliku ja summa nihkub 1,15-le, ilma et midagi anomaaliat märgata annaks. Skoorid jäävad arvutatavaks, kuid on valed ning versioonide võrdlemisel viivad ekslike järeldusteni.

Hindaja tõlgib seejärel maatriksi vihjeks (prompt), küsib iga kriteeriumi kohta 0–5 skoori ja arvutab kaalutud üldskoori. Iga skooriga kaasneb lühike kommentaar: just see võimaldab sul halbu juhtumeid üle vaadates aru saada, kas mudel vastas halvasti või oli sinu kriteerium halvasti sõnastatud.

import openai
import json

client = openai.OpenAI()

def hinda_mitme_kriteeriumiga(
    küsimus: str,
    vastus: str,
    maatriks: Maatriks,
) -> dict:
    """Hindab vastust mitme kriteeriumiga maatriksi põhjal."""

    kriteeriumide_tekst = "\n".join(
        f"- {k.nimi} (kaal: {k.kaal}): {k.kirjeldus}"
        for k in maatriks.kriteeriumid
    )

    prompt = (
        "Hinda seda vastust järgmiste kriteeriumide põhjal.\n"
        "Anna iga kriteeriumi eest skoor vahemikus 0 kuni 5.\n\n"
        f"Esitatud küsimus: {küsimus}\n"
        f"Hinnatav vastus: {vastus}\n\n"
        f"Kriteeriumid:\n{kriteeriumide_tekst}\n\n"
        "Vasta JSON-formaadis objektiga 'scores', mis sisaldab iga kriteeriumi "
        "kohta skoori (0-5) ja lühikest kommentaari."
    )

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

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

        # Arvuta kaalutud skoor
        kaalutud_skoor = 0
        for kriteerium in maatriks.kriteeriumid:
            if kriteerium.nimi in skoorid:
                toor_skoor = skoorid[kriteerium.nimi]["score"] / 5.0
                kaalutud_skoor += toor_skoor * kriteerium.kaal

        return {
            "üldskoor": kaalutud_skoor,
            "üksikasjalikud_skoorid": skoorid,
            "maatriks": maatriks.nimi,
        }
    except (json.JSONDecodeError, KeyError):
        return {"üldskoor": 0, "viga": "Parsimine ebaõnnestus"}

Jälgi arvutustsüklit: kui hindaja vastusest puudub mõni kriteerium, ignoreeritakse seda vaikselt ja see annab kaalutud skoori nulli. Suurepärane vastus võib seetõttu peatuda 0,75 juures lihtsalt sellepärast, et hindaja unustas võtme. Kui sinu skoorid tunduvad jäävat seletamatu lae alla, kontrolli üksikasjalikud_skoorid enne, kui süüdistad hinnatavat mudelit.

Kui masin hindab paremini kui inimene

LLM-i kasutamine koodi hindamiseks on kulukas lühike tee: ainus oluline otsus on käivitamine. Allpool olev hindaja liidab genereeritud koodi ja testi, kirjutab need ajutisse faili, käivitab need ja loeb õnnestumised. Saadud skoor ei vaja tõlgendamist – test kas läbib või ei läbi.

import subprocess
import tempfile

def hinda_python_koodi(
    genereeritud_kood: str,
    testid: list[str],
) -> dict:
    """Hindab Pythoni koodi, käivitades seda testide vastu."""
    testide_tulemused = []

    for i, test in enumerate(testid):
        täielik_kood = f"{genereeritud_kood}\n\n{test}"

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

            try:
                tulemus = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                õnnestus = tulemus.returncode == 0
                testide_tulemused.append({
                    "test": i,
                    "õnnestus": õnnestus,
                    "väljund": tulemus.stdout[:200],
                    "viga": tulemus.stderr[:200] if not õnnestus else "",
                })
            except subprocess.TimeoutExpired:
                testide_tulemused.append({
                    "test": i,
                    "õnnestus": False,
                    "viga": "Aegumine (10s)",
                })

    õnnestumiste_arv = sum(1 for r in testide_tulemused if r["õnnestus"])
    return {
        "skoor": õnnestumiste_arv / len(testid) if testid else 0,
        "läbitud_testid": õnnestumiste_arv,
        "testide_koguarv": len(testid),
        "üksikasjad": testide_tulemused,
    }

timeout=10 pole mugavusabinõu: mudel toodab regulaarselt lõpmatuid tsükleid ja ilma selle piiranguta jääb sinu hindamiskampaania esimese ebaõnnestunud juhtumi taha kinni. Samuti pea meeles, et käivitad koodi, mida sa pole ise kirjutanud – väljaspool isoleeritud arenduskeskkonda nõuab see funktsioon liivakasti (sandbox).

Kokkuvõte illustreerib segajuhtu, kus osa hindamisest on mehaaniline ja osa mitte. Pikkust saab mõõta: arvutatud suhe karistab sümmeetriliselt nii liiga lühikest kui ka liiga pikka kokkuvõtet, mis väldib mudeli trikki kopeerida lähteteksti, et midagi välja jätta. Truudust seevastu ei saa reegliga mõõta ja see taandub LLM-hindajale, esitades otsese küsimuse väljamõeldud info kohta.

def hinda_kokkuvõtet(
    algne_tekst: str,
    kokkuvõte: str,
    sihtpikkus: int = 100,
) -> dict:
    """Hindab kokkuvõtte kvaliteeti."""
    sõnad_kokkuvõttes = len(kokkuvõte.split())
    pikkuse_suhe = min(
        sõnad_kokkuvõttes / sihtpikkus,
        sihtpikkus / max(sõnad_kokkuvõttes, 1),
    )

    # Truudus LLM-i kaudu
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Kas järgnev kokkuvõte on algsele tekstile truu? "
            f"Kas see sisaldab väljamõeldud infot?\n\n"
            f"Algne tekst (väljavõte): {algne_tekst[:2000]}\n\n"
            f"Kokkuvõte: {kokkuvõte}\n\n"
            f"Vasta JSON-formaadis võtmetega: truudus (0-5), "
            f"hallutsinatsioonid (jah/ei), kommentaar (lühike)."
        ),
        temperature=0.0,
    )

    try:
        truudus = json.loads(response.output_text)
    except json.JSONDecodeError:
        truudus = {"truudus": 0, "hallutsinatsioonid": "tundmatu"}

    return {
        "pikkuse_skoor": pikkuse_suhe,
        "truuduse_skoor": truudus.get("truudus", 0) / 5.0,
        "hallutsinatsioonid": truudus.get("hallutsinatsioonid", "tundmatu"),
        "sõnad_kokkuvõttes": sõnad_kokkuvõttes,
        "sihtpikkus": sihtpikkus,
    }

Tee hindamine korratavaks

Hindamine, mida käsitsi uuesti käivitad, jääb lõpuks soiku. Torustik (pipeline) kapseldab maatriksi ja hoiab kampaaniate ajalugu, muutes ühekordse mõõtmise ajareaks: näed, et keskmine skoor langes 0,81-lt 0,79-le pärast teisipäevast vihje muutmist – teave, mida ükski isoleeritud käivitamine anda ei saaks.

class HindamiseTorustik:
    """Taaskasutatav hindamistorustik."""

    def __init__(self, nimi: str, maatriks: Maatriks):
        self.nimi = nimi
        self.maatriks = maatriks
        self.ajalugu: list[dict] = []

    def hinda_partii(
        self,
        andmestik: list[dict],
        mudel: str,
        süsteemi_vihje: str,
    ) -> dict:
        """Hindab täieliku partii ja tagastab meetrikad."""
        tulemused = []

        for juhtum in andmestik:
            response = client.responses.create(
                model=mudel,
                instructions=süsteemi_vihje,
                input=juhtum["input"],
            )

            hindamise_tulemus = hinda_mitme_kriteeriumiga(
                juhtum["input"],
                response.output_text,
                self.maatriks,
            )
            tulemused.append(hindamise_tulemus)

        skoorid = [r["üldskoor"] for r in tulemused]
        aruanne = {
            "torustik": self.nimi,
            "mudel": mudel,
            "juhtumite_arv": len(andmestik),
            "keskmine_skoor": sum(skoorid) / len(skoorid),
            "min_skoor": min(skoorid),
            "max_skoor": max(skoorid),
        }

        self.ajalugu.append(aruanne)
        return aruanne

Üks nõuanne alustamiseks: koosta oma esimene maatriks vaid kahekümne juhtumi põhjal, lase seda hinnata paralleelselt nii LLM-hindajal kui ka valdkonna eksperdil ning võrdle kahte seeriat. Lahknevused näitavad, millised kriteeriumid on halvasti kirjeldatud, palju enne, kui need ütlevad midagi mudeli kvaliteedi kohta.

Peamised punktid

  • Loo oma äridomeenile spetsiifilised hindamismaatriksid selgete kaaludega
  • Veendu, et kaalude summa püsib 1 juures, kui maatriks muutub
  • Kombineeri automatiseeritud hindamist (kood, pikkus) ja LLM-hindajat (kvaliteet)
  • Testi genereeritud koodi, käivitades selle koos ajaülemiku ja isoleeritud keskkonnaga
  • Ehita taaskasutatav torustik, mis hoiab kampaaniate ajalugu