Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Sammenlign med basismodellen

Lektion 11 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Hvorfor systematisk sammenligning er vigtig
  2. Definer baseline
  3. Generer svar side om side
  4. Lad en tredjepartsmodel dømme
  5. Sammenlign omkostninger
  6. Sammenlign latens
  7. Beslut baseret på resultater
  8. Vigtige pointer

Opdatering 2. november 2026 — Tilgængelighed af fine-tuning. OpenAIs selvbetjente fine-tuning udfases: Fra den 7. maj 2026 kan organisationer, der aldrig har brugt tjenesten, ikke længere oprette jobs; siden den 2. juli skal du have brugt en fine-tunet model inden for de sidste 60 dage; og fra den 6. januar 2027 vil ingen kunde kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel udgår. Dette kursus er stadig nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.

Hvorfor systematisk sammenligning er vigtig

Fine-tuning har en omkostning: tid til dataforberedelse, træningsudgifter og kompleksitet i vedligeholdelsen. Du skal bevise, at din fine-tunede model leverer en målbar forbedring i forhold til basismodellen med en stærk prompt. Hvis forskellen er marginal, er fine-tuning måske ikke besværet værd.

Fristelsen i denne øvelse er at sammenligne din trænede model med en dårligt instrueret basismodel. Det giver en smigrende, men værdiløs demonstration: Du har besejret en modstander, du selv har svækket. Den eneste ærlige sammenligning sætter din fine-tunede model op imod den bedst mulige brug af basismodellen.

Definer baseline

Baselinen er basismodellen med din bedste system-prompt. Optimer denne prompt, før du sammenligner. Konkret betyder det, at du nedskriver de regler, du implicit har lært modellen ved hjælp af eksempler under fine-tuning: rollen, tonen, den forventede længde og hvordan en udveksling skal afsluttes. Prompts nedenfor gør netop dette for en supportassistent; bemærk, at den fine-tunede model ikke har brug for sådanne instrukser, da disse regler nu er en del af dens vægte.

from openai import OpenAI

client = OpenAI()

OPTIMIZED_SYSTEM_PROMPT = """You are a customer support assistant for TechCorp.
Rules:
- Respond professionally and empathetically
- Always propose a concrete solution
- Limit responses to 3 sentences maximum
- End with a follow-up question"""

def baseline_response(question: str) -> str:
    """Gets a response from the base model."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions=OPTIMIZED_SYSTEM_PROMPT,
        input=question
    )
    return response.output_text

def fine_tune_response(question: str, model_ft: str) -> str:
    """Gets a response from the fine-tuned model."""
    response = client.responses.create(
        model=model_ft,
        input=question
    )
    return response.output_text

Generer svar side om side

Næste skridt er at spørge begge modeller om præcis de samme spørgsmål og gemme de parrede svar. Vælg spørgsmål, der er repræsentative for din rigtige trafik, frem for lærebogseksempler: en klage over levering, en anmodning om procedure, utilfredshed, en anmodning om refusion, et faktaspørgsmål. Disse fem familier gør forskellen i produktion, ikke perfekt formulering.

import json

def compare_models(
    questions: list[str],
    base_model: str,
    ft_model: str,
    system_prompt: str
) -> list[dict]:
    """Compares responses from two models on the same questions."""
    comparisons = []

    for q in questions:
        # Base model with optimized prompt
        r_base = client.responses.create(
            model=base_model,
            instructions=system_prompt,
            input=q
        )

        # Fine-tuned model (minimal or no prompt)
        r_ft = client.responses.create(
            model=ft_model,
            input=q
        )

        comparisons.append({
            "question": q,
            "baseline_response": r_base.output_text,
            "ft_response": r_ft.output_text
        })

    return comparisons

# Test questions
test_questions = [
    "My package hasn't arrived.",
    "How do I reset my password?",
    "Your product isn't working as expected.",
    "I would like a refund.",
    "What are your opening hours?",
]

results = compare_models(
    test_questions,
    "gpt-5.6-luna",
    "ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
    OPTIMIZED_SYSTEM_PROMPT
)

Lad en tredjepartsmodel dømme

At læse hundrede par i hånden bliver hurtigt demotiverende, og dømmekraften svigter, når trætheden melder sig. En tredjepartsmodel, som ikke har produceret nogen af svarene, arbitrerer hvert par ud fra fire kriterier og afsiger en global dom. Først skal du neutralisere labels: dommeren ser „Svar A” og „Svar B”, aldrig hvilken model der har produceret dem, ellers vil dens dom vægte modelnavnet lige så højt som teksten. Dernæst skal du håndtere tilfælde, hvor outputtet ikke kan parses; ellers vil et enkelt malformed svar standse hele kampagnen.

def judge_comparison(comparison: dict) -> dict:
    """Has a third-party model judge the comparison."""
    prompt = f"""Compare these two responses to the same question.

Question: {comparison['question']}

Response A: {comparison['baseline_response']}

Response B: {comparison['ft_response']}

For each criterion, indicate which response is better (A, B, or tie):
1. Relevance of the response
2. Professionalism of tone
3. Adherence to expected format
4. Usefulness to the user

Respond in JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=prompt
    )

    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"error": "Response not parseable"}

# Judge all comparisons
judgments = [judge_comparison(c) for c in results]

Aggreger nu disse domme til ét enkelt tal. Forbedringsraten – andelen af par, hvor den fine-tunede model vinder – læses op imod definerede tærskler: Over 60 % er gevinsten klar; mellem 40 % og 60 % skal du veje gevinsten op imod de ekstra omkostninger; under det har din fine-tuning ikke bevist sig selv, og problemet ligger næsten altid i dataene.

def comparison_score(judgments: list[dict]) -> dict:
    """Calculates the overall comparison score."""
    scores = {"A_wins": 0, "B_wins": 0, "tie": 0}

    for j in judgments:
        winner = j.get("overall_winner", "tie")
        if winner == "A":
            scores["A_wins"] += 1
        elif winner == "B":
            scores["B_wins"] += 1
        else:
            scores["tie"] += 1

    total = len(judgments)
    print(f"Base model wins: {scores['A_wins']}/{total}")
    print(f"Fine-tuned model wins: {scores['B_wins']}/{total}")
    print(f"Tie: {scores['tie']}/{total}")

    improvement_rate = scores["B_wins"] / total * 100
    print(f"\nImprovement rate: {improvement_rate:.1f}%")

    if improvement_rate >= 60:
        print("Fine-tuning provides a significant improvement.")
    elif improvement_rate >= 40:
        print("Modest improvement—check if the cost is justified.")
    else:
        print("Fine-tuning does not provide a clear improvement.")

    return scores

comparison_score(judgments)

Sammenlign omkostninger

Kvalitet er kun halvdelen af beslutningen. Fine-tuning reducerer ofte input-tokens, da den lange prompt bliver unødvendig, men hvert token, der faktureres på en fine-tunet model, koster mere. Disse to effekter trækker i modsatte retninger, og kun beregningen afgør sagen. Funktionen nedenfor sætter dem op imod hinanden over en måneds trafik: En prompt, der falder fra 500 til 50 tokens, opvejer mere end end en fordoblet input-sats, men det ville ikke holde stik med en i forvejen kort basis-prompt.

def compare_costs(
    requests_per_day: int,
    base_prompt_tokens: int,
    ft_prompt_tokens: int,
    avg_output_tokens: int,
    base_input_price: float,
    ft_input_price: float,
    output_price: float
):
    """Compares monthly costs between base and fine-tuned models."""
    days = 30

    base_cost = days * requests_per_day * (
        base_prompt_tokens * base_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    ft_cost = days * requests_per_day * (
        ft_prompt_tokens * ft_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    savings = base_cost - ft_cost
    print(f"Monthly base cost: ${base_cost:.2f}")
    print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
    print(f"Monthly savings: ${savings:.2f}")

# Example
compare_costs(
    requests_per_day=1000,
    base_prompt_tokens=500,   # long prompt with instructions
    ft_prompt_tokens=50,       # short prompt, behavior is integrated
    avg_output_tokens=200,
    base_input_price=0.15,
    ft_input_price=0.30,        # fine-tuned costs more per token
    output_price=0.60
)

Sammenlign latens

At forkorte en prompt med flere hundrede tokens påvirker også svartiden, et kriterium dine brugere lægger mærke til længe før tonal finesse. Mål latensen på de samme spørgsmål, der blev brugt til den kvalitative sammenligning, uden for spidsbelastningstider, og gentag målingen flere gange: En enkelt værdi afspejler mest af alt netværkstilstanden på testtidspunktet.

import time

def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
    """Measures the average latency of a model."""
    latencies = []
    for q in questions:
        start = time.time()
        kwargs = {"model": model, "input": q}
        if prompt:
            kwargs["instructions"] = prompt
        client.responses.create(**kwargs)
        latencies.append(time.time() - start)

    avg = sum(latencies) / len(latencies)
    print(f"{model} — Average latency: {avg:.2f}s")
    return avg

Beslut baseret på resultater

Krydsreferér nu kvalitet og omkostninger. Hver kombination kræver en anden beslutning, og den mest ubehagelige forbliver mellemvejen: Når de to modeller er lige, skal du opgive arbejde, der allerede er betalt for, frem for at søge retfærdiggørelse efterfølgende.

ResultatHandling
FT vinder på kvalitet + omkostningerImplementer den fine-tunede model
FT vinder på kvalitet, taber på omkostningerVurdér om kvaliteten retfærdiggør de ekstra omkostninger
Lignende resultaterBliv ved basismodel + prompt
Basis vinderForbedr dine data og prøv igen

Vigtige pointer

  • Sammenlign altid med en basismodel + optimeret prompt, ikke en basal prompt
  • Brug LLM-domme til at automatisere kvalitativ sammenligning
  • Mål omkostninger og latens, ikke kun kvalitet
  • En forbedringsrate på 60 %+ retfærdiggør fine-tuning
  • Hvis fine-tuning ikke giver en klar forbedring, så bliv ved prompt engineering