Comparar com o Modelo Base
Nesta página
Atualização de 2 de novembro de 2026 — Disponibilidade do fine-tuning. O serviço de fine-tuning self-service da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca o utilizaram já não podem criar jobs; desde 2 de julho, é necessário ter utilizado um modelo com fine-tuning nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novos jobs. Os modelos já treinados permanecem utilizáveis até que o seu modelo base seja desativado. Este curso mantém a sua utilidade para compreender e aproveitar um modelo existente; para novos projetos, priorize a engenharia de prompts, RAG e avaliações.
Por que razão a comparação sistemática é importante
O fine-tuning tem um custo: tempo de preparação de dados, despesas de treino e complexidade de manutenção. Deve provar que o seu modelo com fine-tuning oferece uma melhoria mensurável em relação ao modelo base com um prompt robusto. Se a diferença for marginal, o fine-tuning pode não valer o esforço.
A tentação neste exercício é comparar o seu modelo treinado com um modelo base mal instruído. Isso resulta numa demonstração lisonjeira, mas inútil: venceu um oponente que você próprio enfraqueceu. A única comparação honesta coloca o seu modelo com fine-tuning contra a melhor utilização possível do modelo base.
Definir a linha de base
A linha de base é o modelo base com o seu melhor prompt de sistema. Otimize este prompt antes de comparar. Concretamente, isto significa escrever as regras que ensinou implicitamente por exemplo durante o fine-tuning: o papel, o tom, o comprimento esperado e como encerrar uma troca. O prompt abaixo faz exatamente isso para um assistente de suporte; note que o modelo com fine-tuning não precisa dessas instruções, pois essas regras fazem agora parte dos seus pesos.
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
Gerar respostas lado a lado
O passo seguinte é consultar ambos os modelos com exatamente as mesmas perguntas e manter as respostas emparelhadas. Escolha perguntas representativas do seu tráfego real, em vez de casos de livro: uma reclamação de entrega, um pedido de procedimento, insatisfação, um pedido de reembolso, uma pergunta factual. Estas cinco famílias fazem a diferença em produção, não a formulação perfeita.
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
)
Solicitar a um modelo terceiro que julgue
Ler cem pares à mão torna-se rapidamente desanimador, e o julgamento falha à medida que a fadiga se instala. Um modelo terceiro, que não produziu nenhuma das respostas, arbitra cada par com base em quatro critérios e emite um veredicto global. Primeiro, neutralize os rótulos: o juiz vê «Resposta A» e «Resposta B», nunca qual o modelo que as produziu; caso contrário, o seu veredicto ponderará o nome do modelo tanto quanto o texto. De seguida, trate os casos em que a saída não é analisável; caso contrário, uma única resposta mal formatada interrompe toda a campanha.
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]
Agora agregue estes veredictos num único número. A taxa de melhoria — a percentagem de pares em que o modelo com fine-tuning vence — é lida face a limiares predefinidos: acima de 60%, o ganho é claro; entre 40% e 60%, pondere o ganho face ao custo extra; abaixo disso, o seu fine-tuning não se provou, e o problema reside quase sempre nos dados.
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)
Comparar custos
A qualidade é apenas metade da decisão. O fine-tuning reduz frequentemente os tokens de entrada, uma vez que o longo prompt se torna desnecessário, mas cada token faturado num modelo com fine-tuning custa mais. Estes dois efeitos puxam em direções opostas, e apenas o cálculo decide. A função abaixo coloca-os frente a frente ao longo de um mês de tráfego: um prompt que cai de 500 para 50 tokens compensa mais do que uma taxa de entrada duplicada, mas isso não se manteria verdadeiro com um prompt base já curto.
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
)
Comparar a latência
Encurtar um prompt em várias centenas de tokens também afeta o tempo de resposta, um critério que os seus utilizadores notam muito antes da finesse tonal. Meça a latência nas mesmas perguntas utilizadas para a comparação qualitativa, fora das horas de pico, e repita a medição várias vezes: um único valor reflete maioritariamente o estado da rede no momento do teste.
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
Decidir com base nos resultados
Agora cruze qualidade e custo. Cada combinação exige uma decisão diferente, e a mais desconfortável permanece o meio-termo: quando os dois modelos são iguais, deve abandonar o trabalho já pago em vez de procurar justificações a posteriori.
| Resultado | Ação |
|---|---|
| FT vence em qualidade + custos | Implementar o modelo com fine-tuning |
| FT vence em qualidade, perde em custos | Avaliar se a qualidade justifica o custo extra |
| Resultados semelhantes | Manter o modelo base + prompt |
| Base vence | Melhorar os seus dados e tentar novamente |
Pontos-chave
- Compare sempre com um modelo base + prompt otimizado, não com um prompt básico
- Utilize o julgamento de LLM para automatizar a comparação qualitativa
- Meça custos e latência, não apenas a qualidade
- Uma taxa de melhoria de 60%+ justifica o fine-tuning
- Se o fine-tuning não proporcionar uma melhoria clara, mantenha a engenharia de prompts