Įvertinkite savo derintą modelį
Šiame puslapyje
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