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

Comparație cu modelul de bază

Lecția 11 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. De ce contează comparația sistematică
  2. Definirea liniei de bază
  3. Generarea răspunsurilor alăturate
  4. Utilizarea unui model terț pentru evaluare
  5. Compararea costurilor
  6. Compararea latenței
  7. Decizia bazată pe rezultate
  8. Puncte cheie

Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning-ului. Funcționalitatea de fine-tuning self-service de la OpenAI este în curs de eliminare: începând cu 7 mai 2026, organizațiile care nu au utilizat-o niciodată nu mai pot crea job-uri; din 2 iulie, trebuie să fi utilizat un model fine-tuned î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 contează comparația sistematică

Fine-tuning-ul are un cost: timpul de pregătire a datelor, cheltuielile de antrenament și complexitatea mentenanței. Trebuie să demonstrați că modelul dumneavoastră fine-tuned oferă o îmbunătățire măsurabilă față de modelul de bază utilizat cu un prompt optimizat. Dacă diferența este marginală, efortul de fine-tuning s-ar putea să nu merite.

Tentația în acest exercițiu este să comparați modelul antrenat cu un model de bază instruit necorespunzător. Aceasta duce la o demonstrație flatantă, dar fără valoare: ați învins un adversar pe care l-ați slăbit singur. Singura comparație onestă oppose modelul dumneavoastră fine-tuned celei mai bune utilizări posibile a modelului de bază.

Definirea liniei de bază

Linia de bază este modelul de bază utilizat cu cel mai bun prompt de sistem al dumneavoastră. Optimizați acest prompt înainte de a face comparația. Concret, aceasta înseamnă să scrieți regulile pe care le-ați predat implicit prin exemple în timpul fine-tuning-ului: rolul, tonul, lungimea așteptată și modul de încheiere a unui schimb. Prompt-ul de mai jos face exact acest lucru pentru un asistent de suport; rețineți că modelul fine-tuned nu are nevoie de astfel de instrucțiuni, deoarece aceste reguli fac acum parte din ponderile sale.

from openai import OpenAI

client = OpenAI()

OPTIMIZED_SYSTEM_PROMPT = """You are a customer support assistant for TechCorp.
Rules:
- Respond professionally and empathetically
- Always propose a concrete solution
- Limit responses to 3 sentences maximum
- End with a follow-up question"""

def baseline_response(question: str) -> str:
    """Gets a response from the base model."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions=OPTIMIZED_SYSTEM_PROMPT,
        input=question
    )
    return response.output_text

def fine_tune_response(question: str, model_ft: str) -> str:
    """Gets a response from the fine-tuned model."""
    response = client.responses.create(
        model=model_ft,
        input=question
    )
    return response.output_text

Generarea răspunsurilor alăturate

Următorul pas este interogarea ambelor modele cu exact aceleași întrebări și păstrarea răspunsurilor pereche. Alegeți întrebări reprezentative pentru traficul dumneavoastră real, nu cazuri de manual: o plângere privind livrarea, o cerere de procedură, nemulțumirea, o cerere de rambursare, o întrebare factuală. Aceste cinci familii fac diferența în producție, nu formularea perfectă.

import json

def compare_models(
    questions: list[str],
    base_model: str,
    ft_model: str,
    system_prompt: str
) -> list[dict]:
    """Compares responses from two models on the same questions."""
    comparisons = []

    for q in questions:
        # Base model with optimized prompt
        r_base = client.responses.create(
            model=base_model,
            instructions=system_prompt,
            input=q
        )

        # Fine-tuned model (minimal or no prompt)
        r_ft = client.responses.create(
            model=ft_model,
            input=q
        )

        comparisons.append({
            "question": q,
            "baseline_response": r_base.output_text,
            "ft_response": r_ft.output_text
        })

    return comparisons

# Test questions
test_questions = [
    "My package hasn't arrived.",
    "How do I reset my password?",
    "Your product isn't working as expected.",
    "I would like a refund.",
    "What are your opening hours?",
]

results = compare_models(
    test_questions,
    "gpt-5.6-luna",
    "ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
    OPTIMIZED_SYSTEM_PROMPT
)

Utilizarea unui model terț pentru evaluare

Citirea a o sută de perechi manual devine rapid descurajantă, iar judecata se alterează pe măsură ce oboseala se instalează. Un model terț, care nu a generat niciunul dintre răspunsuri, arbitrează fiecare pereche pe baza a patru criterii și emite un verdict global. În primul rând, neutralizați etichetele: evaluatorul vede „Răspuns A“ și „Răspuns B“, niciodată care model le-a generat; altfel, verdictul său va cântări numele modelului la fel de mult ca textul. În al doilea rând, gestionați cazurile în care ieșirea nu poate fi analizată; altfel, un singur răspuns malformat oprește întreaga campanie.

def judge_comparison(comparison: dict) -> dict:
    """Has a third-party model judge the comparison."""
    prompt = f"""Compare these two responses to the same question.

Question: {comparison['question']}

Response A: {comparison['baseline_response']}

Response B: {comparison['ft_response']}

For each criterion, indicate which response is better (A, B, or tie):
1. Relevance of the response
2. Professionalism of tone
3. Adherence to expected format
4. Usefulness to the user

Respond in JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=prompt
    )

    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"error": "Response not parseable"}

# Judge all comparisons
judgments = [judge_comparison(c) for c in results]

Agregați acum aceste verdicte într-o singură cifră. Rata de îmbunătățire – cota de perechi în care modelul fine-tuned câștigă – se citește în raport cu praguri predefinite: peste 60%, câștigul este clar; între 40% și 60%, cântăriți câștigul față de costul suplimentar; sub acest prag, fine-tuning-ul dumneavoastră nu și-a dovedit valoarea, iar problema se află aproape întotdeauna în date.

def comparison_score(judgments: list[dict]) -> dict:
    """Calculates the overall comparison score."""
    scores = {"A_wins": 0, "B_wins": 0, "tie": 0}

    for j in judgments:
        winner = j.get("overall_winner", "tie")
        if winner == "A":
            scores["A_wins"] += 1
        elif winner == "B":
            scores["B_wins"] += 1
        else:
            scores["tie"] += 1

    total = len(judgments)
    print(f"Base model wins: {scores['A_wins']}/{total}")
    print(f"Fine-tuned model wins: {scores['B_wins']}/{total}")
    print(f"Tie: {scores['tie']}/{total}")

    improvement_rate = scores["B_wins"] / total * 100
    print(f"\nImprovement rate: {improvement_rate:.1f}%")

    if improvement_rate >= 60:
        print("Fine-tuning provides a significant improvement.")
    elif improvement_rate >= 40:
        print("Modest improvement—check if the cost is justified.")
    else:
        print("Fine-tuning does not provide a clear improvement.")

    return scores

comparison_score(judgments)

Compararea costurilor

Calitatea reprezintă doar jumătate din decizie. Fine-tuning-ul reduce adesea token-ii de intrare, deoarece prompt-ul lung devine inutil, dar fiecare token facturat pe un model fine-tuned costă mai mult. Aceste două efecte trag în direcții opuse, iar doar calculul decide. Funcția de mai jos le oppose una alteia pe parcursul unei luni de trafic: un prompt care scade de la 500 la 50 de tokeni compensează mai mult decât o rată de intrare dublată, dar acest lucru nu ar fi valabil cu un prompt de bază deja scurt.

def compare_costs(
    requests_per_day: int,
    base_prompt_tokens: int,
    ft_prompt_tokens: int,
    avg_output_tokens: int,
    base_input_price: float,
    ft_input_price: float,
    output_price: float
):
    """Compares monthly costs between base and fine-tuned models."""
    days = 30

    base_cost = days * requests_per_day * (
        base_prompt_tokens * base_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    ft_cost = days * requests_per_day * (
        ft_prompt_tokens * ft_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    savings = base_cost - ft_cost
    print(f"Monthly base cost: ${base_cost:.2f}")
    print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
    print(f"Monthly savings: ${savings:.2f}")

# Example
compare_costs(
    requests_per_day=1000,
    base_prompt_tokens=500,   # long prompt with instructions
    ft_prompt_tokens=50,       # short prompt, behavior is integrated
    avg_output_tokens=200,
    base_input_price=0.15,
    ft_input_price=0.30,        # fine-tuned costs more per token
    output_price=0.60
)

Compararea latenței

Scurtarea unui prompt cu câteva sute de tokeni afectează, de asemenea, timpul de răspuns, un criteriu pe care utilizatorii dumneavoastră îl observă cu mult înainte de finețea tonală. Măsurați latența pe aceleași întrebări utilizate pentru comparația calitativă, în afara orelor de vârf, și repetați măsurătoarea de mai multe ori: o singură valoare reflectă în mare parte starea rețelei la momentul testului.

import time

def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
    """Measures the average latency of a model."""
    latencies = []
    for q in questions:
        start = time.time()
        kwargs = {"model": model, "input": q}
        if prompt:
            kwargs["instructions"] = prompt
        client.responses.create(**kwargs)
        latencies.append(time.time() - start)

    avg = sum(latencies) / len(latencies)
    print(f"{model} — Average latency: {avg:.2f}s")
    return avg

Decizia bazată pe rezultate

Corelați acum calitatea și costul. Fiecare combinație necesită o decizie diferită, iar cea mai incomodă rămâne terenul de mijloc: când cele două modele sunt egale, trebuie să abandonați munca deja plătită, mai degrabă decât să căutați o justificare post-factum.

RezultatAcțiune
FT câștigă la calitate + costuriImplementați modelul fine-tuned
FT câștigă la calitate, pierde la costuriEvaluați dacă calitatea justifică costul suplimentar
Rezultate similareRămâneți la modelul de bază + prompt
Modelul de bază câștigăÎmbunătățiți datele și reîncercați

Puncte cheie

  • Comparați întotdeauna cu un model de bază + prompt optimizat, nu cu un prompt de bază
  • Utilizați evaluarea prin LLM pentru a automatiza comparația calitativă
  • Măsurați costurile și latența, nu doar calitatea
  • O rată de îmbunătățire de peste 60% justifică fine-tuning-ul
  • Dacă fine-tuning-ul nu oferă o îmbunătățire clară, rămâneți la ingineria prompt-urilor