Itérer : quand re-fine-tuner

Le fine-tuning est un processus itératif

Votre premier fine-tuning sera rarement parfait. L’amélioration vient de cycles itératifs : analyser les erreurs, enrichir les données, relancer l’entraînement, réévaluer. Cette leçon vous apprend à identifier quand et comment itérer efficacement.

Analyser les erreurs du modèle

Catégoriser les échecs

Après chaque évaluation, classez les erreurs en catégories :

def analyser_erreurs(resultats: list[dict]) -> dict:
    """Catégorise les erreurs du modèle fine-tuné."""
    categories = {
        "format": [],       # Mauvais format de réponse
        "ton": [],          # Ton inapproprié
        "factuel": [],      # Information incorrecte
        "incomplet": [],    # Réponse trop courte ou manque des éléments
        "hors_sujet": [],   # Ne répond pas à la question
        "hallucination": [] # Invente des informations
    }

    for r in resultats:
        if r.get("score", 5) < 3:
            # Classifier l'erreur (peut être fait manuellement ou par LLM)
            categorie = classifier_erreur(r)
            categories[categorie].append(r)

    print("Distribution des erreurs :")
    for cat, erreurs in categories.items():
        if erreurs:
            print(f"  {cat} : {len(erreurs)} cas")

    return categories

Identifier les patterns

Recherchez des patterns récurrents dans les erreurs :

• Le modèle échoue-t-il sur un type de question spécifique ?
• Les erreurs sont-elles concentrées sur certains sujets ?
• Le problème vient-il des données ou des hyperparamètres ?

Quand re-fine-tuner

Signaux clairs qu’il faut itérer

Quand NE PAS re-fine-tuner

• Les erreurs sont rares et non systématiques — le prompt engineering peut suffire
• Le problème vient de l’infrastructure (latence, timeouts), pas du modèle
• Vous n’avez pas assez de nouvelles données pour justifier un nouveau run
• Un nouveau modèle de base est disponible — testez-le d’abord sans fine-tuning

Stratégies d’itération

Itération incrémentale

Ajoutez de nouveaux exemples ciblés à vos données existantes :

import json

def enrichir_dataset(
    dataset_existant: str,
    nouveaux_exemples: list[dict],
    output: str
):
    """Ajoute de nouveaux exemples au dataset existant."""
    # Charger les données existantes
    with open(dataset_existant, "r") as f:
        existants = [json.loads(l) for l in f]

    # Fusionner
    combines = existants + nouveaux_exemples

    # Sauvegarder
    with open(output, "w") as f:
        for ex in combines:
            f.write(json.dumps(ex, ensure_ascii=False) + "\n")

    print(f"Dataset enrichi : {len(existants)} + {len(nouveaux_exemples)} = {len(combines)}")

Itération corrective

Transformez les erreurs détectées en exemples d’entraînement :

def erreur_vers_exemple(
    question: str,
    mauvaise_reponse: str,
    bonne_reponse: str,
    system_msg: str
) -> dict:
    """Transforme une erreur en exemple d'entraînement."""
    return {
        "messages": [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question},
            {"role": "assistant", "content": bonne_reponse}
        ]
    }

# Transformer un lot d'erreurs
corrections = []
for erreur in erreurs_detectees:
    correction = erreur_vers_exemple(
        question=erreur["question"],
        mauvaise_reponse=erreur["reponse_modele"],
        bonne_reponse=erreur["reponse_corrigee"],
        system_msg=PROMPT_SYSTEME
    )
    corrections.append(correction)

Fine-tuning continu

Vous pouvez fine-tuner un modèle déjà fine-tuné pour l’améliorer progressivement :

# Fine-tuner à partir d'un modèle déjà fine-tuné
job_v2 = client.fine_tuning.jobs.create(
    training_file=nouveau_fichier.id,
    model="ft:gpt-5.3-mini:org::suffix-v1:xxxxxxxx",  # modèle v1 comme base
    suffix="mon-assistant-v2"
)

Attention : le fine-tuning continu accumule les biais. Après 2-3 itérations successives, il est souvent préférable de repartir du modèle de base avec un dataset complet et enrichi.

Workflow d’itération recommandé

Documenter chaque itération

iteration_log = {
    "version": "v3",
    "date": "2026-04-02",
    "modele_base": "gpt-5.3-mini",
    "dataset": {
        "train": 350,
        "validation": 45,
        "nouveaux_exemples": 50,
        "source_nouveaux": "erreurs production semaine 12"
    },
    "hyperparametres": {
        "n_epochs": 3,
        "learning_rate_multiplier": "auto",
        "batch_size": "auto"
    },
    "resultats": {
        "validation_loss": 0.42,
        "precision_test": 0.91,
        "csat_moyen": 4.3,
        "amelioration_vs_v2": "+5% précision, +0.2 CSAT"
    },
    "decision": "Déployé en production le 2026-04-03"
}

Points clés à retenir

• Le fine-tuning est itératif — planifiez plusieurs cycles
• Catégorisez les erreurs avant de les corriger dans les données
• Transformez le feedback utilisateur en exemples d’entraînement
• Après 2-3 itérations successives, repartez du modèle de base
• Documentez chaque itération pour garder un historique clair