Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ocena vašega fino uglašenega modela

Lekcija 10 od 16 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Zakaj je ocena nujna
  2. Izgradnja testnega niza
  3. Avtomatizirano ocenjevanje
  4. Specializirane metrike
  5. Človeško ocenjevanje
  6. Poročilo o oceni
  7. Ključne ugotovitve

Posodobitev 2. novembra 2026 — Razpoložljivost fino uglaševanja. Samostojno fino uglaševanje podjetja OpenAI se postopno ukinja: od 7. maja 2026 organizacije, ki ga še niso uporabljale, ne morejo več ustvarjati opravil; od 2. julija morate biti fino uglašen model uporabili v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler se njihov osnovni model ne umakne. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov, RAG in ocenjevanju.

Zakaj je ocena nujna

Uspešno fino uglaševanje ne merimo le z izgubo. Pravo vprašanje je: ali je vaš fino uglašen model za vaš primer uporabe dejansko boljši od osnovnega modela? Čista padajoča krivulja dokazuje le, da se je model naučil reproducirati vaše primere; o njegovem obnašanju pri nevidnih zahtevkih ne pove ničesar. Ta lekcija vam pokaže, kako zgraditi strog protokol ocenjevanja, ki združuje avtomatizirane metrike, ocenjevanje z LLM in človeški pregled.

Izgradnja testnega niza

Vaš testni niz mora biti ločen od podatkov za usposabljanje in validacijo. Razlika je pomembna: validacijski niz spremlja usposabljanje in zato vpliva na vaše odločitve o hiperparametrih, kar ga postopoma onesnaži. Testni niz pa odprete šele, ko je model zamrznjen. Predstavlja situacije iz resničnega sveta, s katerimi se bo model srečal v proizvodnji, z enakimi deleži preprostih in zahtevnih primerov. Razdelitev 80/10/10 na predhodno premešanem korpusu je razumen začetek.

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

Avtomatizirano ocenjevanje

Ocenjevanje na podlagi metrik

Načelo je preprosto: za vsak testni primer odstranite sporočilo asistenta – to je pričakovani odgovor, ki ga model ne sme videti – predložite ostalo in hranite vhod, referenčni odgovor in generirani odgovor drug ob drugem. Ta struktura s tremi stolpci je temelj vsega, kar sledi; njena uporaba za izračun metrik ali kvalitativno presojo je zgolj stvar nadaljnjega procesiranja.

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

Ocenjevanje z LLM kot sodnikom

Mogočna tehnika je uporaba zmogljivega modela za oceno kakovosti odgovorov. Primerjava beseda za besedo s referenco postane neuporabna, takoj ko je sprejemljivih več formulacij; sodnik pa ceni bistvo. Kakovost njegove sodbe je v celoti odvisna od natančnosti poziva: štiri merila, ocenjena od 1 do 5, vsiljen izhod JSON in komentar v prostem besedilu, ki ga boste kasneje uporabili za razumevanje napak. Načrtujte primere, ko izhoda ni mogoče razčleniti, namesto da bi izjema prekinila kampanjo.

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

Specializirane metrike

Prejšnja dva pristopa dobro delujeta za pisne odgovore. Takoj ko ima izhod vašega modela fiksno strukturo, so mogoče bolj neposredne meritve, ki vam prihranijo ovinek prek sodnika.

Za klasifikacijo

Ko pričakovani izhod spada v zaprto množico – kategorija tiketa, sentiment, koda izdelka – postane natančno ujemanje ponovno relevantno. Pred primerjavo normalizirajte velike in male črke ter presledke; sicer bo „Urgent” nasproti „urgent” štelo kot napaka in izkrivilo vašo stopnjo.

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}

Za klicanje funkcij

Klicanje funkcij ocenjujemo po dveh oseh, ki ju je treba meriti ločeno. Model, ki izbere pravo funkcijo, a dobi parameter narobe, odpove drugače kot tisti, ki pokliče popolnoma napačno orodje: prvo težavo rešite s primeri ekstrakcije, drugo s primeri diskriminacije. En sam globalni rezultat bi to razliko zamaskiral in vas pustil delati na slepo.

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

Človeško ocenjevanje

Avtomatizirano ocenjevanje ne zajame vsega. Rahlo pokroviteljski ton, stavek, ki ne sede vašim strankam, tehnično pravilen, a neuporaben odgovor: te napake se pokažejo le pod človeškim očesom. Protokol je preprost. Naključno vzorčite dvajset do petdeset odgovorov, nikoli tistih, ki ste jih že označili kot problematične, sicer boste merili le svojo pristranskost pri izbiri. Nato določite jasna, merljiva merila in jih formalizirajte v standardizirani ocenjevalni lestvici, da dva recenzenta ocenjujeta isto stvar.

Nazadnje naj oceno opravi več ljudi in izračunajte soglasje med ocenjevalci. Močno nesoglasje nujno ne pomeni slabega modela: najpogosteje razkrije, da vaša lestvica ostaja dvoumna in potrebuje pojasnilo, preden lahko karkoli zaključite.

Vzorčna ocenjevalna lestvica

Merilo 1 (Slabo) 3 (Sprejemljivo) 5 (Odlično)
Relevantnost Izven teme Delno relevantno Popolnoma ciljno usmerjeno
Ton Neustrezno Sprejemljivo, a dolgočasno Popolnoma usklajeno
Oblika Ni upoštevano Delno upoštevano Popolnoma upoštevano

Poročilo o oceni

En sam zadnji refleks loči oceno od odločitve: zabeležite obe družini rezultatov v eno samo poročilo, ki ga spremlja izrecno priporočilo. Prag, ki ga določite – tu povprečna človeška ocena 4 za prehod v proizvodnjo, 3 za iteracijo na podatkih – mora biti izbran pred zagonom kampanje. Če ga določite naknadno, se vedno prilagodi rezultatu, ki ste si ga želeli.

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

Ključne ugotovitve

  • Vedno ločite neodvisen testni niz (niti za usposabljanje niti za validacijo)
  • Združite avtomatizirano in človeško ocenjevanje
  • Ocenjevanje z LLM kot sodnikom je dober kompromis med obema
  • Pred začetkom določite merljiva merila
  • Nizka izguba ne zagotavlja kakovosti za proizvodnjo