Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Avaliar o Seu Modelo Ajustado

Aula 10 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Por Que a Avaliação É Essencial
  2. Construir um Conjunto de Teste
  3. Avaliação Automatizada
  4. Métricas Especializadas
  5. Avaliação Humana
  6. Relatório de Avaliação
  7. Pontos-chave

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