Сравнение с базовия модел
На тази страница
Актуализация от 2 ноември 2026 г. — Наличност на фина настройка. Собствената услуга за фина настройка на OpenAI се преустановява постепенно: към 7 май 2026 г. организациите, които никога не са я използвали, вече не могат да създават задачи; от 2 юли трябва да сте използвали фина настроен модел през последните 60 дни; а считано от 6 януари 2027 г. никой клиент няма да може да стартира нови задачи. Вече обучените модели остават използваеми до оттеглянето на техния базов модел. Този курс остава полезен за разбиране и използване на съществуващ модел; за нови проекти дайте приоритет на инженерството на подкани (prompt engineering), RAG и оценките.
Защо системното сравнение е важно
Фина настройката има цена: време за подготовка на данни, разходи за обучение и сложност на поддръжката. Трябва да докажете, че вашият фина настроен модел осигурява измеримо подобрение спрямо базовия модел с добра подкана. Ако разликата е незначителна, фина настройката може да не си струва усилието.
Изкушението при това упражнение е да сравните вашия обучен модел с лошо инструктиран базов модел. Това води до ласкава, но безполезна демонстрация: сте победили противник, когото сами сте отслабили. Единственото честно сравнение противопоставя вашия фина настроен модел на най-доброто възможно използване на базовия модел.
Дефиниране на базовата линия
Базовата линия е базовият модел с вашата най-добра системна подкана. Оптимизирайте тази подкана, преди да правите сравнението. Конкретно това означава да запишете правилата, които имплицитно сте преподали чрез примери по време на фина настройката: ролята, тона, очакваната дължина и начина на приключване на размяната. Подканата по-долу прави точно това за асистент за поддръжка; имайте предвид, че фина настройкият модел не се нуждае от такива инструкции, тъй като тези правила вече са част от неговите тегла.
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
Генериране на отговори рамо до рамо
Следващата стъпка е да заявите и двата модела с абсолютно същите въпроси и да запазите сдвоените отговори. Изберете въпроси, които са представителни за реалния ви трафик, а не учебни случаи: оплакване относно доставка, заявка за процедура, недоволство, искане за възстановяване на средства, фактологичен въпрос. Тези пет категории правят разликата в продукцията, а не перфектното формулиране.
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
)
Използване на трети модел за оценка
Четенето на сто двойки на ръка бързо става обезкуражаващо, а преценката се размива с настъпването на умората. Трети модел, който не е генерирал нито един от отговорите, арбитраж всяка двойка по четири критерия и издава глобална присъда. Първо, неутрализирайте етикетите: съдията вижда „Отговор А“ и „Отговор Б“, никога кой модел ги е произвел, в противен случай присъдата му ще тежи името на модела толкова, колкото и текста. След това обработете случаите, когато изходът не може да се анализира; в противен случай един единствен malformed отговор спира цялата кампания.
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]
Сега агрегирайте тези присъди в една единствена цифра. Нивото на подобрение – делът на двойките, при които фина настройкият модел печели – се сравнява с предварително дефинирани прагове: над 60% печалбата е ясна; между 40% и 60% претеглете печалбата спрямо допълнителните разходи; под това вашата фина настройка не се е доказала и проблемът почти винаги е в данните.
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)
Сравнение на разходите
Качеството е само половината от решението. Фина настройката често намалява входните токени, тъй като дългата подкана става ненужна, но всеки таксуван токен при фина настроен модел струва повече. Тези два ефекта дърпат в противоположни посоки и само изчислението решава. Функцията по-долу ги противопоставя за един месец трафик: подкана, намаляваща от 500 на 50 токена, повече от компенсира удвоената входна тарифа, но това няма да е вярно при вече кратка базова подкана.
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
)
Сравнение на латентността
Съкращаването на подканата с няколкостотин токена също влияе на времето за отговор, критерий, който вашите потребители забелязват много преди тоналната финес. Измерете латентността върху същите въпроси, използвани за качественото сравнение, извън пиковите часове и повторете измерването няколко пъти: една единствена стойност отразява предимно състоянието на мрежата по време на теста.
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
Вземане на решение въз основа на резултатите
Сега кръстосайте качеството и разходите. Всяка комбинация изисква различно решение, а най-неудобната остава средният път: когато двата модела са равни, трябва да изоставите вече платена работа, вместо да търсите оправдание постфактум.
| Резултат | Действие |
|---|---|
| FT печели по качество + разходи | Разполагане на фина настройкия модел |
| FT печели по качество, губи по разходи | Оценка дали качеството оправдава допълнителните разходи |
| Подобни резултати | Придържане към базов модел + подкана |
| Базовият печели | Подобрете данните си и опитайте отново |
Ключови изводи
- Винаги сравнявайте с базов модел + оптимизирана подкана, а не с основна подкана
- Използвайте преценка от LLM, за да автоматизирате качественото сравнение
- Измервайте разходите и латентността, а не само качеството
- Ниво на подобрение от 60%+ оправдава фина настройката
- Ако фина настройката не осигурява ясно подобрение, придържайте се към инженерството на подкани