Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Novērtē savu smalki noregulēto modeli

Nodarbība 10 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Kāpēc novērtēšana ir būtiska
  2. Testa kopas izveide
  3. Automatizēta novērtēšana
  4. Specializēti rādītāji
  5. Cilvēku veikta novērtēšana
  6. Novērtēšanas ziņojums
  7. Galvenās atziņas

Atjauninājums: 2026. gada 2. novembris — Smalkās noregulēšanas pieejamība. OpenAI pašapkalpošanās smalkā noregulēšana tiek pakāpeniski izslēgta: kopš 2026. gada 7. maija organizācijas, kas to nekad nav izmantojušas, vairs nevar izveidot uzdevumus; kopš 2. jūlija jums ir jābūt izmantojušam smalki noregulētu modeli pēdējo 60 dienu laikā; un sākot ar 2027. gada 6. janvāri, neviens klients nevarēs uzsākt jaunus uzdevumus. Jau apmācītie modeļi paliek lietojami, līdz tiek izņemts to bāzes modelis. Šis kurss joprojām ir noderīgs, lai izprastu un izmantotu esošu modeli; jauniem projektiem dodiet priekšroku uzvedņu inženierijai (prompt engineering), RAG un novērtēšanai.

Kāpēc novērtēšana ir būtiska

Veiksmīgu smalko noregulēšanu nemēra tikai pēc zudumu funkcijas (loss). Patiesais jautājums ir: vai tavs smalki noregulētais modelis patiešām ir labāks par bāzes modeli tavam konkrētajam lietojumam? Gludi krītoša līkne tikai pierāda, ka modelis ir iemācījies atveidot tavus piemērus; tā neko nepasaka par tā uzvedību attiecībā uz neredzētiem pieprasījumiem. Šī nodarbība parāda, kā izveidot stingru novērtēšanas protokolu, apvienojot automatizētus rādītājus, LLM vērtēšanu un cilvēku pārskatu.

Testa kopas izveide

Tava testa kopai ir jābūt atdalītai gan no apmācības, gan validācijas datiem. Šī atšķirība ir svarīga: validācijas kopa uzrauga apmācību un tādējādi ietekmē tavus hiperparametru lēmumus, kas to pakāpeniski piesārņo. Turpretī testa kopa tiek atvērta tikai tad, kad modelis ir iesaldēts. Tā atspoguļo reālās situācijas, ar kurām tavs modelis saskarsies ražošanas vidē, saglabājot tādas pašas vienkāršu un sarežģītu gadījumu proporcijas. 80/10/10 sadalījums iepriekš sajauktā korpusā ir saprātīgs sākumpunkts.

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

Automatizēta novērtēšana

Novērtēšana, balstoties uz rādītājiem

Princips ir vienkāršs: katram testa piemēram noņem asistenta ziņojumu — tā ir paredzamā atbilde, ko modelim nedrīkst redzēt — iesniedz pārējo daļu un saglabā ievadi, atsauces atbildi un ģenerēto atbildi blakus. Šī trīs kolonnu struktūra ir pamats visam, kas seko; tās izmantošana rādītāju aprēķināšanai vai kvalitatīvam vērtējumam ir tikai turpmākās apstrādes jautājums.

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

Novērtēšana, izmantojot „LLM kā tiesnesi”

Spēcīga metode ir izmantot augstas veiktspējas modeli, lai vērtētu atbilžu kvalitāti. Salīdzinājums vārds vārdā ar atsauces tekstu kļūst nelietojams, tiklīdz ir pieņemami vairāki formulējumi; tiesnesis tomēr novērtē saturu. Tā sprieduma kvalitāte ir pilnībā atkarīga no uzvednes precizitātes: četri kritēriji, kas vērtēti no 1 līdz 5, piespiedu JSON izvade un brīva teksta komentārs, ko vēlāk izmantosi, lai saprastu kļūmes. Plāno gadījumus, kad izvadi nevar parsēt, nevis ļauj izņēmumam pārtraukt kampaņu.

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

Specializēti rādītāji

Abas iepriekšējās pieejas labi darbojas rakstiskām atbildēm. Tiklīdz tava modeļa izvadei ir fiksēta struktūra, kļūst iespējami tiešāki mērījumi, kas ietaupa tev laiku, izvairoties no tiesneša iesaistes.

Klasifikācijai

Kad paredzamā izvade pieder slēgtai kopai — biļetes kategorija, noskaņojums, produkta kods — atkal kļūst nozīmīga precīza atbilstība (exact match). Pirms salīdzināšanas normalizē lielos/burtus un atstarpes; pretējā gadījumā „Urgent” pret „urgent” tiks uzskatīts par kļūdu un sagrozīs tavu rādītāju.

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}

Funkciju izsaukumiem (Function Calling)

Funkciju izsaukumus vērtē pēc divām asīm, kas jāmēra atsevišķi. Modelis, kas izvēlas pareizo funkciju, bet kļūdās parametrā, izgāžas citādāk nekā tas, kas izsauc pilnīgi nepareizu rīku: pirmo problēmu risina ar ekstrakcijas piemēriem, otro — ar diskriminācijas piemēriem. Viens vispārīgs rezultāts šo atšķirību noslēptu un liktu tev strādāt akli.

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

Cilvēku veikta novērtēšana

Automatizēta novērtēšana neaptver visu. Nedaudz augstprātīgs tonis, frāze, kas nepatīk taviem klientiem, tehniski pareiza, bet nelietojama atbilde: šie trūkumi atklājas tikai cilvēka acīm. Protokols ir vienkāršs. Nejauši atlasiet divdesmit līdz piecdesmit atbildes, nekad ne tās, kuras jau esi atzīmējis kā problemātiskas, citādi mērīsi tikai savu atlases novirzi. Tad definē skaidrus, izmērāmus kritērijus un formalizē tos standartizētā vērtēšanas rubrikā, lai divi recenzenti vērtētu vienu un to pašu.

Visbeidzot, liec vairākiem cilvēkiem veikt novērtēšanu un aprēķini vērtētāju saskaņotību. Liela neatbilstība ne vienmēr liecina par sliktu modeli: visbiežāk tā atklāj, ka tava rubrika joprojām ir neskaidra un tai nepieciešama precizēšana, pirms vari izdarīt secinājumus.

Novērtēšanas rubrikas paraugs

Kritērijs 1 (Slikti) 3 (Pieņemami) 5 (Lieliski)
Atbilstība Nav saistīts ar tēmu Daļēji atbilstošs Ideāli mērķēts
Tons Nepiemērots Pieņemams, bet vienmuļš Ideāli saskaņots
Formāts Nav ievērots Daļēji ievērots Ideāli ievērots

Novērtēšanas ziņojums

Viens pēdējais reflekss atdala novērtēšanu no lēmuma: fiksē abus rezultātu veidus vienotā ziņojumā, pievienojot skaidru ieteikumu. Slieksnis, ko nosaki — šeit cilvēka vidējais rādītājs 4, lai pārietu uz ražošanu, vai 3, lai iterētu datus — ir jāizvēlas pirms kampaņas uzsākšanas. Ja to izlemj pēc tam, tas vienmēr pielāgojas rezultātam, ko cerēji iegūt.

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

Galvenās atziņas

  • Vienmēr atdali neatkarīgu testa kopu (ne apmācības, ne validācijas)
  • Apvieno automatizētu un cilvēku veiktu novērtēšanu
  • Novērtēšana, izmantojot „LLM kā tiesnesi”, ir labs kompromiss starp abām pieejām
  • Pirms sākuma definē izmērāmus kritērijus
  • Zems zudumu rādītājs negarantē kvalitāti ražošanas vidē