Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Vertaile perusmalliin

Oppitunti 11 / 16 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi systemaattinen vertailu on tärkeää
  2. Määritä vertailukohta
  3. Luo rinnakkaisia vastauksia
  4. Pyydä kolmatta mallia tuomitsemaan
  5. Vertaile kustannuksia
  6. Vertaile viivettä
  7. Tee päätös tulosten perusteella
  8. Keskeiset asiat

Päivitys 2. marraskuuta 2026 — Hienosäädön saatavuus. OpenAI:n itsepalveluhienosäätö on poistumassa: 7. toukokuuta 2026 alkaen organisaatiot, jotka eivät ole koskaan käyttäneet sitä, eivät voi enää luoda tehtäviä; 2. heinäkuuta lähtien sinun on täytynyt käyttää hienosäädettyä mallia viimeisen 60 päivän aikana; ja 6. tammikuuta 2027 alkaen mikään asiakas ei voi käynnistää uusia tehtäviä. Jo koulutetut mallit pysyvät käytössä, kunnes niiden perusmalli poistetaan käytöstä. Tämä kurssi on edelleen hyödyllinen olemassa olevan mallin ymmärtämiseen ja hyödyntämiseen; uusissa projekteissa priorisoi kehotetekniikkaa, RAG:ia ja arviointia.

Miksi systemaattinen vertailu on tärkeää

Hienosäädöllä on hintansa: datan valmisteluaika, koulutuskulut ja ylläpidon monimutkaisuus. Sinun on osoitettava, että hienosäädetty mallisi tarjoaa mitattavan parannuksen verrattuna perusmalliin, jota on ohjeistettu erinomaisella kehotteella. Jos ero on marginaalinen, hienosäätö ei välttämättä ole vaivan arvoista.

Kiusaus tässä harjoituksessa on verrata koulutettua malliasi huonosti ohjeistettuun perusmalliin. Se luo imartelevan mutta arvottoman demonstraation: olet voittanut vastustajan, jonka heikensit itse. Ainoa rehellinen vertailu asettaa hienosäädetyn mallisi vastakkain perusmallin parhaan mahdollisen käytön kanssa.

Määritä vertailukohta

Vertailukohta on perusmalli parhaalla järjestelmäkehotteellasi. Optimoi tämä kehote ennen vertailua. Konkreettisesti tämä tarkoittaa niiden sääntöjen kirjaamista, jotka opetit epäsuorasti esimerkein hienosäädön aikana: rooli, sävy, odotettu pituus ja tapa päättää vuorovaikutus. Alla oleva kehote tekee juuri tämän tukiasistentille; huomaa, että hienosäädetty malli ei tarvitse tällaisia ohjeita, sillä nämä säännöt ovat nyt osa sen painoarvoja.

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

Luo rinnakkaisia vastauksia

Seuraava vaihe on kysyä molemmilta malleilta täsmälleen samoilla kysymyksillä ja säilyttää vastausparit. Valitse kysymykset, jotka edustavat todellista liikennettäsi äläkä oppikirjatapauksia: toimitusvalitus, menettelypyyntö, tyytymättömyys, hyvityspyyntö, faktakysymys. Nämä viisi ryhmää ratkaisevat eron tuotannossa, ei täydellinen muotoilu.

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
)

Pyydä kolmatta mallia tuomitsemaan

Sadan parin lukeminen käsin muuttuu nopeasti lannistavaksi, ja arvostelukyvyn heikkeneminen väsymyksen myötä on väistämätöntä. Kolmas osapuoli, joka ei ole tuottanut kumpaakaan vastausta, arbitroi jokaisen parin neljän kriteerin perusteella ja antaa yleisen tuomion. Ensiksi neutraloi tunnisteet: tuomari näkee ”Vastaus A” ja ”Vastaus B”, ei koskaan sitä, kumpi malli ne tuotti, muuten sen tuomio painottaa mallin nimeä yhtä paljon kuin tekstiä. Seuraavaksi käsittele tapaukset, joissa tuloste ei ole jäsennettävissä; muuten yksi vioittunut vastaus pysäyttää koko kampanjan.

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]

Nyt aggregoi nämä tuomiot yhdeksi luvuksi. Parannusaste – osuus pareista, joissa hienosäädetty malli voittaa – luetaan ennalta määriteltyjä kynnysarvoja vasten: yli 60 %, hyöty on selkeä; 40 % ja 60 % välillä, punnitse hyötyä lisäkustannuksiin nähden; alle sen, hienosäätösi ei ole osoittanut arvoaan, ja ongelma on lähes aina datassa.

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)

Vertaile kustannuksia

Laatu on vain puoli päätöksestä. Hienosäätö vähentää usein syöttötokeneita, sillä pitkä kehote muuttuu tarpeettomaksi, mutta jokainen hienosäädetystä mallista laskutettu token maksaa enemmän. Nämä kaksi vaikutusta vetävät vastakkaisiin suuntiin, ja vain laskelma ratkaisee. Alla oleva funktio asettaa ne vastakkain kuukauden liikenteelle: kehotteen lyhentyminen 500:sta 50 tokeniin kompensoi enemmän kuin kaksinkertaistuneen syöttöhinnan, mutta tämä ei päde jo valmiiksi lyhyeen peruskehotteeseen.

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
)

Vertaile viivettä

Kehotteen lyhentäminen useilla sadoilla tokeneilla vaikuttaa myös vasteaikaan, kriteeriin, jonka käyttäjäsi huomaavat kauan ennen sävyn hienovaraisuuksia. Mittaa viive samoilla kysymyksillä, joita käytit laadulliseen vertailuun, ruuhka-aikojen ulkopuolella, ja toista mittaus useita kertoja: yksittäinen arvo heijastaa lähinnä verkon tilaa testihetkellä.

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 päätös tulosten perusteella

Nyt ristiinviittaa laatu ja kustannukset. Jokainen yhdistelmä vaatii erilaisen päätöksen, ja epämukavin on keskiväli: kun kaksi mallia ovat tasavertaisia, sinun on hylättävä jo maksettu työ sen sijaan, että etsisit jälkikäteen oikeutusta.

TulosToimenpide
Hienosäädetty voittaa laadussa + kustannuksissaOta hienosäädetty malli käyttöön
Hienosäädetty voittaa laadussa, häviää kustannuksissaArvioi, oikeuttaako laatu lisäkustannukset
Samanlaiset tuloksetPysy perusmallissa + kehotteessa
Perusmalli voittaaParanna dataasi ja yritä uudelleen

Keskeiset asiat

  • Vertaa aina perusmalliin + optimoituun kehotteeseen, älä peruskehotteeseen
  • Käytä LLM-arviointia laadullisen vertailun automatisointiin
  • Mittaa kustannukset ja viive, ei vain laatua
  • Yli 60 %:n parannusaste oikeuttaa hienosäädön
  • Jos hienosäätö ei tarjoa selkeää parannusta, pysy kehotetekniikassa