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

Jämför med basmodellen

Lektion 11 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Varför systematisk jämförelse är avgörande
  2. Definiera baslinjen
  3. Generera sidosvidda svar
  4. Låt en tredjepartsmodell bedöma
  5. Jämför kostnader
  6. Jämför latens
  7. Besluta baserat på resultaten
  8. Viktiga punkter

Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: från och med den 7 maj 2026 kan organisationer som aldrig har använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med den 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.

Varför systematisk jämförelse är avgörande

Finjustering har en kostnad: tid för dataförberedelse, träningskostnader och underhållskomplexitet. Du måste bevisa att din finjusterade modell levererar en mätbar förbättring jämfört med basmodellen med en stark prompt. Om skillnaden är marginell kanske finjustering inte är värt besväret.

Frestanden i denna övning är att jämföra din tränade modell mot en dåligt instruerad basmodell. Det ger en smickrande men värdelös demonstration: du har besegrat en motståndare som du själv försvagat. Den enda ärliga jämförelsen ställer din finjusterade modell mot den bästa möjliga användningen av basmodellen.

Definiera baslinjen

Baslinjen är basmodellen med din bästa systemprompt. Optimera denna prompt innan du jämför. Konkret innebär det att du skriver ner de regler du implicit lärde ut genom exempel under finjusteringen: roll, ton, förväntad längd och hur en interaktion ska avslutas. Prompten nedan gör exakt detta för en supportassistent; notera att den finjusterade modellen inte behöver sådana instruktioner, eftersom dessa regler nu är en del av dess vikter.

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

Generera sidosvidda svar

Nästa steg är att fråga båda modellerna exakt samma frågor och spara de parade svaren. Välj frågor som är representativa för din verkliga trafik snarare än läroboksexempel: ett klagomål om leverans, en begäran om procedur, missnöje, en återbetalningsbegäran, en faktuell fråga. Dessa fem familjer gör skillnad i produktion, inte 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
)

Låt en tredjepartsmodell bedöma

Att läsa hundra par för hand blir snabbt avskräckande, och omdömet sviktar när tröttheten sätter in. En tredjepartsmodell, som inte producerat något av svaren, skiljer varje par åt baserat på fyra kriterier och avkunnar en global dom. Först, neutralisera etiketterna: domaren ser “Svar A” och “Svar B”, aldrig vilken modell som producerade dem, annars kommer dess dom att väga in modellnamnet lika mycket som texten. Härnäst, hantera fall där utdata inte går att tolka; annars stoppar ett enda felaktigt svar hela kampanjen.

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]

Sammanfatta nu dessa domar till en enda siffra. Förbättringstakten – andelen par där den finjusterade modellen vinner – läses mot fördefinierade tröskelvärden: över 60 % är vinsten tydlig; mellan 40 % och 60 % väger du vinsten mot den extra kostnaden; under det har din finjustering inte bevisat sitt värde, och problemet ligger nästan alltid i datan.

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)

Jämför kostnader

Kvalitet är bara halva beslutet. Finjustering minskar ofta antalet input-tokens eftersom den långa prompten blir onödig, men varje token som debiteras på en finjusterad modell kostar mer. Dessa två effekter drar åt motsatta håll, och bara beräkningen avgör. Funktionen nedan ställer dem mot varandra över en månads trafik: en prompt som sjunker från 500 till 50 tokens uppväger mer än väl en fördubblad input-taxa, men det skulle inte gälla med en redan kort basprompt.

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
)

Jämför latens

Att korta ner en prompt med flera hundra tokens påverkar också svarstiden, ett kriterium som dina användare märker långt innan tonal finess. Mät latens på samma frågor som användes för den kvalitativa jämförelsen, utanför rusningstid, och upprepa mätningen flera gånger: ett enskilt värde speglar mest nätverksstatus vid testtillfället.

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

Besluta baserat på resultaten

Korsreferera nu kvalitet och kostnad. Varje kombination kräver ett annat beslut, och det mest obekväma återstår medelvägen: när de två modellerna är lika bra måste du överge arbete som redan är betalt snarare än att söka rättfärdigande i efterhand.

ResultatÅtgärd
FT vinner på kvalitet + kostnadDistribuera den finjusterade modellen
FT vinner på kvalitet, förlorar på kostnadUtvärdera om kvaliteten motiverar extrakostnaden
Liknande resultatStanna vid basmodell + prompt
Basen vinnerFörbättra din data och försök igen

Viktiga punkter

  • Jämför alltid mot en basmodell + optimerad prompt, inte en grundläggande prompt
  • Använd LLM-bedömning för att automatisera kvalitativ jämförelse
  • Mät kostnader och latens, inte bara kvalitet
  • En förbättringstakt på 60 %+ motiverar finjustering
  • Om finjustering inte ger en tydlig förbättring, håll dig till prompt engineering