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

Arvioi hienosäädetty mallisi

Oppitunti 10 / 16 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi arviointi on välttämätöntä
  2. Testijoukon rakentaminen
  3. Automatisoitu arviointi
  4. Erikoismittarit
  5. Ihmisten tekemä arviointi
  6. Arviointiraportti
  7. Keskeiset asiat

Päivitys 2. marraskuuta 2026 — Hienosäädön saatavuus. OpenAI:n itsepalveluhienosäätö on poistumassa: 7. toukokuuta 2026 lähtien 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 arviointeja.

Miksi arviointi on välttämätöntä

Onnistunutta hienosäätöä ei mitata pelkällä häviöllä. Todellinen kysymys kuuluu: onko hienosäädetty mallisi todella parempi kuin perusmalli juuri sinun käyttötarkoitukseesi? Puhtaasti laskeva käyrä todistaa vain, että malli on oppinut toistamaan esimerkkisi; se ei kerro mitään sen toiminnasta näkemättömissä pyynnöissä. Tämä oppitunti näyttää, kuinka rakennat tarkan arviointiprotokollan, joka yhdistää automatisoidut mittarit, LLM-arvioinnin ja ihmisten tekemän tarkastelun.

Testijoukon rakentaminen

Testijoukkosi on pidettävä erillään sekä koulutus- että validointidatasta. Ero on tärkeä: validointijoukko valvoo koulutusta ja vaikuttaa siten hyperparametripäätöksiisi, mikä saastuttaa sitä vähitellen. Testijoukko sitä vastoin avataan vasta, kun malli on jäädytetty. Se edustaa todellisia tilanteita, joissa mallisi kohtaa tuotantoympäristössä, sisältäen samat suhteet yksinkertaisia ja haastavia tapauksia. 80/10/10-jako aiemmin sekoitetusta aineistosta on järkevä lähtökohta.

import json
import random

def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
    """Splits data into train/validation/test."""
    with open(file, "r") as f:
        examples = [json.loads(l) for l in f]

    random.shuffle(examples)
    n = len(examples)
    i1 = int(n * ratios[0])
    i2 = int(n * (ratios[0] + ratios[1]))

    datasets = {
        "train": examples[:i1],
        "validation": examples[i1:i2],
        "test": examples[i2:]
    }

    for name, data in datasets.items():
        with open(f"{name}.jsonl", "w") as f:
            for ex in data:
                f.write(json.dumps(ex, ensure_ascii=False) + "\n")
        print(f"{name}: {len(data)} examples")

    return datasets

prepare_datasets("all_data.jsonl")

Automatisoitu arviointi

Mittareihin perustuva arviointi

Periaate on yksinkertainen: poista jokaisesta testiesimerkistä avustajan viesti – tämä on odotettu vastaus, jota malli ei saa nähdä – lähetä loput ja pidä syöte, vertailuvastaus ja generoitu vastaus rinnakkain. Tämä kolmen sarakkeen rakenne on kaiken seuraavan perusta; sen käyttäminen mittarien laskemiseen tai laadulliseen arviointiin on vain jälkikäsittelykysymys.

from openai import OpenAI

client = OpenAI()

def evaluate_model(model: str, test_examples: list[dict]) -> dict:
    """Evaluates a model on a test set."""
    results = []

    for ex in test_examples:
        # Extract the question (without the expected answer)
        input_messages = [
            m for m in ex["messages"] if m["role"] != "assistant"
        ]
        expected_answer = next(
            m["content"] for m in ex["messages"] if m["role"] == "assistant"
        )

        # Get the model's response
        response = client.responses.create(
            model=model,
            input=input_messages
        )
        model_answer = response.output_text

        results.append({
            "input": input_messages[-1]["content"],
            "expected": expected_answer,
            "obtained": model_answer
        })

    return results

LLM-tuomariarviointi

Tehokas tekniikka on käyttää suorituskykyistä mallia vastausten laadun arvioimiseen. Sanasanainen vertailu vertailuvastaukseen muuttuu käyttökelvottomaksi heti, kun useat muotoilut ovat hyväksyttäviä; tuomari sen sijaan arvostaa sisältöä. Sen tuomion laatu riippuu täysin kehotteen tarkkuudesta: neljä arviointiperustetta asteikolla 1–5, pakotettu JSON-tuloste ja vapaamuotoinen kommentti, jota käytät myöhemmin epäonnistumisten ymmärtämiseen. Suunnittele tilanteet, joissa tulostetta ei voi jäsentää, sen sijaan että antaisit poikkeuksen keskeyttää koko kampanjan.

def evaluate_with_judge(results: list[dict]) -> list[dict]:
    """Uses gpt-5.6-sol as a judge to evaluate responses."""
    evaluations = []

    for r in results:
        judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.

Question: {r['input']}

Expected response: {r['expected']}

Obtained response: {r['obtained']}

Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?

Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""

        response = client.responses.create(
            model="gpt-5.6-sol",
            input=judge_prompt
        )

        try:
            evaluation = json.loads(response.output_text)
            evaluations.append(evaluation)
        except json.JSONDecodeError:
            evaluations.append({"error": "Response not parseable"})

    return evaluations

Erikoismittarit

Kaksi edellistä lähestymistapaa toimivat hyvin kirjallisille vastauksille. Heti kun mallisi tulosteella on kiinteä rakenne, suoraviivaisemmat mittaukset tulevat mahdollisiksi ja säästävät sinut kiertämästä tuomarin kautta.

Luokittelulle

Kun odotettu tuloste kuuluu suljettuun joukkoon – kuten tukipyynnön kategoria, sentimentti tai tuotekoodi – täsmällinen osuma muuttuu jälleen merkitykselliseksi. Normalisoi kirjainkoko ja välilyönnit ennen vertailua; muuten “Urgent” versus “urgent” lasketaan virheeksi ja vääristää prosenttiosiuttasi.

def classification_metrics(results: list[dict]) -> dict:
    """Calculates precision, recall, and F1 for a classification task."""
    correct = sum(
        1 for r in results
        if r["expected"].strip().lower() == r["obtained"].strip().lower()
    )
    total = len(results)
    precision = correct / total if total > 0 else 0

    print(f"Precision: {precision:.2%} ({correct}/{total})")
    return {"precision": precision, "correct": correct, "total": total}

Funktiokutsuille

Funktiokutsuja arvioidaan kahdella akselilla, jotka on mitattava erikseen. Malli, joka valitsee oikean funktion mutta saa parametrin väärin, epäonnistuu eri tavalla kuin se, joka kutsuu täysin väärää työkalua: ensimmäinen ongelma ratkeaa erotusesimerkeillä, toinen erotteluesimerkeillä. Yksi globaali pistemäärä peittäisi tämän eron ja jättäisi sinut työskentelemään sokkona.

def function_calling_metrics(results: list[dict]) -> dict:
    """Evaluates the quality of function calls."""
    stats = {"correct_function": 0, "correct_params": 0, "total": 0}

    for r in results:
        stats["total"] += 1
        if r.get("expected_function") == r.get("obtained_function"):
            stats["correct_function"] += 1
        if r.get("expected_params") == r.get("obtained_params"):
            stats["correct_params"] += 1

    print(f"Correct function: {stats['correct_function']}/{stats['total']}")
    print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
    return stats

Ihmisten tekemä arviointi

Automatisoitu arviointi ei tavoita kaikkea. Hieman alentuva sävy, lause, joka ei miellytä asiakkaitasi, tai teknisesti oikea mutta käyttökelvoton vastaus: nämä puutteet paljastuvat vain ihmisen silmällä. Protokolla on suoraviivainen. Ota satunnaisotos kahdestakymmenestä viiteenkymmeneen vastaukseen, älä koskaan niitä tapauksia, jotka olet jo merkinnyt ongelmallisiksi, tai mittaat vain omaa valintaharhaasi. Määritä sitten selkeät, mitattavat kriteerit ja formalisoi ne standardoiduksi pisteytysmatriisiksi, jotta kaksi arvioijaa arvostavat samaa asiaa.

Lopuksi pyydä useita henkilöitä arvioimaan ja laske arvioijien välinen yhteensopivuus. Vahva erimielisyys ei välttämättä tarkoita huonoa mallia: useimmiten se paljastaa, että matriisisi on edelleen epäselvä ja tarvitsee tarkennusta, ennen kuin voit tehdä johtopäätöksiä.

Esimerkki arviointimatriisista

Criterion 1 (Poor) 3 (Acceptable) 5 (Excellent)
Relevance Off-topic Partially relevant Perfectly targeted
Tone Inappropriate Acceptable but plain Perfectly aligned
Format Not followed Partially followed Perfectly followed

Arviointiraportti

Yksi viimeinen refleksi erottaa arvioinnin päätöksestä: kirjaa molemmat tulostyypit yhteen raporttiin, jossa on selkeä suositus. Asettamasi kynnysarvo – tässä ihmisten keskiarvo 4 tuotantoon siirtymiseksi, 3 datan iterointiin – on valittava ennen kampanjan käynnistämistä. Jos se päätetään jälkeenpäin, se mukautuu aina toivomaasi tulokseen.

def evaluation_report(auto_results: dict, human_results: dict):
    """Generates a combined evaluation report."""
    print("=" * 60)
    print("FINE-TUNED MODEL EVALUATION REPORT")
    print("=" * 60)

    print(f"\nAutomated metrics:")
    for k, v in auto_results.items():
        print(f"  {k}: {v}")

    print(f"\nHuman evaluation:")
    for k, v in human_results.items():
        print(f"  {k}: {v}")

    print(f"\nRecommendation:")
    average_score = sum(human_results.values()) / len(human_results)
    if average_score >= 4:
        print("  Model is ready for production")
    elif average_score >= 3:
        print("  Improvements needed—iterate on data")
    else:
        print("  Insufficient results—rethink your approach")

Keskeiset asiat

  • Pidä aina erillinen testijoukko (ei koulutus eikä validointi)
  • Yhdistä automatisoitu ja ihmisten tekemä arviointi
  • LLM-tuomariarviointi on hyvä kompromissi näiden kahden välillä
  • Määritä mitattavat kriteerit ennen aloittamista
  • Alhainen häviöarvo ei takaa tuotantolaatua