Lancer un fine-tuning via l'API

Vue d’ensemble du processus

Vos données sont prêtes, validées, découpées en train et validation. Le passage à l’entraînement proprement dit tient en trois mouvements : vous uploadez votre fichier de données, vous créez un job de fine-tuning, puis vous attendez que l’entraînement se termine. Tout passe par le SDK Python officiel, et vous verrez que le code tient en une trentaine de lignes — l’essentiel du travail était en amont.

Installer et configurer le SDK

Le client s’instancie sans argument : il lit tout seul la variable d’environnement OPENAI_API_KEY.

# Installation
# pip install openai

from openai import OpenAI

# Le client utilise automatiquement la variable OPENAI_API_KEY
client = OpenAI()

Assurez-vous que cette variable est bien définie avant de lancer le script, sans quoi l’instanciation échouera dès la première requête. En production, ne codez jamais votre clé en dur dans le code : une clé écrite en clair finit dans l’historique Git, et l’y retirer après coup est autrement plus coûteux que de la lire depuis l’environnement dès le premier jour.

Uploader les fichiers

L’upload se fait avec purpose="fine-tune", qui indique à OpenAI que le fichier est destiné à un entraînement et déclenche les contrôles de format correspondants. Uploadez le fichier de validation dans la foulée : il est techniquement optionnel, mais sans lui l’entraînement se déroule à l’aveugle, puisqu’aucune validation loss ne viendra signaler le surapprentissage pendant que le job tourne.

# Upload du fichier d'entraînement
training_file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"ID du fichier : {training_file.id}")
print(f"Statut : {training_file.status}")

# Optionnel : upload du fichier de validation
validation_file = client.files.create(
    file=open("validation_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"ID validation : {validation_file.id}")

Le fichier passe par une phase de traitement côté OpenAI. Attendez que le statut soit processed avant de lancer le job : un job créé sur un fichier encore en cours de traitement partira en erreur, et vous perdrez quelques minutes à chercher une cause inexistante dans votre JSONL.

Créer le job de fine-tuning

job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    validation_file=validation_file.id,  # optionnel mais recommandé
    model="gpt-5.6-luna",  # ou "gpt-5.6-luna"
    suffix="mon-assistant-v1"  # suffixe pour identifier votre modèle
)

print(f"Job ID : {job.id}")
print(f"Statut : {job.status}")
print(f"Modèle de base : {job.model}")

Le paramètre suffix est ajouté au nom de votre modèle fine-tuné : avec "mon-assistant-v1", le modèle résultant sera nommé ft:gpt-5.6-luna:votre-org::mon-assistant-v1:xxxxxxxx. Prenez l’habitude d’y mettre le cas d’usage et un numéro de version. Le jour où trois modèles cohabitent dans votre compte, c’est la seule chose qui vous permettra de savoir lequel sert quoi sans ouvrir la console.

Suivre l’avancement

Un job passe successivement par plusieurs statuts, et retrieve vous donne à tout moment celui en cours.

# Récupérer le statut du job
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Statut : {job.status}")
# Statuts possibles : validating_files, queued, running, succeeded, failed, cancelled

Le statut seul reste laconique. Les événements, eux, racontent le déroulé : validation du fichier, démarrage, progression par étapes, fin.

# Voir les événements du job
events = client.fine_tuning.jobs.list_events(
    fine_tuning_job_id=job.id,
    limit=20
)

for event in events.data:
    print(f"[{event.created_at}] {event.message}")

Plutôt que d’appeler retrieve à la main toutes les cinq minutes, encapsulez l’attente dans une boucle qui rend la main dès que le job atteint un état terminal. Notez que les trois cas de sortie sont traités séparément : un job annulé n’est pas un job en échec, et vous voudrez les distinguer dans vos logs.

import time

def suivre_job(client: OpenAI, job_id: str, intervalle: int = 30):
    """Suit un job de fine-tuning jusqu'à sa complétion."""
    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)
        print(f"Statut : {job.status}")

        if job.status == "succeeded":
            print(f"Modèle fine-tuné : {job.fine_tuned_model}")
            return job

        if job.status == "failed":
            print(f"Échec : {job.error}")
            return job

        if job.status == "cancelled":
            print("Job annulé.")
            return job

        time.sleep(intervalle)

# Utilisation
job_final = suivre_job(client, job.id)

Utiliser le modèle fine-tuné

Une fois le job terminé avec succès, votre modèle s’appelle exactement comme un modèle standard. Seule la valeur passée à model change, ce qui signifie qu’un basculement vers votre modèle personnalisé se résume, dans une application existante, à modifier une variable de configuration.

response = client.responses.create(
    model=job_final.fine_tuned_model,  # ex: "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
    input="Bonjour, j'ai un problème avec ma commande."
)

print(response.output_text)

Gérer vos jobs

Deux appels suffisent à administrer l’ensemble : lister ce qui existe, et interrompre ce qui tourne. L’annulation est utile dès que le monitoring vous montre un entraînement qui part de travers — inutile de payer les tokens d’un job dont vous savez déjà qu’il produira un mauvais modèle.

# Lister tous vos jobs de fine-tuning
jobs = client.fine_tuning.jobs.list(limit=10)
for j in jobs.data:
    print(f"{j.id} | {j.status} | {j.model} | {j.fine_tuned_model}")

# Annuler un job en cours
client.fine_tuning.jobs.cancel(job.id)

Coûts et durée

L’entraînement est facturé au nombre de tokens traités. La durée, elle, dépend de la taille de vos données et du nombre d’epochs.

Ces ordres de grandeur vous aident surtout à dimensionner votre boucle de travail : à quelques minutes par run, vous itérez dans la même session ; à deux heures, vous planifiez. Les prix exacts varient selon le modèle choisi, consultez la page de tarification OpenAI pour les tarifs actuels.

Points clés à retenir

• Le workflow est : upload fichier, créer job, attendre, utiliser le modèle
• Ajoutez un suffix descriptif pour identifier facilement vos modèles
• Utilisez toujours un fichier de validation pour évaluer la qualité
• Le modèle fine-tuné s’utilise exactement comme le modèle de base via l’API
• Gardez les IDs de vos jobs et modèles — vous en aurez besoin pour le versioning