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

Iteração: Quando Voltar a Ajustar o Modelo

Aula 13 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. O ajuste fino é um processo iterativo
  2. Analise os erros antes de os corrigir
  3. Reconhecer quando iterar
  4. Enriquecer em vez de começar do zero
  5. Ajuste fino contínuo e os seus limites
  6. O ciclo completo
  7. Documentar cada iteração
  8. Pontos-chave

Atualização de 2 de novembro de 2026 — Disponibilidade do ajuste fino. O serviço de ajuste fino (fine-tuning) self-service da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca executaram um trabalho de ajuste fino não podem criar um; 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 novos trabalhos. 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.

O ajuste fino é um processo iterativo

A sua primeira execução de ajuste fino raramente será perfeita. A melhoria resulta de ciclos iterativos: analise os erros, enriqueça os seus dados, volte a treinar e reavalie. Esta lição ensina-o a identificar quando e como iterar eficazmente e, tão importante quanto isso, a reconhecer situações em que o retreinamento seria inútil.

Analise os erros antes de os corrigir

O reflexo natural após uma avaliação dececionante é adicionar exemplos aleatoriamente, na esperança de que o volume resolva o problema. Essa é a forma mais rápida de queimar o seu orçamento de treino sem fazer progressos. Comece por classificar cada falha numa categoria: formatação incorreta, tom inadequado, erro factual, resposta incompleta, resposta fora de tópico ou alucinação pura. A distribuição resultante indica onde deve focar o seu esforço e, muitas vezes, revela uma surpresa: o que pensava ser um problema de estilo revela-se um problema de completude.

def analyze_errors(results: list[dict]) -> dict:
    """Categorizes errors from the fine-tuned model."""
    categories = {
        "format": [],       # Incorrect response format
        "tone": [],         # Inappropriate tone
        "factual": [],      # Incorrect information
        "incomplete": [],   # Response too short or missing elements
        "off_topic": [],    # Does not answer the question
        "hallucination": [] # Invents information
    }

    for r in results:
        if r.get("score", 5) < 3:
            # Classify the error (can be done manually or by an LLM)
            category = classify_error(r)
            categories[category].append(r)

    print("Error distribution:")
    for cat, errors in categories.items():
        if errors:
            print(f"  {cat}: {len(errors)} cases")

    return categories

De seguida, reveja os casos dentro da mesma categoria para encontrar um denominador comum. Faça a si próprio as mesmas perguntas de cada vez: o modelo falha num tipo específico de pergunta? Os erros agrupam-se em torno de certos tópicos? O problema resulta dos dados ou dos hiperparâmetros? Falhas dispersas por todos os tópicos, mas sempre da mesma natureza, indicam falta de exemplos; falhas concentradas num domínio indicam uma lacuna de cobertura; e respostas que se agarram demasiado aos seus exemplos de treino, independentemente da pergunta, sinalizam sobreajuste (overfitting) que precisa de correção no lado das épocas (epochs).

Reconhecer quando iterar

Certos sinais exigem inequivocamente uma nova versão, e cada um requer uma resposta diferente. Um modelo que alucina sobre um tópico não se corrige mostrando-lhe mais respostas corretas sobre esse tópico, mas ensinando-o a recusar educadamente quando não sabe.

SinalAção
Erros de formatação recorrentesAdicione mais exemplos com o formato correto
O modelo alucina em certos tópicosAdicione exemplos onde recusa educadamente
Sobreajuste detetadoReduza as épocas, diversifique os dados
Novos casos de uso a cobrirAdicione exemplos para estes casos
Feedback negativo direcionado dos utilizadoresTransforme o feedback em exemplos corrigidos

Pelo contrário, várias situações devem impedi-lo de retreinar. Quando os erros são raros e não sistemáticos, um ajuste no prompt resolve-os de forma mais rápida e barata. Quando as queixas dizem respeito à latência ou tempos de espera, o problema reside na sua infraestrutura e nenhum amount de treino o resolverá. Quando recolheu apenas um punhado de novos exemplos desde a última versão, o ganho esperado não cobrirá o custo da execução. E quando um novo modelo base se torna disponível, teste-o primeiro tal como está: por vezes, ele alcança por si só, sem treino, o que a sua versão anterior tinha dificuldade em entregar.

Enriquecer em vez de começar do zero

A iteração incremental significa adicionar exemplos direcionados a um conjunto de dados existente sem tocar no resto. Esta é a operação mais frequente e simples: carrega o ficheiro atual, concatena os novos casos e reescreve tudo no formato JSONL. A contagem final serve como controlo — um total que não corresponde à soma esperada indica um erro de leitura do ficheiro ou linhas perdidas.

import json

def enrich_dataset(
    existing_dataset: str,
    new_examples: list[dict],
    output: str
):
    """Adds new examples to the existing dataset."""
    # Load existing data
    with open(existing_dataset, "r") as f:
        existing = [json.loads(l) for l in f]

    # Merge
    combined = existing + new_examples

    # Save
    with open(output, "w") as f:
        for ex in combined:
            f.write(json.dumps(ex, ensure_ascii=False) + "\n")

    print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")

A iteração corretiva é ainda mais valiosa porque transforma as suas falhas em matéria-prima. Cada erro detetado em produção fornece uma pergunta real; basta escrever a resposta que gostaria de ter visto, e o par torna-se um exemplo de treino. Note que a resposta incorreta não entra no exemplo final: ajuda a documentar o caso e a decidir se a correção vale o esforço, mas o modelo aprende apenas com a versão correta.

def error_to_example(
    question: str,
    bad_response: str,
    good_response: str,
    system_msg: str
) -> dict:
    """Transforms an error into a training example."""
    return {
        "messages": [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question},
            {"role": "assistant", "content": good_response}
        ]
    }

# Transform a batch of errors
corrections = []
for error in detected_errors:
    correction = error_to_example(
        question=error["question"],
        bad_response=error["model_response"],
        good_response=error["corrected_response"],
        system_msg=SYSTEM_PROMPT
    )
    corrections.append(correction)

Ajuste fino contínuo e os seus limites

Nada o impede de fazer ajuste fino num modelo já ajustado: basta passar o seu ID completo no parâmetro model em vez do nome do modelo base. A operação é tentadora, pois treina apenas com os novos dados.

# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
    training_file=new_file.id,
    model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx",  # v1 model as base
    suffix="my-assistant-v2"
)

Aviso: o ajuste fino contínuo acumula enviesamentos. Após 2–3 iterações sucessivas, é frequentemente melhor começar de novo a partir do modelo base com um conjunto de dados completo e enriquecido. Cada camada amplifica as peculiaridades da anterior, incluindo aquelas que não pretendia, e o modelo acaba por responder com uma rigidez que ninguém lhe ensinou explicitamente.

O ciclo completo

Os passos abaixo formam o loop que repetirá para cada versão. Se abordar os erros mais frequentes primeiro, a próxima versão mostrará ganhos mensuráveis no seu conjunto de teste; abordá-los fora de ordem produz apenas uma melhoria difusa, difícil de defender perante a sua equipa.

1

Recolher erros

Identifique os casos em que o modelo falha em produção ou durante a avaliação.

2

Categorizar e priorizar

Classifique os erros por tipo e aborde primeiro os mais frequentes.

3

Criar exemplos corretivos

Transforme cada erro num exemplo de treino com a resposta correta.

4

Retreinar e reavaliar

Treine a nova versão e compare-a com a anterior no mesmo conjunto de teste.

Documentar cada iteração

Após quatro ou cinco versões, ninguém se lembra do que distinguia a v2 da v3 ou por que razão a v4 foi abandonada. Registar sistematicamente cada execução — a composição do conjunto de dados, a origem dos novos exemplos, hiperparâmetros, resultados e a decisão tomada — fornece-lhe esta informação quando uma regressão o obriga a refazer os seus passos. Preste especial atenção à origem dos novos exemplos: só isso lhe dirá, meses depois, se a degradação veio de um lote de dados mal escolhido.

iteration_log = {
    "version": "v3",
    "date": "2026-04-02",
    "base_model": "gpt-5.6-luna",
    "dataset": {
        "train": 350,
        "validation": 45,
        "new_examples": 50,
        "new_examples_source": "production errors week 12"
    },
    "hyperparameters": {
        "n_epochs": 3,
        "learning_rate_multiplier": "auto",
        "batch_size": "auto"
    },
    "results": {
        "validation_loss": 0.42,
        "precision_test": 0.91,
        "avg_csat": 4.3,
        "improvement_vs_v2": "+5% precision, +0.2 CSAT"
    },
    "decision": "Deployed to production on 2026-04-03"
}

Pontos-chave

  • O ajuste fino é iterativo — planeie múltiplos ciclos
  • Categorize os erros antes de os corrigir nos dados
  • Transforme o feedback dos utilizadores em exemplos de treino
  • Após 2–3 iterações sucessivas, recomece a partir do modelo base
  • Documente cada iteração para manter um histórico claro