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

Hinda oma häälestatud mudelit

Õppetund 10 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Miks hindamine on hädavajalik
  2. Testkomplekti loomine
  3. Automatiseeritud hindamine
  4. Spetsialiseeritud meetrikad
  5. Inimlik hindamine
  6. Hindamisaruanne
  7. 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 mudelid jäävad kasutatavaks kuni nende baasmudeli kasutusest kõrvaldamiseni. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja rakendamiseks; uute projektide puhul sea esikohale vihjeinseneria (prompt engineering), RAG ja hindamine.

Miks hindamine on hädavajalik

Edukat häälestamist ei mõõdeta ainult kadu (loss) põhjal. Tegelik küsimus on: kas sinu häälestatud mudel on sinu kasutusjuhu jaoks tegelikult parem kui baasmudel? Puhtalt langev kõver tõestab vaid seda, et mudel õppis sinu näiteid reprodutseerima; see ei ütle midagi selle käitumise kohta nägemata päringute korral. See tund õpetab, kuidas koostada range hindamisprotokoll, kombineerides automatiseeritud meetrikaid, LLM-hindamist ja inimlikku ülevaatust.

Testkomplekti loomine

Sinu testkomplekt peab olema eraldatud nii treening- kui ka valideerimisandmetest. Erinevus on oluline: valideerimiskomplekt jälgib treeningut ja mõjutab seetõttu sinu hüperparameetrite otsuseid, mis saastab seda järk-järgult. Testkomplekt avatakse seevastu alles siis, kui mudel on külmutatud. See esindab reaalseid olukordi, millega mudel tootmises kokku puutub, säilitades lihtsate ja keeruliste juhtumite samad proportsioonid. 80/10/10 jaotus eelnevalt segatud korpuse puhul on mõistlik alguspunkt.

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")

Automatiseeritud hindamine

Meetrikapõhine hindamine

Põhimõte on lihtne: iga testnäite puhul eemalda assistendi sõnum – see on oodatav vastus, mida mudel ei tohi näha –, esita ülejäänud osa ja hoia sisend, võrdlusvastus ja genereeritud vastus kõrvuti. See kolme veeru struktuur on kõige järgneva alus; selle kasutamine meetrikate arvutamiseks või kvalitatiivseks hindamiseks on vaid järeltöötluse küsimus.

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-hindaja (LLM-as-a-Judge) hindamine

Võimas tehnika on kasutada suure jõudlusega mudelit vastuste kvaliteedi hindamiseks. Sõna-sõnalt võrdlus võrdlusvastusega muutub kasutuks niipea, kui lubatud on mitu sõnastust; hindaja hindab aga sisu. Tema otsuse kvaliteet sõltub täielikult vihje (prompt) täpsusest: neli kriteeriumi hinnanguga 1–5, sunnitud JSON-väljund ja vabatekstiline kommentaar, mida kasutad hiljem ebaõnnestumiste mõistmiseks. Planeeri juhtumeid, kus väljundit ei saa parsida, selle asemel et lasta erandil kampaaniat katkestada.

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

Spetsialiseeritud meetrikad

Kaks eelmist lähenemist toimivad hästi kirjalike vastuste puhul. Niipea kui sinu mudeli väljundil on fikseeritud struktuur, muutuvad võimalikuks otsesemad mõõtmised, mis säästavad sind hindaja kaudu keerutamast.

Klassifitseerimise jaoks

Kui oodatav väljund kuulub suletud hulka – pileti kategooria, sentiment, tootekood – muutub taas asjakohaseks täpne vaste (exact match). Normaliseeri tähistus ja tühikud enne võrdlemist; vastasel juhul loetakse „Urgent“ versus „urgent“ veaks ja moonutab sinu määra.

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}

Funktsioonide kutsumise (Function Calling) jaoks

Funktsioonide kutsumist hinnatakse kahel teljel, mida tuleb mõõta eraldi. Mudel, mis valib õige funktsiooni, kuid saab parameetri valesti, ebaõnnestub teisiti kui see, mis kutsub täiesti vale tööriista: esimest probleemi lahendavad ekstraheerimise näited, teist diskrimineerimise näited. Üksainus globaalne skoor varjaks seda eristust ja jätaks sind pimesi tegutsema.

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

Inimlik hindamine

Automatiseeritud hindamine ei püüa kõike kinni. Kergelt ülbe toon, fraas, mis sinu klientidele ei meeldi, tehniliselt korrektne, kuid kasutamatu vastus: need vead ilmnevad vaid inimliku pilgu all. Protokoll on sirgjooneline. Vali juhuslikult kakskümmend kuni viiskümmend vastust, mitte kunagi neid juhtumeid, mille oled juba problemaatilistena märganud, muidu mõõdad vaid oma valikukallutatust. Seejärel defineeri selged, mõõdetavad kriteeriumid ja vormista need standardiseeritud hindamismaatriksiks, et kaks hindajat hindaksid sama asja.

Lõpuks lase mitmel inimesel hinnata ja arvuta hindajatevaheline kooskõla. Tugev lahkarvamus ei viita tingimata halvale mudelile: enamasti paljastab see, et sinu maatriks on endiselt ebaselge ja vajab selgitamist enne, kui saad mingile järeldusele jõuda.

Näidislik hindamismaatriks

Kriteerium 1 (Halb) 3 (Vastuvõetav) 5 (Suurepärane)
Asjakohasus Teemast väljas Osaliselt asjakohane Ideaalne tabamus
Toon Sobimatu Vastuvõetav, kuid igav Ideaalne kooskõla
Formaat Eiramata jäetud Osaliselt järgitud Ideaalne järgimine

Hindamisaruanne

Üks viimane refleks eristab hindamist otsusest: kirjuta mõlemat tüüpi tulemused ühte aruandesse, lisades selge soovituse. Lävi, mille sead – siin inimlik keskmine 4 tootmisse minekuks, 3 andmete iteratsiooniks – tuleb valida enne kampaania käivitamist. Hiljem otsustatuna kohandub see alati tulemusega, mida lootsid saada.

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")

Peamised punktid

  • Eralda alati sõltumatu testkomplekt (ei treening ega valideerimine)
  • Kombineeri automatiseeritud ja inimlikku hindamist
  • LLM-hindaja hindamine on hea kompromiss kahe vahel
  • Defineeri mõõdetavad kriteeriumid enne alustamist
  • Madal kadu (loss) ei garanteeri tootmiskvaliteeti