Iteração: Quando Voltar a Ajustar o Modelo
Nesta página
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.
| Sinal | Ação |
|---|---|
| Erros de formatação recorrentes | Adicione mais exemplos com o formato correto |
| O modelo alucina em certos tópicos | Adicione exemplos onde recusa educadamente |
| Sobreajuste detetado | Reduza as épocas, diversifique os dados |
| Novos casos de uso a cobrir | Adicione exemplos para estes casos |
| Feedback negativo direcionado dos utilizadores | Transforme 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.
Recolher erros
Identifique os casos em que o modelo falha em produção ou durante a avaliação.
Categorizar e priorizar
Classifique os erros por tipo e aborde primeiro os mais frequentes.
Criar exemplos corretivos
Transforme cada erro num exemplo de treino com a resposta correta.
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