Procijeni svoj fino podešeni model
Na ovoj stranici
Ažuriranje 2. studenoga 2026. — Dostupnost finog podešavanja. OpenAI postupno ukida samostalno fino podešavanje: od 7. svibnja 2026. organizacije koje ga nikada nisu koristile više ne mogu stvarati zadatke; od 2. srpnja moraš koristiti fino podešeni model unutar posljednjih 60 dana; a počevši od 6. siječnja 2027., nijedan korisnik neće moći pokrenuti nove zadatke. Već obučeni modeli ostaju upotrebljivi dok se njihov temeljni model ne povuče. Ovaj tečaj i dalje je koristan za razumijevanje i iskorištavanje postojećeg modela; za nove projekte daj prednost inženjerstvu upita (prompt engineering), RAG-u i evaluacijama.
Zašto je evaluacija ključna
Uspješno fino podešavanje ne mjeri se samo gubitkom (loss). Pravo je pitanje: je li tvoj fino podešeni model zapravo bolji od temeljnog modela za tvoj slučaj upotrebe? Čista silazna krivulja dokazuje samo da je model naučio reproducirati tvoje primjere; ne govori ništa o njegovu ponašanju na neviđenim zahtjevima. Ova lekcija pokazuje ti kako izgraditi rigorozan protokol evaluacije, kombinirajući automatizirane metrike, procjenu pomoću LLM-a i ljudski pregled.
Izrada testnog skupa
Tvoj testni skup mora biti odvojen i od podataka za obuku i od validacijskih podataka. Razlika je bitna: validacijski skup prati obuku i stoga utječe na tvoje odluke o hiperparametrima, što ga postupno kontaminira. Testni skup, nasuprot tome, otvara se tek kada je model zamrznut. On predstavlja situacije iz stvarnog svijeta s kojima će se tvoj model susresti u proizvodnji, s istim omjerom jednostavnih i zamršenih slučajeva. Podjela 80/10/10 na prethodno promiješanom korpusu razuman je početak.
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")
Automatizirana evaluacija
Evaluacija temeljena na metrikama
Načelo je jednostavno: za svaki testni primjer ukloni poruku asistenta – to je očekivani odgovor koji model ne smije vidjeti – pošalji ostatak i zadrži ulaz, referentni odgovor i generirani odgovor jedan do drugoga. Ova struktura s tri stupca temelj je svega što slijedi; njezina uporaba za izračun metrika ili kvalitativnu procjenu samo je pitanje daljnje obrade.
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
Evaluacija pomoću LLM-a kao sucem
Moćna je tehnika koristiti visokoučinkovit model za procjenu kvalitete odgovora. Usporedba riječ-po-riječ s referencom postaje neupotrebljiva čim su prihvatljiva više načina formuliranja; sudac, međutim, cijeni suštinu. Kvaliteta njegove presude u potpunosti ovisi o preciznosti upita: četiri kriterija ocijenjena od 1 do 5, prisilni JSON izlaz i komentar u slobodnom tekstu koji ćeš kasnije koristiti za razumijevanje neuspjeha. Planiraj slučajeve gdje izlaz nije moguće analizirati umjesto da dopustiš da iznimka prekine kampanju.
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
Specijalizirane metrike
Dva prethodna pristupa dobro funkcioniraju za pisane odgovore. Čim izlaz tvog modela ima fiksnu strukturu, moguće je koristiti izravnije mjere koje te štede zaobilaznog puta preko suca.
Za klasifikaciju
Kada očekivani izlaz pripada zatvorenom skupu – kategorija tiketa, sentiment, kod proizvoda – točno podudaranje ponovno postaje relevantno. Normaliziraj velika i mala slova te razmake prije usporedbe; inače će se „Urgent“ naspram „urgent“ računati kao pogreška i iskriviti tvoju stopu.
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 pozivanje funkcija
Pozivanje funkcija procjenjuje se po dvije osi koje se moraju mjeriti odvojeno. Model koji odabere ispravnu funkciju, ali pogriješi u parametru, ne uspijeva na isti način kao onaj koji pozove potpuno pogrešan alat: prvi se problem rješava primjerima ekstrakcije, drugi primjerima diskriminacije. Jedna globalna ocjena prikrila bi tu razliku i ostavila te da radiš naslijepo.
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
Ljudska evaluacija
Automatizirana evaluacija ne hvata sve. Blago pokroviteljski ton, fraza koja ne odgovara tvojim korisnicima, tehnički točan, ali neupotrebljiv odgovor: ti se nedostaci pojavljuju samo pod ljudskim okom. Protokol je jednostavan. Uzorkuj dvadeset do pedeset odgovora nasumično, nikada one slučajeve koje si već označio kao problematične, jer ćeš inače mjeriti samo vlastitu pristranost odabira. Zatim definiraj jasne, mjerljive kriterije i formaliziraj ih u standardiziranu rubriku bodovanja kako bi dva recenzenta procjenjivala istu stvar.
Na kraju, neka više ljudi provede evaluaciju i izračunaj suglasnost između ocjenjivača. Jaka neslaganja nužno ne signaliziraju loš model: najčešće otkrivaju da tvoja rubrika ostaje dvosmislena i treba pojašnjenje prije nego što možeš išta zaključiti.
Primjer rubrike za evaluaciju
| Kriterij | 1 (Loše) | 3 (Prihvatljivo) | 5 (Izvrsno) |
|---|---|---|---|
| Relevantnost | Izvan teme | Djelomično relevantno | Savršeno ciljano |
| Ton | Neprimjeren | Prihvatljivo, ali bezlično | Savršeno usklađeno |
| Format | Nije poštovan | Djelomično poštovan | Savršeno poštovan |
Izvještaj o evaluaciji
Jedan konačni refleks razlikuje evaluaciju od odluke: zabilježi obje obitelji rezultata u jedinstveni izvještaj, popraćen eksplicitnom preporukom. Prag koji postaviš – ovdje ljudski prosjek od 4 za odlazak u proizvodnju, 3 za iteraciju na podacima – mora se odabrati prije pokretanja kampanje. Ako se odluči naknadno, uvijek se prilagođava rezultatu kojem si se nadao.
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 točke
- Uvijek odvoji neovisan testni skup (ni za obuku ni za validaciju)
- Kombiniraj automatiziranu i ljudsku evaluaciju
- Evaluacija pomoću LLM-a kao suca dobar je kompromis između ta dva pristupa
- Definiraj mjerljive kriterije prije početka
- Nizak rezultat gubitka ne jamči kvalitetu za proizvodnju