Salt la conținutul principal
Română— Alege o limbă
Meniu

Evaluarea modelului dumneavoastră fine-tunat

Lecția 10 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. De ce este esențială evaluarea
  2. Construirea unui set de test
  3. Evaluarea automată
  4. Metrici specializate
  5. Evaluarea umană
  6. Raportul de evaluare
  7. Puncte cheie

Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning-ului. Serviciul de fine-tuning self-service oferit de OpenAI este în curs de eliminare: începând cu 7 mai 2026, organizațiile care nu l-au utilizat niciodată nu mai pot crea job-uri; începând cu 2 iulie, trebuie să fi utilizat un model fine-tunat în ultimele 60 de zile; iar începând cu 6 ianuarie 2027, niciun client nu va mai putea lansa job-uri noi. Modelele deja antrenate rămân utilizabile până la retragerea modelului lor de bază. Acest curs rămâne util pentru înțelegerea și exploatarea unui model existent; pentru proiecte noi, prioritizați ingineria prompt-urilor, RAG și evaluările.

De ce este esențială evaluarea

Un fine-tuning reușit nu se măsoară doar prin pierdere (loss). Întrebarea reală este: este modelul dumneavoastră fine-tunat realmente mai bun decât modelul de bază pentru cazul dumneavoastră de utilizare? O curbă în descrescere clară dovedește doar că modelul a învățat să reproducă exemplele dumneavoastră; ea nu spune nimic despre comportamentul său în fața unor cereri nevăzute. Această lecție vă arată cum să construiți un protocol de evaluare riguros, combinând metrici automate, judecata unui LLM și revizuirea umană.

Construirea unui set de test

Setul dumneavoastră de test trebuie să fie separat atât de datele de antrenament, cât și de cele de validare. Distincția contează: setul de validare monitorizează antrenamentul și, prin urmare, influențează deciziile privind hiperparametrii, ceea ce îl contaminează treptat. Setul de test, dimpotrivă, este deschis doar după ce modelul este înghețat. El reprezintă situațiile din lumea reală pe care modelul le va întâlni în producție, cu aceleași proporții de cazuri simple și complexe. O împărțire de 80/10/10 pe un corpus amestecat anterior este un punct de plecare rezonabil.

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

Evaluarea automată

Evaluarea bazată pe metrici

Principiul este simplu: pentru fiecare exemplu din setul de test, eliminați mesajul asistentului – aceasta fiind răspunsul așteptat, pe care modelul nu trebuie să îl vadă – submitteți restul și păstrați input-ul, răspunsul de referință și răspunsul generat unul lângă altul. Această structură cu trei coloane stă la baza a tot ce urmează; utilizarea ei pentru calculul metricilor sau pentru judecata calitativă este doar o chestiune de procesare ulterioară.

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

Evaluarea de tip „LLM-as-a-Judge“

O tehnică puternică este utilizarea unui model performant pentru a judeca calitatea răspunsurilor. Comparația cuvânt cu cuvânt cu referința devine inutilizabilă imediat ce sunt acceptabile mai multe formulări; un judecător, însă, apreciază fondul. Calitatea verdictului său depinde în întregime de precizia prompt-ului: patru criterii notate de la 1 la 5, un output JSON forțat și un comentariu în text liber pe care îl veți folosi ulterior pentru a înțelege eșecurile. Planificați cazurile în care output-ul nu poate fi parsat, în loc să permiteți unei excepții să întrerupă campania.

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

Metrici specializate

Cele două abordări anterioare funcționează bine pentru răspunsurile scrise. De îndată ce output-ul modelului dumneavoastră are o structură fixă, devin posibile măsuri mai directe, care vă scutesc de ocolul prin intermediul unui judecător.

Pentru clasificare

Când output-ul așteptat aparține unui set închis – o categorie de tichet, un sentiment, un cod de produs – potrivirea exactă devine din nou relevantă. Normalizați majusculele și spațiile înainte de comparare; altfel, „Urgent“ față de „urgent“ va fi contorizat ca o eroare și vă va distorsiona rata.

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}

Pentru apelarea de funcții (Function Calling)

Apelarea de funcții se judecă pe două axe care trebuie măsurate separat. Un model care alege funcția corectă, dar greșește parametrul, eșuează diferit față de unul care apelează instrumentul complet greșit: prima problemă se rezolvă prin exemple de extracție, a doua prin exemple de discriminare. Un singur scor global ar masca această distincție și v-ar lăsa să lucrați în orb.

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

Evaluarea umană

Evaluarea automată nu surprinde totul. Un ton ușor condescendent, o frază care nu rezonează cu clienții dumneavoastră, un răspuns corect tehnic dar inutilizabil: aceste defecte apar doar sub ochiul uman. Protocolul este simplu. Eșantionați aleatoriu douăzeci până la cincizeci de răspunsuri, niciodată cazurile pe care le-ați semnalat deja ca problematice, sau veți măsura doar propria bias de selecție. Apoi definiți criterii clare, măsurabile și formalizați-le într-o grilă de scor standardizată, astfel încât doi evaluatori să judece același lucru.

În final, solicitați mai multor persoane să evalueze și calculați acordul inter-evaluatori. Un dezacord puternic nu semnalează neapărat un model prost: cel mai adesea, el relevă faptul că grila dumneavoastră rămâne ambiguă și are nevoie de clarificare înainte de a putea trage orice concluzie.

Exemplu de grilă de evaluare

Criteriu 1 (Slab) 3 (Acceptabil) 5 (Excelent)
Relevanță Fără legătură cu subiectul Parțial relevant Perfect țintit
Ton Inadecvat Acceptabil dar banal Perfect aliniat
Format Nerespectat Parțial respectat Perfect respectat

Raportul de evaluare

Un ultim reflex separă o simplă evaluare de o decizie: înregistrați ambele familii de rezultate într-un singur raport, însoțit de o recomandare explicită. Pragul pe care îl stabiliți – aici o medie umană de 4 pentru a merge în producție, 3 pentru a itera asupra datelor – trebuie ales înainte de lansarea campaniei. Decis ulterior, el se va ajusta mereu la rezultatul pe care sperați să îl obțineți.

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

Puncte cheie

  • Separați întotdeauna un set de test independent (nici antrenament, nici validare)
  • Combinați evaluarea automată cu cea umană
  • Evaluarea de tip „LLM-as-a-judge“ este un bun compromis între cele două
  • Definiți criterii măsurabile înainte de a începe
  • Un scor de pierdere (loss) scăzut nu garantează calitatea pentru producție