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

Mõõdikud ja võrdlusalused

Õppetund 17 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Kvaliteedi mõõtmine mõõdikute abil
  2. Tähenduse võrdlemine, mitte sõnade
  3. Veendumine, et mudel ei luuleta
  4. Korratava võrdlusaluse koostamine
  5. Peamised punktid

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

Kvaliteedi mõõtmine mõõdikute abil

Lisaks LLM-kohtuniku hinnetele eksisteerivad kvantitatiivsed mõõdikud, millega hinnata suurte keelemudelite (LLM) väljundite erinevaid aspekte. Nende väärtus ei seisne selles, et need oleksid täpsemad – hästi koostatud LLM-kohtunik märkab nüansse, mida ükski valem kunagi ei taba –, vaid selles, et need on stabiilsed ja odavad. Koosiinussarnasus annab igal käivitamisel täpselt sama tulemuse, maksab peaaegu mitte midagi ja seetõttu saab seda käitada tuhandete juhtumite peal iga koodimuudatuse korral. LLM-kohtuniku jäta alles mõõtmete jaoks, mis seda tõeliselt vajavad.

Enne kui koondame need korratavateks võrdlusalusteks, vaatame üle olulisemad mõõdikud.

Tähenduse võrdlemine, mitte sõnade

Tekstide võrdlemine tähemärgi haaval muutub kasutuks niipea, kui sõnastus on vaba. Semantiline sarnasus lahendab selle probleemi: iga tekst teisendatakse manustamismudeli (embedding model) abil vektoriks ja mõõdetakse nende kahe vektori vahelist nurka. Kaks lauset, mis väljendavad sama mõtet erinevate sõnadega, osutavad samas suunas.

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Calculates the cosine similarity between two vectors."""
    a = np.array(vec_a)
    b = np.array(vec_b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def semantic_similarity(text_a: str, text_b: str) -> float:
    """Measures the semantic similarity between two texts."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[text_a, text_b],
    )

    vec_a = response.data[0].embedding
    vec_b = response.data[1].embedding

    return cosine_similarity(vec_a, vec_b)

# Example
score = semantic_similarity(
    "The cat is on the rug.",
    "A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}")  # ~0.85+

Näide on õpetlik: kaks lauset, millel pole ühtegi ühist sõna, saavad hindeks üle 0,85. See on meetodi tugevus, kuid samas ka selle lõks. Semantiline sarnasus ignoreerib eitamist ja astme nüansse – laused „makse aktsepteeriti“ ja „makse lükati tagasi“ näivad vektorruumis väga sarnased. Seetõttu ära kasuta seda kunagi üksi vastuse valideerimisel, kui oluline on faktiline täpsus.

Kui küsimus on „kas vastus tegelikult käsitleb esitatud küsimust“, ei asenda ühtegi valemit inimlik hinnang. Allpool toodud asjakohasuse hinne jaotab selle hinnangu kolmeks eraldiseisvaks küsimuseks: kas vastus on otsene? Kas see püsib teemas? Kas see on täielik? See jaotus on parem kui üldhinne, sest see ütleb sulle, millises suunas prompti parandada – sõnaohtrale mudelile ja puudulikule mudelile on vaja vastupidiseid parandusi.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Evaluates whether the answer is relevant to the question."""
    prompt = (
        "Evaluate the relevance of this answer.\n\n"
        f"Question: {question}\n"
    )
    if context:
        prompt += f"Context provided: {context[:1000]}\n"
    prompt += (
        f"Answer: {answer}\n\n"
        "Criteria:\n"
        "1. Does the answer directly address the question? (0-5)\n"
        "2. Does the answer contain unrequested information? (0-5, 5=none)\n"
        "3. Is the answer complete? (0-5)\n\n"
        "Respond in JSON with keys: direct, focus, completeness."
    )

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

    import json
    try:
        scores = json.loads(response.output_text)
        average = sum(scores.values()) / (len(scores) * 5)
        return {"score": average, "details": scores}
    except (json.JSONDecodeError, TypeError):
        return {"score": 0, "error": "Parsing failed"}

Pane tähele teise kriteeriumi pööratud sõnastust, kus 5 tähendab „soovimatu teabe puudumine“. See võimaldab liita kolm hinnet samas suunas, kuid on lugemisel ebaloomulik: kui lisad oma kriteeriume, pea sellest konventsioonist kinni, muidu saad keskmisi, which premeerivad vigu, mida tahtsid karistada.

Veendumine, et mudel ei luuleta

Dokumentidel põhinevas küsimuste ja vastuste rakenduses ei ole otsustavaks mõõdikuks kirjutamise kvaliteet, vaid truudus allikale. Kontrollprintsiip on lihtne: esita kohtunikule algne kontekst ja genereeritud vastus ning palu tal liigitada iga väide kas kontekstiga põhjendatuks, kontekstist puuduvaks või sellega vastuolus olevaks. Viimase kahe kategooria eristamine on oluline, sest pelgalt puuduv väide võib olla üldteadmistes korrektne, samas kui allikaga vastuolus olev väide on alati viga.

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Detects statements not supported by the context."""
    prompt = (
        "Analyze this answer and identify any statement "
        "that is NOT supported by the provided context.\n\n"
        f"Context: {context[:3000]}\n\n"
        f"Answer: {answer}\n\n"
        "For each statement in the answer, indicate:\n"
        "- supported: the statement is in the context\n"
        "- unsupported: the statement is not in the context\n"
        "- invented: the statement contradicts the context\n\n"
        "Respond in JSON with the key statements (list) and "
        "fidelity_score (0 to 1)."
    )

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

    import json
    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"fidelity_score": 0, "error": "Parsing failed"}

Konteksti kärpimine 3000 märgini on piirang, millest pead teadlik olema: kui allikas ületab selle suuruse, loetakse täiesti täpsed väited põhjendamatuks lihtsalt seetõttu, et neid õigustav lõik on ära lõigatud. Pikkade dokumentide puhul jaga need osadeks ja hinda iga osa eraldi, selle asemel et leppida süstemaatiliste valepositiivsete tulemustega.

Korratava võrdlusaluse koostamine

Võrdlusalus (benchmark) ei ole lihtsalt järjekordne mõõdik: see on seadistus, mis külmutab andmestiku ja protokolli, et kahe käivituse tulemused oleksid võrreldavad. Allpool olev klass mõõdab asjakohasust, truudust (kui kontekst on olemas), latentsust ja kulu, salvestades iga tulemuse kuupäevaga ja märgistatuna prompti versiooni järgi.

from dataclasses import dataclass, field
import time

@dataclass
class BenchmarkResult:
    model: str
    prompt_version: str
    scores: dict
    avg_latency: float
    total_cost: float
    date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))

class Benchmark:
    """Reusable benchmark for comparing models and prompts."""

    def __init__(self, name: str, dataset: list[dict]):
        self.name = name
        self.dataset = dataset
        self.results: list[BenchmarkResult] = []

    def run(
        self,
        model: str,
        system_prompt: str,
        prompt_version: str,
    ) -> BenchmarkResult:
        """Runs the benchmark with a given model and prompt."""
        relevance_scores = []
        hallucination_scores = []
        latencies = []
        cost = 0

        for case in self.dataset:
            start = time.perf_counter()
            response = client.responses.create(
                model=model,
                instructions=system_prompt,
                input=case["input"],
            )
            latency = time.perf_counter() - start
            latencies.append(latency)

            # Evaluate
            relevance = relevance_score(
                case["input"], response.output_text
            )
            relevance_scores.append(relevance["score"])

            if case.get("context"):
                halluc = detect_hallucinations(
                    case["context"], response.output_text
                )
                hallucination_scores.append(
                    halluc.get("fidelity_score", 0)
                )

        result = BenchmarkResult(
            model=model,
            prompt_version=prompt_version,
            scores={
                "relevance": sum(relevance_scores) / len(relevance_scores),
                "fidelity": (
                    sum(hallucination_scores) / len(hallucination_scores)
                    if hallucination_scores else None
                ),
            },
            avg_latency=sum(latencies) / len(latencies),
            total_cost=cost,
        )

        self.results.append(result)
        return result

    def compare(self) -> str:
        """Compares all benchmark results."""
        lines = [f"Benchmark: {self.name}\n"]
        for r in self.results:
            lines.append(
                f"  {r.model} (prompt {r.prompt_version}) | "
                f"Relevance: {r.scores['relevance']:.2f} | "
                f"Latency: {r.avg_latency:.2f}s"
            )
        return "\n".join(lines)

Funktsiooni compare väljund asetab tahtlikult asjakohasuse ja latentsuse samale reale, sest nii tehakse tegelikult otsuseid. Mudel, mis võidab asjakohasuses kaks sajandikku, kuid kahekordistab vastamisaega, ei ole interaktiivse rakenduse jaoks parem valik; öiseks töötlemiseks võib olla küll. Tabel ei otsusta sinu eest; see toob kompromissi otse sinu silme ette.

Lõpuks jääb total_cost selles teostuses nulliks. Täida see API poolt tagastatud kasutusväljadest: mudelite võrdlus, mis jätab kõrvale kulu, jätab välja kriteeriumi, mis lahendab arutelu sinu finantsmeeskonnaga.

Peamised punktid

  • Semantiline sarnasus mõõdab tähendust, kuid jääb pimedaks eitamise suhtes
  • Jaota asjakohasus eraldiseisvateks kriteeriumideks, mitte üldhindeks
  • Tuvasta luulud, vastandades vastuse allika kontekstile
  • Loo korratavad võrdlusalused, mis mõõdavad üheaegselt kvaliteeti, latentsust ja kulu
  • Kombineeri automaatseid mõõdikuid ja LLM-kohtunikku terviklikuks hindamiseks