Monitorização do Treino
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 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, RAG e avaliações.
Por Que Monitorizar o Treino
Lançar uma tarefa de fine-tuning e esquecê-la deixa-o com um facto consumado: uma hora depois, descobre um modelo sem saber o que aconteceu entretanto. Ao observar as métricas enquanto o treino decorre, deteta problemas cedo, decide ajustar hiperparâmetros antes de queimar todo o seu orçamento e, acima de tudo, compreende por que razão uma execução superou outra. A monitorização transforma uma série de tentativas numa disciplina de engenharia.
As Duas Métricas a Ler
A perda de treino (training loss) mede o quanto o modelo erra nos dados de treino — exatamente os dados que está a ingerir no momento. Deve diminuir ao longo das etapas: esse é o sinal de que a aprendizagem está a ocorrer. Uma perda que estagna ou volta a subir indica um problema, geralmente uma taxa de aprendizagem mal calibrada ou um corpus demasiado heterogéneo.
A perda de validação (validation loss) mede o desempenho em dados que o modelo nunca viu durante o treino — o ficheiro que separou durante a divisão. Esta é a métrica mais fiável para avaliar a qualidade real do seu modelo, porque é a única que o modelo não consegue melhorar através da memorização. É a evolução conjunta de ambas que fornece o diagnóstico.
| Perda de treino | Perda de validação | Diagnóstico |
|---|---|---|
| Diminui | Diminui | Tudo bem, continue |
| Diminui | Aumenta | Sobreajuste — reduza as épocas |
| Estagna | Estagna | Subajuste — aumente a taxa de aprendizagem |
| Oscila | Oscila | Instabilidade — reduza a taxa de aprendizagem |
A segunda linha é a que custa mais caro em produção: uma perda de treino que continua a diminuir enquanto a perda de validação sobe descreve um modelo a memorizar os seus exemplos de cor. No papel, tudo parece estar a melhorar; na realidade, cada etapa adicional degrada a sua capacidade de responder a uma pergunta que nunca viu.
Rastrear Eventos via API
A API não envia notificações push: tem de consultar a tarefa em intervalos regulares. O ciclo abaixo busca novos eventos, exibe-os por ordem cronológica evitando mostrar novamente os já vistos e devolve o controlo assim que a tarefa atinge um estado terminal.
from openai import OpenAI
import time
client = OpenAI()
def monitor_job(job_id: str):
"""Monitors a job in real time."""
last_event = None
while True:
job = client.fine_tuning.jobs.retrieve(job_id)
# Fetch new events
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job_id,
limit=50
)
for event in reversed(events.data):
if last_event and event.id == last_event:
continue
print(f"[{event.created_at}] {event.message}")
if events.data:
last_event = events.data[0].id
if job.status in ("succeeded", "failed", "cancelled"):
print(f"\nJob finished: {job.status}")
if job.status == "succeeded":
print(f"Model: {job.fine_tuned_model}")
return job
time.sleep(30)
# Usage
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")
Os eventos não contêm apenas mensagens de texto: também carregam valores de perda em cada etapa. Extraí-los permite-lhe traçar uma curva em vez de ler linhas de registo, e é numa curva que deteta um pico na perda de validação num instante.
def extract_metrics(job_id: str) -> dict:
"""Extracts loss metrics from a completed job."""
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job_id,
limit=200
)
training_losses = []
validation_losses = []
for event in events.data:
data = event.data
if data and "train_loss" in str(data):
training_losses.append(data)
if data and "valid_loss" in str(data):
validation_losses.append(data)
return {
"training": training_losses,
"validation": validation_losses
}
Checkpoints e Resultados Intermédios
A OpenAI guarda checkpoints durante o treino. Se a tarefa falhar ou se a cancelar, por vezes consegue recuperar um checkpoint intermédio utilizável — ou seja, uma execução interrompida não é necessariamente uma execução perdida. Este é também um recurso valioso em caso de sobreajuste tardio: o checkpoint tirado antes do pico na perda de validação pode ser melhor do que o modelo final.
# List checkpoints for a job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id=job.id
)
for cp in checkpoints.data:
print(f"Step {cp.step_number}")
print(f" Model: {cp.fine_tuned_model_checkpoint}")
if cp.metrics:
print(f" Training loss: {cp.metrics.train_loss:.4f}")
if hasattr(cp.metrics, "valid_loss"):
print(f" Validation loss: {cp.metrics.valid_loss:.4f}")
Saber Quando Parar
Três sinais justificam a interrupção de uma execução de treino em curso. O primeiro é uma perda de validação que tem subido durante várias etapas, não apenas uma: um valor isolado é ruído, uma tendência ao longo de cinco pontos é sobreajuste. O segundo é uma perda de treino próxima de zero, o que significa que o modelo está a reproduzir os seus exemplos textualmente e não tem mais nada a aprender com eles. O terceiro é mais prosaico: os seus testes não melhoram de um checkpoint para o outro e cada etapa adicional apenas aumenta a fatura.
# If you detect a problem, cancel the job
client.fine_tuning.jobs.cancel(job.id)
print("Job cancelled. Adjust your data or hyperparameters and relaunch.")
Um Relatório Resumido por Execução
Termine cada sessão de treino produzindo um registo acionável. A função seguinte reúne numa única saída o ID da tarefa, o modelo base, as épocas utilizadas, o número de tokens treinados e as métricas do último checkpoint. Cole estes relatórios no seu registo de execuções: daqui a um mês, dir-lhe-ão por que razão manteve esta versão em vez de outra.
def job_report(job_id: str):
"""Generates a summary report for the job."""
job = client.fine_tuning.jobs.retrieve(job_id)
print("=" * 50)
print(f"Job: {job.id}")
print(f"Base model: {job.model}")
print(f"Status: {job.status}")
print(f"Epochs: {job.hyperparameters.n_epochs}")
if job.status == "succeeded":
print(f"Fine-tuned model: {job.fine_tuned_model}")
print(f"Trained tokens: {job.trained_tokens}")
if job.status == "failed":
print(f"Error: {job.error}")
# Checkpoints
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id=job_id
)
if checkpoints.data:
latest = checkpoints.data[0]
print(f"Latest checkpoint: step {latest.step_number}")
if latest.metrics:
print(f" Train loss: {latest.metrics.train_loss:.4f}")
print("=" * 50)
job_report("ftjob-xxxxxxxxxxxxxxxx")
Pontos-chave
- Monitore sempre a perda de validação — é o seu verdadeiro indicador de qualidade
- Se a perda de validação subir, está em sobreajuste: reduza as épocas
- Os checkpoints permitem-lhe recuperar um estado intermédio
- Automatize a monitorização para tarefas de longa duração
- Documente as métricas de cada execução para comparar as suas iterações