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

Utvärdering av prompts automatiskt

Lektion 16 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Utvärdering av prompts automatiskt
  2. Typer av utvärdering
  3. Komplett utvärderingspipeline
  4. Testsvit: Format
  5. CI/CD-integration
  6. Utvärderingsdashboard
  7. Sätt upp dina skyddsräcken
  8. Viktiga punkter
  9. Testa dina kunskaper

Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete (reasoning effort) 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"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.

Utvärdering av prompts automatiskt

Automatisk utvärdering är hörnstenen i en mogen pipeline för prompt-teknik. Den låter dig upptäcka regressioner, jämföra modeller och validera ändringar innan driftsättning. Utan den är varje ändring av en prompt ett blindt spel.

Typer av utvärdering

Tre familjer av utvärderare delar på arbetet beroende på typen av förväntat svar, och du kommer nästan alltid att kombinera flera av dem.

Exakt matchning (Exact Match)

För uppgifter med ett enda förväntat svar räcker en direkt jämförelse. eval_exact_match normaliserar skiftläge och blanktecken innan jämförelsen: utan denna försiktighetsåtgärd skulle “Bug” och “bug” räknas som ett fel, vilket får dig att fixa ett problem som inte finns.

eval_set_match hanterar fall där svaret är en mängd – entiteter som hittats i ett dokument, kategorier tilldelade en artikel. Den härleder precision och recall, två siffror som berättar olika historier: hög precision med lågt recall signalerar en alltför försiktig modell som bara extraherar det den är säker på; det omvända avslöjar en modell som hallucinerar för att fylla luckor. F1 sammanfattar dem bekvämt men ersätter dem inte vid diagnos.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Exakt matchning efter normalisering."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Mängdmatchning (entiteter, kategorier)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Semantisk utvärdering (Inbäddning)

För textsvar där formuleringen kan variera blir exakt matchning absurd: “Din order levereras imorgon” och “Leverans är schemalagd för imorgon” säger samma sak men skulle ändå få poängen noll. Cosinuslikhet mellan inbäddningar mäter semantisk närhet snarare än teckenmatchning och returnerar en kontinuerlig poäng.

Du ställer in tröskeln över vilken ett svar anses acceptabelt. Kalibrera den på några dussin par som du manuellt klassificerat som “ekvivalenta” eller “olika”, och välj sedan det värde som bäst skiljer de två grupperna åt: en tröskel vald på magkänsla ger resultat lika godtyckliga som ingen mätning alls, med den extra illusionen av noggrannhet.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Cosinuslikhet mellan inbäddningar."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

LLM-utvärdering (LLM-as-Judge)

Modellen utvärderar kvaliteten på ett svar. Detta är det enda genomförbara tillvägagångssättet när ingen referens finns: ingen kommer att skriva för hand det “korrekta” supportsvaret för tvåhundra ärenden.

Det som gör en domare användbar kokar ner till några få saker. Först, modellen som används: du väljer en mer kapabel modell som domare, här gpt-5.6-sol, eftersom en domare på samma nivå som den som utvärderas tenderar att validera sina egna brister. För det andra, kravet på motivering: att motivera varje poäng stabiliserar omdömet och låter dig upptäcka en utvärderare som använder fel kriterium – en motivering som diskuterar längd när kriteriet var tydlighet är en varningssignal. Slutligen säkerställer temperature på 0.1 poängstabilitet över körningar.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Utvärdering av en domarmodell."""
    criteria_text = "\n".join(
        f"- {c}: poäng från 1 till 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Mer kapabel modell som domare
        reasoning={"effort": "none"},  # temperature kräver effort none
        instructions="Du är en expert, opartisk utvärderare.",
        input=f"""Utvärdera detta svar enligt följande kriterier:

Ställd fråga: {question}

Svar att utvärdera: {prediction}

Kriterier:
{criteria_text}

Ge för varje kriterium en poäng från 1 till 5 med motivering.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Komplett utvärderingspipeline

EvalPipeline sätter ihop dessa byggstenar: den läser in en testsvit, kör prompten på varje fall, tillämpar alla angivna utvärderare och aggregerar poängen. Utvärderare skickas som en lista med funktioner, alla anropade med samma signatur; att lägga till en metrik kräver därför ingen ändring av pipelinen, och du kan köra exakt matchning, semantisk likhet och en domare på samma exekvering utan att betala för generering tre gånger.

Metoden summary ackumulerar också förbrukade tokens. Denna vid första anblicken sekundära rad skyddar dig från en vanlig fälla: en promptversion som vinner två poäng men tredubblar kostnaden är inte nödvändigtvis rätt val, och det är bättre att lära sig det vid tidpunkten för avvägning än när månadsfakturan kommer.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Ett testfall för utvärdering."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automatisk utvärderingspipeline."""

    def __init__(self, test_suite_path: str):
        """Läser in testsviten från en JSON-fil."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Kör alla tester och utvärderar resultaten."""
        self.results = []

        for tc in self.test_cases:
            # Generera svar
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature kräver effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Utvärdera med varje utvärderare
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Sammanfattar utvärderingsresultaten."""
        if not self.results:
            return {"error": "Inga resultat"}

        # Aggregera poäng per utvärderare
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Testsvit: Format

Formatet för testsviten är avsiktligt minimalistiskt: en inmatning, det förväntade svaret och fritt formaterad metadata. Denna metadata är mer användbar än den verkar – genom att tagga varje fall efter kategori kan du bryta ner poängen och upptäcka att din klassificerare inte misslyckas slumpmässigt utan på en specifik familj av förfrågningar, vilket ett globalt genomsnitt på 88 % inte avslöjar. De tre exemplen nedan visar också vad en bra svit bör innehålla: tydliga fall, som en krasch vid start, men också fall som gränsar till en annan kategori – en fråga om en saknad funktion liknar mycket en felrapport, och det är på denna gräns som en klassificerares kvalitet avgörs.

[
    {
        "input_text": "Mitt paket har inte kommit fram",
        "expected_output": "klagomål",
        "metadata": {"category": "leverans"}
    },
    {
        "input_text": "Hur aktiverar jag mörkt läge?",
        "expected_output": "fråga",
        "metadata": {"category": "funktion"}
    },
    {
        "input_text": "Appen kraschar vid start på iOS 18",
        "expected_output": "fel",
        "metadata": {"category": "tekniskt"}
    }
]

CI/CD-integration

Kör utvärdering vid varje ändring av prompten. Funktionen ci_eval_check gör mätningen till ett skyddsräcke: den kör pipelinen, jämför medelpoängen med en tröskel och returnerar ett booleskt värde som din integrationskedja tolkar som en lyckad eller misslyckad byggnation. En ändring som sänker precisionen under 85 % når inte längre produktion, precis som ett trasigt enhetstest blockerar en sammanslagning.

Ställ in tröskeln baserat på den poäng som redan uppnåtts av den nuvarande versionen, inte från ett ideal. Sätt den för högt och du dömer teamet till att kringgå verifieringen med tillfälliga inaktiveringar som blir permanenta; sätt den för lågt och du kontrollerar ingenting samtidigt som du visar upp ett grönt märke. Ha slutligen i åtanke att sviten måste förbli representativ för verklig trafik: en tröskel som uppnås på tjugo fall skrivna för två år sedan bevisar ingenting om dagens förfrågningar.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD-grind: kontrollerar att prompten uppfyller minimipoängen."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Medelpoäng: {avg_score:.2%}")
    print(f"Minimitröskel: {min_score:.2%}")

    if avg_score < min_score:
        print("MISSLYCKANDE: poäng under tröskeln")
        return False

    print("LYCKAT: prompt validerad")
    return True

Utvärderingsdashboard

Spåra poängutvecklingen över tid. En ensam poäng säger ingenting; serien berättar din prompts historia och svarar på frågan som alltid dyker upp på möten: gör vi framsteg? Funktionen nedan producerar en Markdown-tabell som ställer sida vid sida, för varje version, medelpoäng, förbrukade tokens och uppskattad kostnad. Formatet är inte slumpmässigt: det klistras direkt in i en pull request, vilket gör jämförelsen läsbar för personer som aldrig kommer att öppna din kod.

def comparison_report(results: dict[str, dict]) -> str:
    """Genererar en jämförande rapport mellan promptversioner."""
    report = "# Jämförande utvärderingsrapport\n\n"
    report += "| Version | Medelpoäng | Genomsnittliga tokens | Kostnad |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Sätt upp dina skyddsräcken

Bygg en svit på tjugo testfall för en riktig prompt, och placera ut en handfull kantfall snarare än tjugo bekväma exempel: en svit som klarar 100 % vid första försöket lär dig ingenting. Implementera de tre utvärderartyperna och kör dem tillsammans på två versioner av din prompt. Exakt matchning ger en ren siffra, semantisk likhet fångar legitima omformuleringar, och domaren belyser fall där de två första är oense – dessa oenigheter är rikast på lärdomar om vad du faktiskt förväntar dig av modellen.

Jämför, identifiera den vinnande versionen och sätt sedan upp CI-skriptet som blockerar driftsättning om poängen sjunker. Du vet att systemet fungerar den dag det avvisar en ändring som du trodde var självklar.

Viktiga punkter

  • Automatiserad utvärdering är avgörande för att iterera med förtroende
  • Kombinera utvärdering med exakt matchning, semantisk analys och LLM-as-judge efter behov
  • Underhåll en testsvit som utvecklas tillsammans med din applikation
  • Integrera utvärdering i din CI/CD med en minimitröskel
  • Använd en mer kapabel modell som domare för att utvärdera en billigare modell
  • Dokumentera varje versions poäng för att spåra utvecklingen

Testa dina kunskaper

Avancerade tekniker och industrialisering: den slutgiltiga kontrollen.

1. Vad innehåller en effektiv systemprompt?

Svar: Roll, omfattning, beteenderegler, utdataformat och hantering av kantfall – skrivet som en specifikation, testat som kod.

2. När bör du använda självkonsistens (self-consistency)?

Svar: På resonemangsproblem med verifierbara svar: generera flera oberoende resonemang och behåll majoritetssvaret – varians blir en allierad.

3. Vad garanterar JSON-läge med schema-tvång?

Svar: Utdata som strikt följer schemat (typer, obligatoriska fält, enumerationer) – validerat på API-sidan och omvaliderat i kod (JSON Schema, Zod) för en kedja fri från överraskningar.

4. Vad är grounding?

Svar: Att förankra svar i tillhandahållna fakta (dokument, hämtad data) snarare än modellens minne – med kravet att citera eller avstå från externa källor.

5. Vad är syftet med en versionerad promptkatalog?

Svar: Att behandla prompts som artefakter: versioner, A/B-tester, automatiserade utvärderingar vid varje ändring – du vet vad som körs i produktion och varför.

Den sista loopen i kursen – versionera, testa, utvärdera automatiskt – transformerar hantverksmässig prompt-teknik till en teampraxis.