Премини към основното съдържание
Български— Изберете език
Меню

Сравнение с базовия модел

Урок 11 от 16 Обновен 2 ноември 2026 г. Напреднало
На тази страница
  1. Защо системното сравнение е важно
  2. Дефиниране на базовата линия
  3. Генериране на отговори рамо до рамо
  4. Използване на трети модел за оценка
  5. Сравнение на разходите
  6. Сравнение на латентността
  7. Вземане на решение въз основа на резултатите
  8. Ключови изводи

Актуализация от 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%+ оправдава фина настройката
  • Ако фина настройката не осигурява ясно подобрение, придържайте се към инженерството на подкани