Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Mätetal och referensvärden

Lektion 17 av 20 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Att mäta kvalitet med mätetal
  2. Att jämföra betydelse snarare än ord
  3. Att verifiera att modellen inte hallucinerar
  4. Att sätta ihop ett reproducerbart referensvärde
  5. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI-dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (API Responses) eller reasoning_effort="none" (Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.

Att mäta kvalitet med mätetal

Utöver poäng från LLM-as-Judge finns det kvantitativa mätetal för att utvärdera olika aspekter av LLM:s svar. Deras värde ligger inte i att de är mer exakta – en väl konstruerad LLM-domare ser saker som ingen formel någonsin kommer att se – utan i att de är stabila och billiga. Cosinuslikhet returnerar exakt samma tal vid varje körning, kostar nästan ingenting och kan därför köras på tusentals fall vid varje commit. Du sparar sedan LLM-domaren för dimensioner som verkligen kräver det.

Vi går igenom de viktigaste mätetalen innan vi sätter ihop dem till reproducerbara referensvärden (benchmarks).

Att jämföra betydelse snarare än ord

Att jämföra två texter tecken för tecken blir oanvändbart så snart formuleringen är fri. Semantisk likhet kringgår detta problem: varje text omvandlas till en vektor av en inbäddningsmodell (embedding model), och vi mäter vinkeln mellan de två vektorerna. Två meningar som säger samma sak med olika ord pekar i samma riktning.

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+

Exemplet är lärorikt: två meningar utan gemensamma ord får ett betyg över 0,85. Detta är metodens styrka, men också dess fälla. Semantisk likhet ignorerar nekningar och nyanser av grad – “betalningen accepterades” och “betalningen nekades” ser mycket lika ut vektormässigt. Använd därför aldrig detta ensamt för att validera ett svar där faktisk noggrannhet är avgörande.

När frågan är “besvarar svaret faktiskt den ställda frågan” kan ingen formel ersätta omdöme. Relevanspoängen nedan bryter ner detta omdöme i tre distinkta frågor: Är svaret direkt? Håller det sig fokuserat? Är det komplett? Denna uppdelning är bättre än ett globalt betyg eftersom den talar om för dig i vilken riktning du ska korrigera prompten – en verbose modell och en ofullständig modell kräver motsatta korrigeringar.

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

Notera den omvända formuleringen av det andra kriteriet, där 5 betyder “ingen obegärd information”. Detta gör det möjligt att addera de tre poängen i samma riktning, men det är kontraintuitivt att läsa: när du lägger till dina egna kriterier, behåll denna konvention eller så får du medelvärden som belönar den brist du avsåg att bestraffa.

Att verifiera att modellen inte hallucinerar

I en dokumentbaserad frågesvarsapplikation är det avgörande mätetalet inte skrivkvalitet utan trohet mot källan. Kontrollprincipen är enkel: presentera domaren för den ursprungliga kontexten och det genererade svaret, och be den klassificera varje påstående som stöttat av kontexten, frånvarande i kontexten eller motsägande kontexten. Skillnaden mellan dessa två sista kategorier är viktig, eftersom ett påstående som bara är frånvarande kan vara korrekt allmän kunskap, medan ett påstående som motsäger källan alltid är ett fel.

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

Att trunkera kontexten till 3 000 tecken är en gräns du måste vara medveten om: om källan överstiger denna storlek kommer perfekt korrekta påståenden att räknas som icke-stöttade helt enkelt eftersom passagen som rättfärdigar dem kapades bort. För långa dokument bör du dela upp och utvärdera per sektion snarare än att acceptera systematiska falska positiva utfall.

Att sätta ihop ett reproducerbart referensvärde

Ett referensvärde (benchmark) är inte bara ett annat mätetal: det är en uppställning som fryser en datamängd och ett protokoll så att två körningar är jämförbara. Klassen nedan mäter relevans, trohet (när kontext finns tillgänglig), latens och kostnad, och behåller sedan varje resultat daterat och märkt med promptversion.

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)

Utmatningen från compare placerar avsiktligt relevans och latens på samma rad, eftersom det är så beslutet faktiskt fattas. En modell som vinner två hundradelar i relevans men fördubblar svarstiden är inte ett bättre val för en interaktiv applikation; det kan det vara för nattlig bearbetning. Tabellen bestämmer inte åt dig; den placerar avvägningen rätt framför dina ögon.

Slutligen förblir total_cost noll i denna implementation. Fyll i den från användningsfälten som returneras av API:t: en modelljämförelse som utelämnar kostnad lämnar ute det kriterium som kommer att avgöra diskussionen med ditt ekonomiteam.

Viktiga punkter

  • Semantisk likhet mäter betydelse men förblir blind för nekningar
  • Dela upp relevans i distinkta kriterier snarare än ett globalt betyg
  • Upptäck hallucinationer genom att konfrontera svaret med källkontexten
  • Skapa reproducerbara referensvärden som mäter kvalitet, latens och kostnad tillsammans
  • Kombinera automatiska mätetal och LLM-as-Judge för en komplett utvärdering