Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Palyginimas su baziniu modeliu

Paskaita 11 iš 16 Atnaujinta 2026 m. lapkričio 2 d. Pažengusiems
Šiame puslapyje
  1. Kodėl sisteminis palyginimas yra svarbus
  2. Apibrėžk pagrindinę liniją (Baseline)
  3. Generuok atsakymus greta
  4. Paverk vertinimą trečiajai šaliai (modeliui)
  5. Palygink išlaidas
  6. Palygink delsą (Latency)
  7. Spręsk pagal rezultatus
  8. Svarbiausi punktai

Atnaujinimas 2026 m. lapkričio 2 d. — Derinimo prieinamumas. „OpenAI“ savitarnos derinimo paslauga yra nutraukiama: nuo 2026 m. gegužės 7 d. organizacijos, kurios ja niekada nesinaudojo, nebegali kurti naujų užduočių; nuo liepos 2 d. būtina būti naudojus derintą modelį per pastaruosius 60 dienų; o nuo 2027 m. sausio 6 d. joks klientas nebegalės paleisti naujų derinimo užduočių. Jau apmokyti modeliai išlieka naudojami tol, kol jų bazinis modelis nėra pašalinamas. Šis kursas išlieka naudingas norint suprasti ir išnaudoti esamą modelį; naujiems projektams teikite pirmenybę promptų inžinerijai, RAG ir vertinimams.

Kodėl sisteminis palyginimas yra svarbus

Derinimas turi kainą: duomenų paruošimo laiką, mokymo išlaidas ir priežiūros sudėtingumą. Turi įrodyti, kad tavo derintas modelis suteikia išmatuojamą pagerėjimą, lyginant su baziniu modeliu, naudojančiu stiprų promptą. Jei skirtumas yra nežymus, derinimas gali būti nevertas pastangų.

Šio pratimo pagunda yra palyginti savo apmokytą modelį su prastai instruktuotu baziniu modeliu. Tai sukuria gražią, bet bevertę demonstraciją: nugalėjai priešininką, kurį pats susilpninai. Vienintelis sąžiningas palyginimas priešpriešina tavo derintą modelį geriausiam įmanomam bazinio modelio naudojimui.

Apibrėžk pagrindinę liniją (Baseline)

Pagrindinė linija yra bazinis modelis su tavo geriausiu sistemos promptu. Prieš lygindamas, optimizuok šį promptą. Konkrečiai tai reiškia užrašyti taisykles, kurias numanomai išmokei pavyzdžiais derinimo metu: vaidmenį, toną, tikėtiną ilgį ir tai, kaip užbaigti dialogą. Toliau pateiktas promptas tai tiksliai ir daro klientų aptarnavimo asistentui; atkreipk dėmesį, kad derintam modeliui tokių instrukcijų nereikia, nes šios taisyklės dabar yra jo svorių dalis.

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

Generuok atsakymus greta

Kitas žingsnis – užklausti abu modelius tais pačiais klausimais ir išsaugoti poruotus atsakymus. Pasirink klausimus, kurie atspindi tavo realų srautą, o ne vadovėlinius atvejus: skundas dėl pristatymo, procedūros užklausa, nepasitenkinimas, grąžinimo prašymas, faktinis klausimas. Būtent šios penkios kategorijos lemia skirtumą gamyboje, o ne tobulas formuluotes.

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
)

Paverk vertinimą trečiajai šaliai (modeliui)

Šimto porų skaitymas rankiniu būdu greitai tampa varginantis, o vertinimo kokybė krenta dėl nuovargio. Trečiosios šalies modelis, kuris nesukūrė nė vieno atsakymo, arbitruoja kiekvieną porą pagal keturis kriterijus ir pateikia bendrą verdiktą. Pirma, neutralizuok etiketes: vertintojas mato „Atsakymas A“ ir „Atsakymas B“, bet niekada nežino, kuris modelis juos sugeneravo, kitaip jo verdiktas svors modelio pavadinimą tiek pat, kiek ir tekstą. Antra, tvarkyk atvejus, kai išvestis nėra analizuojama; kitaip vienas neteisingai suformuotas atsakymas sustabdys visą kampaniją.

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]

Dabar suagreguok šiuos verdiktus į vieną skaičių. Pagerėjimo rodiklis – porų dalis, kurioje laimi derintas modelis – yra vertinamas pagal iš anksto nustatytas ribas: viršijus 60 %, nauda yra akivaizdi; tarp 40 % ir 60 %, pasverk naudą prieš papildomas išlaidas; žemiau šios ribos tavo derinimas neįrodė savo vertės, ir problema beveik visada slypi duomenyse.

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)

Palygink išlaidas

Kokybė yra tik pusė sprendimo. Derinimas dažnai sumažina įvesties tokenų skaičių, nes ilgas promptas tampa nereikalingas, tačiau kiekvienas tokenas, apmokestintas derintame modelyje, kainuoja daugiau. Šie du efektai veikia priešingomis kryptimis, ir tik skaičiavimas lemia rezultatą. Toliau pateikta funkcija juos priešpriešina vieno mėnesio srauto kontekste: prompto sutrumpinimas nuo 500 iki 50 tokenų daugiau nei kompensuoja dvigubai didesnę įvesties kainą, tačiau tai negaliotų, jei bazinis promptas jau būtų trumpas.

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
)

Palygink delsą (Latency)

Prompto sutrumpinimas šimtais tokenų taip pat veikia atsako laiką – kriterijų, kurį tavo vartotojai pastebi gerokai anksčiau nei tonų niuansus. Išmatuok delsą tiems patiems klausimams, naudotiems kokybiniam palyginimui, ne piko valandomis, ir kartok matavimą kelis kartus: viena reikšmė dažniausiai atspindi tik tinklo būklę testavimo metu.

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

Spręsk pagal rezultatus

Dabar sugretink kokybę ir kainą. Kiekvienas derinys reikalauja skirtingo sprendimo, o nepatogiausia lieka vidurio pozicija: kai abu modeliai yra lygiaverčiai, turi atsisakyti jau apmokėto darbo, o ne ieškoti post factum pateisinimų.

RezultatasVeiksmas
Derintas modelis laimi kokybe + kainomisDiegti derintą modelį
Derintas modelis laimi kokybe, pralaimi kainomisĮvertinti, ar kokybė pateisina papildomas išlaidas
Panašūs rezultataiLikti prie bazinio modelio + prompto
Laimi bazinis modelisGerinti duomenis ir bandyti iš naujo

Svarbiausi punktai

  • Visada lygink su baziniu modeliu + optimizuotu promptu, o ne su basic promptu
  • Naudok LLM vertinimą, kad automatizuotum kokybinį palyginimą
  • Matuok išlaidas ir delsą, o ne tik kokybę
  • Didesnis nei 60 % pagerėjimo rodiklis pateisina derinimą
  • Jei derinimas nesuteikia akivaizdaus pagerėjimo, laikykis promptų inžinerijos