Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Rādītāji un etaloni

Nodarbība 17 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Kvalitātes mērīšana ar rādītājiem
  2. Nozīmes salīdzināšana, nevis vārdu
  3. Pārliecināšanās, ka modelis nehalucinē
  4. Reproducējama etalona (Benchmark) izveide
  5. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek pieņemti tikai ar spriešanas piepūli (reasoning effort) vērtībā none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tāpēc izsaukumos, kuros iestatīti šie parametri, ir jānorāda reasoning={"effort": "none"} (API Responses) vai reasoning_effort="none" (Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.

Kvalitātes mērīšana ar rādītājiem

Papildus LLM-as-Judge vērtējumiem eksistē kvantitatīvi rādītāji, lai novērtētu dažādus LLM izejas aspektus. To vērtība nav precizitātē – labi izveidots LLM tiesnesis saskata to, ko neviena formula nespēs, – bet gan stabilitātē un lētumā. Kosinusu līdzība katrā izpildes reizē atgriež tieši to pašu skaitli, maksā gandrīz neko un tāpēc ar katru kodu versiju (commit) var pārbaudīt tūkstošiem gadījumu. LLM tiesnesi tad atstāj tiem aspektiem, kuriem tas tiešām ir nepieciešams.

Pirms šo rādītāju apvienošanas reproducējamos etalonos (benchmarks), apskatīsim būtiskākos no tiem.

Nozīmes salīdzināšana, nevis vārdu

Tekstu salīdzināšana raksts pa rakstam kļūst nelietojama, tiklīdz formulējums ir brīvs. Semantiskā līdzība šo problēmu apej: katrs teksts, izmantojot iegulšanas (embedding) modeli, tiek pārvērsts vektorā, un mēs mērām leņķi starp abiem vektoriem. Divi teikumi, kas saka to pašu dažādiem vārdiem, norāda vienā virzienā.

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+

Piemērs ir pamācošs: divi teikumi bez kopīgiem vārdiem saņem vērtējumu virs 0,85. Šī ir metodes stiprā puse, bet arī tās slazds. Semantiskā līdzība ignorē noliegumu un pakāpes nianses – „maksājums tika akceptēts” un „maksājums tika noraidīts” vektoru telpā izskatās ļoti līdzīgi. Tāpēc nekad neizmanto to vienu pašu, lai validētu atbildi, kur svarīga faktiska precizitāte.

Kad jautājums ir „vai atbilde tiešām adresē uzdoto jautājumu”, neviena formula neaizstāj spriedumu. Zemāk esošais atbilstības (relevance) rādītājs šo spriedumu sadala trīs atsevišķos jautājumos: vai atbilde ir tieša? Vai tā paliek fokusā? Vai tā ir pilnīga? Šāda sadalīšana ir labāka par vispārēju vērtējumu, jo tā norāda, kurā virzienā labot uzvedni (prompt) – daudzrunīgs modelis un nepilnīgs modelis prasa pretējas korekcijas.

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

Ņem vērā otrā kritērija apgriezto formulējumu, kur 5 nozīmē „nav neprasītas informācijas”. Tas ļauj saskaitīt trīs vērtējumus vienā virzienā, taču lasot tas ir pretrunā ar intuīciju: kad pievieno savus kritērijus, ievēro šo konvenciju, citādi iegūsi vidējos rādītājus, kas atlalgo trūkumu, kuru vēlējies sodīt.

Pārliecināšanās, ka modelis nehalucinē

Lietotnēs, kas balstītas uz dokumentiem un jautājumu-atbilžu sistēmām, izšķirošais rādītājs nav rakstīšanas kvalitāte, bet gan uzticamība avotam. Kontroles princips ir vienkāršs: pasniedz tiesnesim oriģinālo kontekstu un ģenerēto atbildi, un liec tam klasificēt katru apgalvojumu kā konteksta apstiprinātu, kontekstā neesošu vai tam pretrunīgu. Atšķirība starp pēdējām divām kategorijām ir svarīga, jo apgalvojums, kas vienkārši nav kontekstā, var būt precīzas vispārīgas zināšanas, savukārt apgalvojums, kas ir pretrunā ar avotu, vienmēr ir kļūda.

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

Konteksta saīsināšana līdz 3000 rakstzīmēm ir robeža, par ko tev jāzina: ja avots pārsniedz šo apjomu, patiesi precīzi apgalvojumi tiks uzskatīti par neatbalstītiem vienkārši tāpēc, ka tos pamatojošais fragments tika nogriezts. Garu dokumentu gadījumā sadali tos un vērtē pa sadaļām, nevis pieņem sistemātiskus viltus pozitīvus rezultātus.

Reproducējama etalona (Benchmark) izveide

Etalons nav tikai vēl viens rādītājs: tā ir iestatne, kas iesaldē datu kopu un protokolu, lai divi izpildes cikli būtu salīdzināmi. Tālāk redzamā klase mēra atbilstību, uzticamību (ja pieejams konteksts), latentumu un izmaksas, pēc tam saglabā katru rezultātu ar datumu un uzvednes versijas marķējumu.

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)

Funkcijas compare izvade apzināti izvieto atbilstību un latentumu vienā rindā, jo tieši tā tiek pieņemts lēmums. Modelis, kas iegūst divus simtdaļpunktus atbilstībā, bet dubulto atbildes laiku, interaktīvai lietotnei nav labāka izvēle; tas varētu būt piemērots nakts apstrādei. Tabula nepieņem lēmumu tavā vietā; tā nostāda kompromisu tieši tavu acu priekšā.

Visbeidzot, šajā implementācijā total_cost paliek nulle. Aizpildi to no API atgrieztajiem lietojuma (usage) laukiem: modeļu salīdzinājums, kas izlaiž izmaksas, izlaiž kritēriju, kas izšķirs diskusiju ar tavu finanšu komandu.

Galvenās atziņas

  • Semantiskā līdzība mēra nozīmi, bet paliek akla pret noliegumu
  • Sadali atbilstību atsevišķos kritērijos, nevis izmanto vispārēju vērtējumu
  • Atklāj halucinācijas, konfrontējot atbildi ar avota kontekstu
  • Izveido reproducējamus etalonus, kas vienlaikus mēra kvalitāti, latentumu un izmaksas
  • Apvieno automātiskos rādītājus un LLM-as-Judge, lai iegūtu pilnvērtīgu novērtējumu