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

Metrike in merila uspešnosti

Lekcija 17 od 20 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Merjenje kakovosti z metrikami
  2. Primerjanje pomena namesto besed
  3. Preverjanje, ali model ne halucinira
  4. Sestavljanje ponovljivega merila uspešnosti (Benchmark)
  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.

Merjenje kakovosti z metrikami

Poleg ocen tipa LLM-as-Judge obstajajo kvantitativne metrike za ovrednotenje različnih vidikov izhodov LLM. Njihova vrednost ni v tem, da so natančnejše – dobro zasnovan sodnik LLM zazna stvari, ki jih nobena formula nikoli ne bo – temveč v tem, da so stabilne in poceni. Kosinusna podobnost vrne popolnoma enako številko ob vsakem zagonu, stane skoraj nič in jo zato lahko zaženete na tisočih primerih ob vsaki potrditvi kode (commit). Sodnika LLM nato rezervirate za dimenzije, ki ga resnično zahtevajo.

Preden jih združite v ponovljiva merila uspešnosti (benchmarks), si bomo ogledali bistvene metrike.

Primerjanje pomena namesto besed

Primerjava dveh besedil znak za znak postane neuporabna, takoj ko je fraziranje svobodno. Semantična podobnost obide to težavo: vsako besedilo se z modelom za vgradnje (embedding) pretvori v vektor, izmerimo pa kot med obema vektorjema. Dva stavka, ki pravita isto z različnimi besedami, kažeta v isto smer.

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Izračuna kosinusno podobnost med dvema vektorjema."""
    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:
    """Izmeri semantično podobnost med dvema besediloma."""
    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)

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

Primer je poučen: dva stavka brez skupnih besed dosežeta oceno nad 0,85. To je moč metode, pa tudi njena past. Semantična podobnost ignorira negacijo in nianse stopnje – „plačilo je bilo sprejeto” in „plačilo je bilo zavrnjeno” sta si vektorsko zelo podobna. Zato je nikoli ne uporabljajte samostojno za validacijo odgovora, kjer je pomembna dejanska točnost.

Ko je vprašanje „ali odgovor dejansko naslavlja zastavljeno vprašanje”, nobena formula ne nadomesti presoje. Spodnja ocena ustreznosti (relevance score) to presojo razčleni na tri ločena vprašanja: Ali je odgovor neposreden? Ali ostaja osredotočen? Ali je popoln? Ta razčlenitev je boljša od globalne ocene, ker vam pove, v katero smer popraviti poziv – zgovoren model in nepopoln model zahtevata nasprotna popravila.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Ovrednoti, ali je odgovor ustrezen vprašanju."""
    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"}

Upoštevajte obrnjeno formulacijo drugega merila, kjer 5 pomeni „brez nezahtevanih informacij”. To omogoča seštevanje treh ocen v isto smer, vendar je za branje protislovno: ko dodajate lastna merila, upoštevajte to konvencijo, sicer boste dobili povprečja, ki nagrajujejo napako, ki ste jo nameravali kaznovati.

Preverjanje, ali model ne halucinira

V aplikaciji za vprašanja in odgovore na podlagi dokumentov odločilna metrika ni kakovost pisanja, temveč zvestoba viru. Nadzorno načelo je preprosto: sodniku predstavite izvirni kontekst in ustvarjeni odgovor ter ga prosite, da vsako trditev razvrsti kot podprto s kontekstom, odsotno iz konteksta ali v nasprotju s kontekstom. Razlika med zadnjima dvema kategorijama je pomembna, saj je trditev, ki je zgolj odsotna, morda točno splošno znanje, medtem ko je trditev, ki nasprotuje viru, vedno napaka.

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Zazna trditve, ki jih kontekst ne podpira."""
    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"}

Okrajšanje konteksta na 3000 znakov je omejitev, ki se je morate zavedati: če vir presega to velikost, bodo popolnoma točne trditve štete kot nepodprte zgolj zato, ker je bil odlomek, ki jih utemeljuje, odrezan. Pri dolgih dokumentih razdelite besedilo in ovrednotite po sekcijah, namesto da bi sprejeli sistematične lažno pozitivne rezultate.

Sestavljanje ponovljivega merila uspešnosti (Benchmark)

Merilo uspešnosti ni le še ena metrika: gre za postavitev, ki zamrzne nabor podatkov in protokol, tako da sta dva zagona primerljiva. Spodnji razred izmeri ustreznost, zvestobo (ko je na voljo kontekst), zakasnitev (latency) in stroške, nato pa vsak rezultat datira in označi z različico poziva.

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:
    """Ponovno uporabno merilo uspešnosti za primerjavo modelov in pozivov."""

    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:
        """Zažene merilo uspešnosti z danim modelom in pozivom."""
        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)

            # Ovrednoti
            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:
        """Primerja vse rezultate merila uspešnosti."""
        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)

Izhod metode compare namerno postavi ustreznost in zakasnitev v isto vrstico, ker se odločitev dejansko sprejme tako. Model, ki pridobi dve stotinki točke pri ustreznosti, a podvoji čas odziva, ni boljša izbira za interaktivno aplikacijo; morda pa je za nočno obdelavo. Tabela ne odloči namesto vas; kompromis vam postavi neposredno pred oči.

Končno, total_cost v tej implementaciji ostaja nič. Izpolnite ga iz polj uporabe (usage), ki jih vrne API: primerjava modelov, ki izpušča stroške, izpušča merilo, ki bo odločilo razpravo z vašo finančno ekipo.

Ključne ugotovitve

  • Semantična podobnost meri pomen, vendar ostaja slepa za negacijo
  • Ustreznost razčlenite na ločena merila namesto globalne ocene
  • Halucinacije zaznajte s soočenjem odgovora z izvornim kontekstom
  • Ustvarite ponovljiva merila uspešnosti, ki hkrati merijo kakovost, zakasnitev in stroške
  • Združite samodejne metrike in LLM-as-Judge za celovito ovrednotenje