Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Salīdzināšana ar bāzes modeli

Nodarbība 11 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Kāpēc sistemātiska salīdzināšana ir svarīga
  2. Definējiet bāzes līniju
  3. Ģenerējiet atbildes blakus blakus
  4. Ļaujiet trešajam modelim spriest
  5. Salīdziniet izmaksas
  6. Salīdziniet latentumu
  7. Pieņemiet lēmumu, balstoties uz rezultātiem
  8. Galvenās atziņas

Atjauninājums: 2026. gada 2. novembris — Fine-tuning pieejamība. OpenAI pašapkalpošanās fine-tuning pakalpojums tiek pakāpeniski izslēgts: kopš 2026. gada 7. maija organizācijas, kas to nekad nav izmantojušas, vairs nevar izveidot uzdevumus; kopš 2. jūlija jums ir jābūt izmantojušam fine-tuned modeli pēdējo 60 dienu laikā; un sākot ar 2027. gada 6. janvāri, neviens klients vairs nevarēs uzsākt jaunus uzdevumus. Jau apmācītie modeļi paliek lietojami, līdz tiek izslēgts to bāzes modelis. Šis kurss joprojām ir noderīgs, lai izprastu un izmantotu esošo modeli; jauniem projektiem dodiet priekšroku promptu inženierijai, RAG un evaluācijām.

Kāpēc sistemātiska salīdzināšana ir svarīga

Fine-tuning rada izmaksas: datu sagatavošanas laiku, apmācības izdevumus un uzturēšanas sarežģītību. Jums ir jāpierāda, ka jūsu fine-tuned modelis nodrošina izmērāmu uzlabojumu salīdzinājumā ar bāzes modeli, izmantojot spēcīgu promptu. Ja atšķirība ir niecīga, fine-tuning var nebūt tā vērts.

Šajā uzdevumā rodas kārdinājums salīdzināt savu apmācīto modeli ar slikti instruētu bāzes modeli. Tas rada glaimojošu, bet bezvērtīgu demonstrējumu: jūs esat uzvarējis pretinieku, kuru pats esat vājinājis. Vienīgais godīgais salīdzinājums nostata jūsu fine-tuned modeli pret bāzes modeļa labāko iespējamo izmantošanu.

Definējiet bāzes līniju

Bāzes līnija ir bāzes modelis ar jūsu labāko sistēmas promptu. Optimizējiet šo promptu pirms salīdzināšanas. Konkrēti tas nozīmē pierakstīt noteikumus, kurus netieši iemācījāt ar piemēriem fine-tuning laikā: lomu, toni, paredzamo garumu un veidu, kā noslēgt sarunu. Zemāk esošais prompts dara tieši to atbalsta asistenta gadījumā; ņemiet vērā, ka fine-tuned modelis šādas instrukcijas neprasa, jo šie noteikumi tagad ir iekļauti tā svaros.

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

Ģenerējiet atbildes blakus blakus

Nākamais solis ir apjautāt abus modeļus par tieši tiem pašiem jautājumiem un saglabāt pāra atbildes. Izvēlieties jautājumus, kas ir reprezentatīvi jūsu reālajai satiksmei, nevis mācību grāmatu gadījumus: sūdzība par piegādi, procedūras pieprasījums, neapmierinātība, atmaksas pieprasījums, faktisks jautājums. Tieši šīs piecas kategorijas rada atšķirību ražošanas vidē, nevis ideāla formulējuma prasme.

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
)

Ļaujiet trešajam modelim spriest

Simtu pāru lasīšana ar roku ātri kļūst atturoša, un spriedums pasliktinās, iestājoties nogurumam. Trešais modelis, kas nav ģenerējis nevienu no atbildēm, arbitrē katru pāri pēc četriem kritērijiem un pasludina globālu spriedumu. Vispirms neitralizējiet etiķetes: tiesnesis redz „Atbilde A” un „Atbilde B”, nekad to, kurš modelis tās ģenerējis, pretējā gadījumā tā spriedums svērs modeļa nosaukumu tikpat daudz kā tekstu. Tālāk apstrādājiet gadījumus, kad izeja nav parsējama; pretējā gadījumā viena kļūdaina atbilde apturēs visu kampaņu.

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]

Tagad apkopojiet šos spriedumus vienā skaitlī. Uzlabojuma rādītājs — to pāru daļa, kur uzvar fine-tuned modelis — tiek vērtēts pret iepriekš definētiem sliekšņiem: virs 60% ieguvums ir skaidrs; starp 40% un 60% svarojiet ieguvumu pret papildu izmaksām; zem tā jūsu fine-tuning nav sevi pierādījis, un problēma gandrīz vienmēr slēpjas datos.

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)

Salīdziniet izmaksas

Kvalitāte ir tikai puse no lēmuma. Fine-tuning bieži samazina ievades tokenus, jo garais prompts kļūst nevajadzīgs, taču katrs tokens, kas tiek norēķināts fine-tuned modelim, maksā vairāk. Šie divi efekti velk pretējos virzienos, un tikai aprēķins izšķir situāciju. Zemāk esošā funkcija nostata tos vienu pret otru mēneša satiksmes griezumā: prompta saīsināšana no 500 uz 50 tokeniem vairāk nekā kompensē dubultotu ievades tarifu, taču tas nebūtu spēkā ar jau īsu bāzes promptu.

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
)

Salīdziniet latentumu

Prompta saīsināšana par vairākiem simtiem tokeniem ietekmē arī atbildes laiku — kritēriju, ko jūsu lietotāji pamana krietni ātrāk nekā tonālās nianses. Mēriet latentumu tajos pašos jautājumos, ko izmantojāt kvalitatīvajai salīdzināšanai, ārpus noslodzes stundām, un atkārtojiet mērījumu vairākas reizes: viena vērtība galvenokārt atspoguļo tīkla stāvokli testa brīdī.

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

Pieņemiet lēmumu, balstoties uz rezultātiem

Tagad savstarpēji sasaistiet kvalitāti un izmaksas. Katra kombinācija prasa atšķirīgu lēmumu, un visneērtākā paliek vidusceļš: kad abi modeļi ir līdzvērtīgi, jums ir jāatsakās no jau apmaksāta darba, nevis jāmeklē pēcfaktuma attaisnojumi.

RezultātsDarbība
FT uzvar kvalitātē + izmaksāsIzvietojiet fine-tuned modeli
FT uzvar kvalitātē, zaudē izmaksāsIzvērtējiet, vai kvalitāte attaisno papildu izmaksas
Līdzīgi rezultātiPalieciet pie bāzes modeļa + prompta
Bāze uzvarUzlabojiet savus datus un mēģiniet vēlreiz

Galvenās atziņas

  • Vienmēr salīdziniet ar bāzes modeli + optimizētu promptu, nevis ar pamata promptu
  • Izmantojiet LLM spriedumu, lai automatizētu kvalitatīvo salīdzināšanu
  • Mēriet izmaksas un latentumu, ne tikai kvalitāti
  • Uzlabojuma rādītājs 60%+ attaisno fine-tuning
  • Ja fine-tuning nenodrošina skaidru uzlabojumu, palieciet pie promptu inženierijas