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

Monitorização do Treino

Aula 7 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Por Que Monitorizar o Treino
  2. As Duas Métricas a Ler
  3. Rastrear Eventos via API
  4. Checkpoints e Resultados Intermédios
  5. Saber Quando Parar
  6. Um Relatório Resumido por Execução
  7. Pontos-chave

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