Monitoring de l'entraînement

Pourquoi monitorer l’entraînement

Lancer un job de fine-tuning sans le surveiller, c’est comme cuire un gâteau sans minuteur. Vous devez observer les métriques en temps réel pour détecter les problèmes tôt et décider si vous devez ajuster vos hyperparamètres.

Les métriques clés

Training loss

La training loss mesure à quel point le modèle se trompe sur les données d’entraînement. Elle doit diminuer au fil des étapes (steps). Une loss qui stagne ou remonte indique un problème.

Validation loss

La validation loss mesure la performance sur des données que le modèle n’a jamais vues pendant l’entraînement. C’est la métrique la plus fiable pour évaluer la qualité réelle de votre modèle.

Relation entre les deux

Suivre les événements via l’API

Récupérer les événements en continu

from openai import OpenAI
import time

client = OpenAI()

def monitorer_job(job_id: str):
    """Monitore un job en temps réel."""
    dernier_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Récupérer les nouveaux événements
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if dernier_event and event.id == dernier_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            dernier_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nJob terminé : {job.status}")
            if job.status == "succeeded":
                print(f"Modèle : {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Utilisation
job = monitorer_job("ftjob-xxxxxxxxxxxxxxxx")

Extraire les métriques de la loss

Les événements contiennent les valeurs de loss à chaque step :

def extraire_metriques(job_id: str) -> dict:
    """Extrait les métriques de loss d'un job terminé."""
    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 et résultats intermédiaires

OpenAI sauvegarde des checkpoints pendant l’entraînement. Si le job échoue ou si vous l’annulez, vous pouvez parfois récupérer un checkpoint intermédiaire utilisable.

# Lister les checkpoints d'un 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"  Modèle : {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}")

Quand arrêter l’entraînement

Signes qu’il faut arrêter

• La validation loss remonte depuis plusieurs steps
• La training loss est proche de zéro (le modèle mémorise)
• Les résultats de test ne s’améliorent plus

Annuler un job en cours

# Si vous détectez un problème, annulez le job
client.fine_tuning.jobs.cancel(job.id)
print("Job annulé. Ajustez vos données ou hyperparamètres et relancez.")

Script de monitoring complet

def rapport_job(job_id: str):
    """Génère un rapport de synthèse du job."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Job : {job.id}")
    print(f"Modèle de base : {job.model}")
    print(f"Statut : {job.status}")
    print(f"Epochs : {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Modèle fine-tuné : {job.fine_tuned_model}")
        print(f"Tokens entraînés : {job.trained_tokens}")

    if job.status == "failed":
        print(f"Erreur : {job.error}")

    # Checkpoints
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        dernier = checkpoints.data[0]
        print(f"Dernier checkpoint : step {dernier.step_number}")
        if dernier.metrics:
            print(f"  Train loss : {dernier.metrics.train_loss:.4f}")

    print("=" * 50)

rapport_job("ftjob-xxxxxxxxxxxxxxxx")

Points clés à retenir

• Surveillez toujours la validation loss — c’est votre indicateur de qualité réel
• Si la validation loss remonte, vous surapprenez : réduisez les epochs
• Les checkpoints permettent de récupérer un état intermédiaire
• Automatisez le monitoring pour vos jobs longs
• Documentez les métriques de chaque run pour comparer vos itérations