Avaliar o Seu Modelo Ajustado
Nesta página
Atualização de 2 de novembro de 2026 — Disponibilidade do ajuste fino. O serviço de ajuste fino 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 tarefas; desde 2 de julho, é necessário ter utilizado um modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novas tarefas. 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, a RAG e as avaliações.
Por Que a Avaliação É Essencial
Um ajuste fino bem-sucedido não se mede apenas pela perda (loss). A verdadeira questão é: o seu modelo ajustado é realmente melhor do que o modelo base para o seu caso de uso? Uma curva em descida limpa apenas prova que o modelo aprendeu a reproduzir os seus exemplos; nada diz sobre o seu comportamento perante pedidos não vistos. Esta lição mostra-lhe como construir um protocolo de avaliação rigoroso, combinando métricas automatizadas, julgamento por LLM e revisão humana.
Construir um Conjunto de Teste
O seu conjunto de teste deve ser separado tanto dos dados de treino como de validação. A distinção é importante: o conjunto de validação monitoriza o treino e, portanto, influencia as suas decisões de hiperparâmetros, o que gradualmente o contamina. O conjunto de teste, pelo contrário, só é aberto quando o modelo está congelado. Representa as situações do mundo real que o seu modelo encontrará em produção, com as mesmas proporções de casos simples e complexos. Uma divisão 80/10/10 num corpus previamente embaralhado é um ponto de partida razoável.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Divide os dados em treino/validação/teste."""
with open(file, "r") as f:
examples = [json.loads(l) for l in f]
random.shuffle(examples)
n = len(examples)
i1 = int(n * ratios[0])
i2 = int(n * (ratios[0] + ratios[1]))
datasets = {
"train": examples[:i1],
"validation": examples[i1:i2],
"test": examples[i2:]
}
for name, data in datasets.items():
with open(f"{name}.jsonl", "w") as f:
for ex in data:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"{name}: {len(data)} exemplos")
return datasets
prepare_datasets("all_data.jsonl")
Avaliação Automatizada
Avaliação Baseada em Métricas
O princípio é simples: para cada exemplo de teste, remova a mensagem do assistente — essa é a resposta esperada, que o modelo não deve ver —, submeta o restante e mantenha a entrada, a resposta de referência e a resposta gerada lado a lado. Esta estrutura de três colunas é a base de tudo o que se segue; utilizá-la para cálculo de métricas ou julgamento qualitativo é apenas uma questão de processamento posterior.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Avalia um modelo num conjunto de teste."""
results = []
for ex in test_examples:
# Extrai a pergunta (sem a resposta esperada)
input_messages = [
m for m in ex["messages"] if m["role"] != "assistant"
]
expected_answer = next(
m["content"] for m in ex["messages"] if m["role"] == "assistant"
)
# Obtém a resposta do modelo
response = client.responses.create(
model=model,
input=input_messages
)
model_answer = response.output_text
results.append({
"input": input_messages[-1]["content"],
"expected": expected_answer,
"obtained": model_answer
})
return results
Avaliação com LLM como Juiz
Uma técnica poderosa é utilizar um modelo de alto desempenho para julgar a qualidade da resposta. A comparação palavra por palavra com a referência torna-se inútil assim que múltiplas formulações são aceitáveis; um juiz, no entanto, aprecia o conteúdo. A qualidade do seu veredito depende inteiramente da precisão do prompt: quatro critérios classificados de 1 a 5, uma saída JSON forçada e um comentário em texto livre que utilizará mais tarde para compreender as falhas. Preveja casos em que a saída não seja analisável, em vez de deixar que uma exceção interrompa a campanha.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Utiliza o gpt-5.6-sol como juiz para avaliar respostas."""
evaluations = []
for r in results:
judge_prompt = f"""Avalie a qualidade da resposta obtida em comparação com a resposta esperada.
Pergunta: {r['input']}
Resposta esperada: {r['expected']}
Resposta obtida: {r['obtained']}
Critérios (classifique cada um de 1 a 5):
1. Precisão: A informação está correta?
2. Completude: Todos os pontos importantes foram cobertos?
3. Estilo: O tom e o formato são adequados?
4. Concisão: A resposta tem um comprimento apropriado?
Responda em JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=judge_prompt
)
try:
evaluation = json.loads(response.output_text)
evaluations.append(evaluation)
except json.JSONDecodeError:
evaluations.append({"error": "Resposta não analisável"})
return evaluations
Métricas Especializadas
As duas abordagens anteriores funcionam bem para respostas escritas. Assim que a saída do seu modelo tiver uma estrutura fixa, tornam-se possíveis medidas mais diretas, poupando-lhe o desvio por um juiz.
Para Classificação
Quando a saída esperada pertence a um conjunto fechado — uma categoria de ticket, um sentimento, um código de produto — a correspondência exata torna-se novamente relevante. Normalize maiúsculas/minúsculas e espaços antes de comparar; caso contrário, “Urgente” versus “urgente” contará como um erro e distorcerá a sua taxa.
def classification_metrics(results: list[dict]) -> dict:
"""Calcula precisão, recall e F1 para uma tarefa de classificação."""
correct = sum(
1 for r in results
if r["expected"].strip().lower() == r["obtained"].strip().lower()
)
total = len(results)
precision = correct / total if total > 0 else 0
print(f"Precisão: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
Para Chamada de Funções
A chamada de funções é julgada em dois eixos que devem ser medidos separadamente. Um modelo que escolhe a função certa mas erra o parâmetro falha de forma diferente de um que chama a ferramenta completamente errada: o primeiro problema resolve-se com exemplos de extração, o segundo com exemplos de discriminação. Uma pontuação global única mascararia esta distinção e deixá-lo-ia a trabalhar às cegas.
def function_calling_metrics(results: list[dict]) -> dict:
"""Avalia a qualidade das chamadas de funções."""
stats = {"correct_function": 0, "correct_params": 0, "total": 0}
for r in results:
stats["total"] += 1
if r.get("expected_function") == r.get("obtained_function"):
stats["correct_function"] += 1
if r.get("expected_params") == r.get("obtained_params"):
stats["correct_params"] += 1
print(f"Função correta: {stats['correct_function']}/{stats['total']}")
print(f"Parâmetros corretos: {stats['correct_params']}/{stats['total']}")
return stats
Avaliação Humana
A avaliação automatizada não capta tudo. Um tom ligeiramente condescendente, uma frase que não agrada aos seus clientes, uma resposta tecnicamente correta mas inutilizável: estas falhas só aparecem sob o olhar humano. O protocolo é direto. Amostre vinte a cinquenta respostas aleatoriamente, nunca os casos que já assinalou como problemáticos, ou estará apenas a medir o seu próprio viés de seleção. Em seguida, defina critérios claros e mensuráveis e formalize-os numa grelha de pontuação padronizada, para que dois avaliadores julguem a mesma coisa.
Por fim, faça com que várias pessoas avaliem e calcule a concordância entre avaliadores. Uma forte discordância não sinaliza necessariamente um mau modelo: na maioria das vezes, revela que a sua grelha permanece ambígua e precisa de clarificação antes de poder concluir qualquer coisa.
Exemplo de Grelha de Avaliação
| Critério | 1 (Fraco) | 3 (Aceitável) | 5 (Excelente) |
|---|---|---|---|
| Relevância | Fora do tema | Parcialmente relevante | Perfeitamente direcionado |
| Tom | Inadequado | Aceitável mas simples | Perfeitamente alinhado |
| Formato | Não seguido | Parcialmente seguido | Perfeitamente seguido |
Relatório de Avaliação
Um último reflexo separa uma avaliação de uma decisão: registe ambas as famílias de resultados num único relatório, acompanhado de uma recomendação explícita. O limiar que definir — aqui uma média humana de 4 para ir para produção, 3 para iterar sobre os dados — deve ser escolhido antes de lançar a campanha. Decidido depois, ajusta-se sempre ao resultado que esperava.
def evaluation_report(auto_results: dict, human_results: dict):
"""Gera um relatório de avaliação combinado."""
print("=" * 60)
print("RELATÓRIO DE AVALIAÇÃO DO MODELO AJUSTADO")
print("=" * 60)
print(f"\nMétricas automatizadas:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nAvaliação humana:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nRecomendação:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" O modelo está pronto para produção")
elif average_score >= 3:
print(" São necessárias melhorias — itere sobre os dados")
else:
print(" Resultados insuficientes — repense a sua abordagem")
Pontos-chave
- Separe sempre um conjunto de teste independente (nem treino, nem validação)
- Combine avaliação automatizada e humana
- A avaliação com LLM como juiz é um bom compromisso entre as duas
- Defina critérios mensuráveis antes de começar
- Uma pontuação de perda baixa não garante qualidade de produção