Porównanie z modelem bazowym
Na tej stronie
Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy z niej nie korzystały, nie mogą już tworzyć nowych zadań; od 2 lipca musisz użyć dostrajonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchomić nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal jest przydatny do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetowo potraktuj inżynierię promptów, RAG oraz ewaluacje.
Dlaczego systematyczne porównanie ma znaczenie
Dostrajanie niesie ze sobą koszty: czas na przygotowanie danych, wydatki na trening oraz złożoność utrzymania. Musisz udowodnić, że Twój dostrajony model zapewnia mierzalną poprawę w porównaniu do modelu bazowego wyposażonego w solidny prompt. Jeśli różnica jest marginalna, dostrajanie może nie być warte wysiłku.
Pokusą w tym ćwiczeniu jest porównanie wytrenowanego modelu z modelem bazowym, któremu wydano słabe instrukcje. To prowadzi do pochlebnej, lecz bezwartościowej demonstracji: pokonałeś przeciwnika, którego sam osłabiłeś. Jedynym uczciwym porównaniem jest zestawienie Twojego dostrajonego modelu z najlepszym możliwym wykorzystaniem modelu bazowego.
Zdefiniuj punkt odniesienia
Punktem odniesienia jest model bazowy z Twoim najlepszym promptem systemowym. Zoptymalizuj ten prompt przed porównaniem. Konkretnie oznacza to spisanie zasad, których неяwnie nauczyłeś model na przykładach podczas dostrajania: roli, tonu, oczekiwanej długości odpowiedzi oraz sposobu kończenia rozmowy. Poniższy prompt robi dokładnie to dla asystenta wsparcia; zauważ, że dostrajony model nie potrzebuje takich instrukcji, ponieważ zasady te są już częścią jego wag.
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
Generuj odpowiedzi obok siebie
Kolejnym krokiem jest zapytanie obu modeli o dokładnie te same pytania i zachowanie sparowanych odpowiedzi. Wybierz pytania reprezentatywne dla Twojego rzeczywistego ruchu, a nie przypadki książkowe: reklamacja dotycząca dostawy, prośba o procedurę, wyrażenie niezadowolenia, żądanie zwrotu pieniędzy, pytanie faktograficzne. Te pięć kategorii robi różnicę w środowisku produkcyjnym, a nie idealne sformułowania.
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
)
Powierz ocenę modelowi trzeciej strony
Ręczne czytanie setek par szybko staje się zniechęcające, a osąd słabnie wraz z narastającym zmęczeniem. Model trzeciej strony, który nie wygenerował żadnej z odpowiedzi, arbitruje każdą parę według czterech kryteriów i wydaje globalny werdykt. Najpierw zneutralizuj etykiety: sędzia widzi „Odpowiedź A“ i „Odpowiedź B“, nigdy nie wie, który model je wygenerował, w przeciwnym razie jego werdykt będzie obciążony nazwą modelu tak samo jak treścią. Następnie obsłuż przypadki, w których wynik nie daje się przetworzyć; w przeciwnym razie jedna błędna odpowiedź zatrzyma całą kampanię.
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]
Teraz zagreguj te werdykty w jedną liczbę. Wskaźnik poprawy – udział par, w których wygrywa model dostrajany – odczytuj względem zdefiniowanych progów: powyżej 60% zysk jest wyraźny; między 40% a 60% zważ zysk przeciwko dodatkowemu kosztowi; poniżej tej wartości Twoje dostrajanie nie udowodniło swojej wartości, a problem prawie zawsze leży w danych.
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)
Porównaj koszty
Jakość to tylko połowa decyzji. Dostrajanie często redukuje liczbę tokenów wejściowych, ponieważ długi prompt staje się zbędny, ale każdy token rozliczany w modelu dostrajonym kosztuje więcej. Te dwa efekty działają w przeciwnych kierunkach i tylko kalkulacja rozstrzyga sprawę. Poniższa funkcja zestawia je ze sobą w kontekście miesięcznego ruchu: zmniejszenie promptu z 500 do 50 tokenów więcej niż rekompensuje podwojoną stawkę za wejście, ale nie byłoby to prawdą w przypadku już krótkiego promptu bazowego.
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
)
Porównaj opóźnienia
Skrócenie promptu o kilkaset tokenów wpływa również na czas odpowiedzi, co jest kryterium, które Twoi użytkownicy zauważają znacznie wcześniej niż finezję tonu. Zmierz opóźnienia na tych samych pytaniach użytych do porównania jakościowego, poza godzinami szczytu, i powtórz pomiar kilka razy: pojedyncza wartość odzwierciedla głównie stan sieci w momencie testu.
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
Podejmij decyzję na podstawie wyników
Teraz skrzyżuj jakość z kosztami. Każda kombinacja wymaga innej decyzji, a najbardziej niewygodna pozostaje sytuacja pośrednia: gdy oba modele są równe, musisz porzucić już opłaconą pracę, zamiast szukać dla niej uzasadnienia post factum.
| Wynik | Działanie |
|---|---|
| FT wygrywa pod względem jakości i kosztów | Wdróż model dostrajany |
| FT wygrywa pod względem jakości, przegrywa pod względem kosztów | Oceń, czy jakość uzasadnia dodatkowy koszt |
| Podobne wyniki | Pozostań przy modelu bazowym + prompt |
| Model bazowy wygrywa | Ulepsz swoje dane i spróbuj ponownie |
Kluczowe wnioski
- Zawsze porównuj z modelem bazowym + zoptymalizowanym promptem, a nie z podstawowym promptem
- Wykorzystaj ocenę przez LLM do automatyzacji porównania jakościowego
- Mierz koszty i opóźnienia, a nie tylko jakość
- Wskaźnik poprawy powyżej 60% uzasadnia dostrajanie
- Jeśli dostrajanie nie przynosi wyraźnej poprawy, pozostań przy inżynierii promptów