Comparație cu modelul de bază
Pe această pagină
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.
| Rezultat | Acțiune |
|---|---|
| FT câștigă la calitate + costuri | Implementați modelul fine-tuned |
| FT câștigă la calitate, pierde la costuri | Evaluați dacă calitatea justifică costul suplimentar |
| Rezultate similare | Ră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