Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Võrdle baasmudeliga

Õppetund 11 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Miks on süstemaatiline võrdlus oluline
  2. Määra baasjoon
  3. Genereeri kõrvuti vastused
  4. Lase kolmandal mudelil hinnata
  5. Võrdle kulusid
  6. Võrdle latentsust
  7. Tee otsus tulemuste põhjal
  8. Peamised punktid

Uuendus 2. november 2026 — Häälestamise kättesaadavus. OpenAI iseteeninduslik häälestamine kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, kes seda varem kasutanud pole, enam uusi ülesandeid luua; alates 2. juulist peab olema viimase 60 päeva jooksul kasutatud häälestatud mudelit; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi ülesandeid käivitada. Juba treenitud mudeleid saab kasutada seni, kuni nende baasmudel on kasutuselt kõrvaldatud. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja ärakasutamiseks; uute projektide puhul seada esikohale viibade inseneeria (prompt engineering), RAG ja hindamine.

Miks on süstemaatiline võrdlus oluline

Häälestamisega kaasnevad kulud: andmete ettevalmistamise aeg, treenimiskulud ja hoolduse keerukus. Sa pead tõestama, et sinu häälestatud mudel pakub mõõdetavat paremust võrreldes baasmudeliga, mida on toetatud tugeva viibaga (prompt). Kui erinevus on marginaalne, ei pruugi häälestamine vaeva väärt olla.

Selles harjutuses tekib kiusatus võrrelda oma treenitud mudelit halvasti juhendatud baasmudeliga. See annab küll meelitava, kuid väärtusetu tulemuse: oled võitnud vastast, keda ise nõrgendasid. Ainult aus võrdlus seab sinu häälestatud mudeli vastamisi baasmudeli parima võimaliku kasutamisviisiga.

Määra baasjoon

Baasjooneks on baasmudel koos sinu parima süsteemiviibaga. Optimeeri see viip enne võrdlemist. Konkreetsemalt tähendab see, et kirjutad üles reeglid, mida häälestamise käigus näidete abil implitsiitselt õpetasid: roll, toon, oodatav pikkus ja viis, kuidas vestlus lõpetada. Allpool olev viip teeb seda täpselt tugiteenuse assistendi jaoks; pane tähele, et häälestatud mudel selliseid juhiseid ei vaja, kuna need reeglid on nüüd osa tema kaaludest.

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

Genereeri kõrvuti vastused

Järgmine samm on pärida mõlemalt mudelilt täpselt samadele küsimustele ja säilitada paarikaupa vastused. Vali küsimused, mis esindavad sinu tegelikku liiklust, mitte õpikunäiteid: kaebus kohaletoimetamise kohta, protseduuri päring, rahulolematus, tagasimakse taotlus, faktiline küsimus. Need viis kategooriat teevad tootmises vahet, mitte täiuslik sõnastus.

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
)

Lase kolmandal mudelil hinnata

Sada paari käsitsi lugemine muutub kiiresti heidutavaks ja hinnangud moonduvad väsimuse tõttu. Kolmas mudel, mis kumbagi vastust ei loonud, arbitreerib iga paari nelja kriteeriumi alusel ja teeb üldise otsuse. Esiteks neutraliseeri sildid: hindaja näeb „Vastus A“ ja „Vastus B“, mitte kunagi seda, kumb mudel need lõi, vastasel juhul kaalub tema otsus mudeli nime sama palju kui teksti. Seejärel lahenda juhtumid, kus väljundit ei saa parsida; vastasel juhul peatab üksainus vigane vastus kogu kampaania.

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]

Nüüd koonda need otsused üheks näitajaks. Paremusmäär – osakaal paaridest, kus häälestatud mudel võidab – asetatakse eelnevalt määratletud lävenditega võrdlusesse: üle 60% on kasv selge; 40% ja 60% vahel kaalu kasu lisakulude vastu; sellest allpool pole sinu häälestus ennast tõestanud ja probleem peitub peaaegu alati andmetes.

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)

Võrdle kulusid

Kvaliteet on vaid pool otsust. Häälestamine vähendab sageli sisendtokeneid, kuna pikk viip muutub tarbetuks, kuid iga häälestatud mudelil arvestatud token maksab rohkem. Need kaks efekti tõmbavad vastassuundades ja ainult arvutus otsustab. Allpool olev funktsioon seab need üksteise vastu kuu liikluse lõikes: viiba lühenemine 500-lt 50 tokenile kompenseerib enam kui kahekordistunud sisendhinda, kuid see ei kehti juba lühikese baasviiba puhul.

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
)

Võrdle latentsust

Viiba lühendamine mitme saja tokeni võrra mõjutab ka vastamisaega, mida kasutajad märkavad kaua enne tooni peenust. Mõõda latentsust samadel küsimustel, mida kasutasid kvalitatiivses võrdluses, väljaspool tipptunde, ja korda mõõtmist mitu korda: üksik väärtus peegeldab enamasti võrgu olekut testi hetkel.

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

Tee otsus tulemuste põhjal

Nüüd vii omavahel kokku kvaliteet ja kulud. Iga kombinatsioon nõuab erinevat otsust ja kõige ebamugavam on kesktee: kui kaks mudelit on võrdsed, pead loobuma juba tasutud tööst, selle asemel et otsida tagantjärele õigustust.

TulemusTegevus
Häälestatud mudel võidab kvaliteedis + kuludesVõta kasutusele häälestatud mudel
Häälestatud mudel võidab kvaliteedis, kaotab kuludesHinda, kas kvaliteet õigustab lisakulu
Sarnased tulemusedJää baasmudeli + viiba juurde
Baasmudel võidabParanda oma andmeid ja proovi uuesti

Peamised punktid

  • Võrdle alati baasmudeli + optimeeritud viibaga, mitte lihtsa viibaga
  • Kasuta LLM-hindamist kvalitatiivse võrdluse automatiseerimiseks
  • Mõõda kulusid ja latentsust, mitte ainult kvaliteeti
  • Paremusmäär üle 60% õigustab häälestamist
  • Kui häälestus ei paku selget paremust, jää viibade inseneeria juurde