Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Įvertinkite savo derintą modelį

Paskaita 10 iš 16 Atnaujinta 2026 m. lapkričio 2 d. Pažengusiems
Šiame puslapyje
  1. Kodėl vertinimas yra būtinas
  2. Testavimo aibės kūrimas
  3. Automatizuotas vertinimas
  4. Specializuoti rodikliai
  5. Žmonių atliekamas vertinimas
  6. Vertinimo ataskaita
  7. Svarbiausi punktai

Atnaujinimas 2026 m. lapkričio 2 d. — Derinimo prieinamumas. „OpenAI“ savitarnos derinimo paslauga yra nutraukiama: nuo 2026 m. gegužės 7 d. organizacijos, kurios jos niekada nenaudojo, nebegali kurti užduočių; nuo liepos 2 d. turite būti naudoję derintą modelį per pastaruosius 60 dienų; o nuo 2027 m. sausio 6 d. joks klientas nebegalės paleisti naujų užduočių. Jau apmokyti modeliai lieka naudojami, kol jų bazinis modelis bus pašalintas. Šis kursas išlieka naudingas norint suprasti ir išnaudoti esamą modelį; naujiems projektams teikite pirmenybę raginimų inžinerijai (prompt engineering), RAG ir vertinimams.

Kodėl vertinimas yra būtinas

Sėkmingas derinimas matuojamas ne vien nuostolių (loss) rodikliu. Tikrasis klausimas toks: ar jūsų derintas modelis jūsų atveju iš tikrųjų veikia geriau nei bazinis modelis? Aiškiai mažėjanti kreivė įrodo tik tai, kad modelis išmoko atkartoti jūsų pavyzdžius; ji nieko nepasako apie jo elgseną susidūrus su nematytais prašymais. Šioje pamokoje sužinosite, kaip sukurti griežtą vertinimo protokolą, derinant automatizuotus rodiklius, LLM vertinimą ir žmonių peržiūrą.

Testavimo aibės kūrimas

Jūsų testavimo aibė turi būti atskira nuo tiek mokymo, tiek validacijos duomenų. Šis skirtumas yra svarbus: validacijos aibė stebi mokymą ir todėl daro įtaką jūsų hiperparametrų sprendimams, o tai ją palaipsniui „užteršia“. Tuo tarpu testavimo aibė atveriama tik tada, kai modelis yra užfiksuotas. Ji atspindi realaus pasaulio situacijas, su kuriomis jūsų modelis susidurs gamyboje, išlaikant tas pačias paprastų ir sudėtingų atvejų proporcijas. 80/10/10 padalijimas anksčiau sumaišytame korpuse yra pagrįstas pradinis taškas.

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

Automatizuotas vertinimas

Vertinimas pagal rodiklius

Principas paprastas: kiekvienam testavimo pavyzdžiui pašalinkite asistento žinutę – tai laukiamas atsakymas, kurio modelis neturi matyti – pateikite likusią dalį ir greta palikite įvestį, etaloninį atsakymą bei sugeneruotą atsakymą. Ši trijų stulpelių struktūra yra visko, kas seka, pagrindas; jos naudojimas rodikliams skaičiuoti arba kokybiniam vertinimui tėra tolesnio apdorojimo klausimas.

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

Vertinimas naudojant „LLM kaip teisėją“

Galinga technika – naudoti našų modelį atsakymų kokybei vertinti. Žodis žodin palyginimas su etalonu tampa nebetinkamas, kai galimi keli formuluotės variantai; tuo tarpu „teisėjas“ įvertina esmę. Jo verdikto kokybė visiškai priklauso nuo raginimo (prompt) tikslumo: keturi kriterijai, vertinami nuo 1 iki 5, privaloma JSON išvestis ir laisvos formos komentaras, kurį vėliau naudosite nesėkmėms suprasti. Numatykite atvejus, kai išvesties nepavyksta išanalizuoti, kad išimtis nenutrauktų viso vertinimo proceso.

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

Specializuoti rodikliai

Du ankstesni metodai gerai veikia rašytiniams atsakymams. Kai tik jūsų modelio išvestis turi fiksuotą struktūrą, tampa įmanomi tiesioginiai matavimai, leidžiantys išvengti kelio per „teisėją“.

Klasifikacijai

Kai laukiamas rezultatas priklauso uždarai aibei – bilieto kategorijai, nuotaikai, produkto kodui – vėl tampa aktualus tikslus atitikimas (exact match). Prieš lygindami normalizuokite raidžių dydį ir tarpus; kitaip „Urgent“ ir „urgent“ bus laikomi klaida ir iškraipys jūsų rodiklį.

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}

Funkcijų kvietimui

Funkcijų kvietimas vertinamas dviem ašimis, kurios turi būti matuojamos atskirai. Modelis, kuris pasirenka tinkamą funkciją, bet suklysta parametre, žlunga kitaip nei tas, kuris iškviečia visiškai netinkamą įrankį: pirmąją problemą išsprendžia ekstrahavimo pavyzdžiai, antrąją – diskriminacijos pavyzdžiai. Vienas bendras balas užmaskuotų šį skirtumą ir paliktų jus dirbti akliems.

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

Žmonių atliekamas vertinimas

Automatizuotas vertinimas neapima visko. Šiek tiek arogantiškas tonas, frazė, kuri nepatinka jūsų klientams, techniškai teisingas, bet nenaudojamas atsakymas: šie trūkumai pastebimi tik žmogaus akiai. Protokolas yra paprastas. Atsitiktine tvarka atrinkite nuo dvidešimties iki penkiasdešimties atsakymų, niekada neimkite tų atvejų, kuriuos jau pažymėjote kaip probleminius, kitaip matuosite tik savo atrankos šališkumą. Tada apibrėžkite aiškius, išmatuojamus kriterijus ir formalizuokite juos standartizuotoje vertinimo skalėje, kad du vertintojai vertintų tą patį dalyką.

Galiausiai, leiskite įvertinti keliems žmonėms ir apskaičiuokite vertintojų sutarimą. Didelis nesutarimas nebūtinai reiškia blogą modelį: dažniausiai tai rodo, kad jūsų vertinimo skalė lieka dviprasmiška ir ją reikia patikslinti prieš darant kokias nors išvadas.

Vertinimo skalės pavyzdys

Kriterijus 1 (Prastas) 3 (Priimtinas) 5 (Puikus)
Aktualumas Nesusijęs su tema Iš dalies aktualus Tobulai tikslus
Tonas Netinkamas Priimtinas, bet blankus Tobulai derantis
Formatas Nesilaikyta Iš dalies laikytasi Tobulai laikytasi

Vertinimo ataskaita

Vienas galutinis refleksas skiria vertinimą nuo sprendimo: abi rezultatų šeimas užfiksuokite vienoje ataskaitoje, pridėdami aiškią rekomendaciją. Jūsų nustatytą slenkstį – čia vidutinis žmogaus balas 4 leidžia pereiti į gamybą, 3 reikalauja kartoti darbą su duomenimis – reikia pasirinkti prieš pradedant vertinimo kampaniją. Jei tai nuspręsite vėliau, slenkstis visada prisitaikys prie norimo rezultato.

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

Svarbiausi punktai

  • Visada turėkite nepriklausomą testavimo aibę (nei mokymo, nei validacijos)
  • Derinkite automatizuotą ir žmonių atliekamą vertinimą
  • Vertinimas naudojant „LLM kaip teisėją“ yra geras kompromisas tarp šių dviejų būdų
  • Prieš pradėdami apibrėžkite išmatuojamus kriterijus
  • Žemas nuostolių rodiklis negarantuoja kokybės gamyboje