Aller au contenu principal

Module 2 — Préparer un jeu de données d'instructions

La qualité d'un modèle affiné dépend d'une seule chose avant tout : la qualité du jeu de données. Un jeu médiocre passé dans une chaîne d'entraînement parfaite donne un modèle médiocre, tandis qu'un jeu excellent donne parfois un excellent modèle malgré des réglages approximatifs. Ce module construit le nôtre — deux mille paires transcription vers compte rendu — dans les règles.

Le format conversationnel, pas un simple texte​

Un modèle instruit — Llama 3 Instruct, Mistral Instruct, Qwen2 Instruct — n'attend pas du texte brut, mais des messages avec un rôle : system, user, assistant. Chaque famille de modèles a son gabarit de conversion en jetons — le chat template. L'oublier est l'erreur la plus fréquente du débutant : le modèle voit alors une chaîne étrange qui n'a rien à voir avec ce qu'il a appris en SFT (Supervised Fine-Tuning) et son comportement se dégrade sans avertissement.

Un exemple type de notre jeu :

exemple = {
    "messages": [
        {
            "role": "system",
            "content": "Tu resumes une reunion en compte rendu structure : decisions, points d'action avec proprietaire et echeance, questions ouvertes.",
        },
        {
            "role": "user",
            "content": "[transcription brute avec noms, hesitations, chevauchements]",
        },
        {
            "role": "assistant",
            "content": "## Decisions\n- ...\n\n## Points d'action\n- [ ] Marie : envoyer le devis pour le 12/03\n\n## Questions ouvertes\n- ...",
        },
    ]
}

L'application du gabarit se fait par le tokeniseur du modèle cible, jamais à la main :

from transformers import AutoTokenizer

tokeniseur = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
texte = tokeniseur.apply_chat_template(
    exemple["messages"], tokenize=False, add_generation_prompt=False
)

La sortie contient les jetons spéciaux propres au modèle — [INST], <|im_start|>, <s> selon la famille — que la bibliothèque TRL reconnaîtra pendant l'entraînement. Utiliser le tokeniseur du modèle exact que l'on va affiner n'est pas négociable : un gabarit voisin mais légèrement différent produit un modèle silencieusement défectueux.

Qualité, diversité, longueur​

Trois critères se surveillent sur un jeu d'instructions, et ils ne se remplacent pas.

La qualité est la conformité de la sortie visée à ce qu'on veut vraiment obtenir. Pour nos comptes rendus, cela signifie une structure identique dans les deux mille exemples : mêmes titres de section, même convention pour les propriétaires, mêmes formats de dates. Un exemple sur dix qui glisse hors du gabarit apprend au modèle qu'il peut, lui aussi, glisser. Mieux vaut mille exemples strictement homogènes que deux mille exemples inconstants.

La diversité évite au modèle d'apprendre une seule façon de parler. Nos transcriptions doivent couvrir plusieurs formats de réunion (comité, point projet, entretien annuel), plusieurs longueurs, plusieurs styles de tour de parole, plusieurs domaines métier. Sans diversité, le modèle affine son point fort et perd tout le reste — c'est la porte d'entrée du surapprentissage.

La longueur conditionne le coût. Le module 7 y reviendra ; retenons ici qu'une longueur de séquence de 4 096 jetons couvre 90 % de nos exemples et fixe la mémoire. Les transcriptions plus longues sont soit tronquées avec précaution, soit découpées en morceaux qui gardent une structure interprétable.

Dédoublonnage : le vice caché des jeux collectés​

Un jeu d'instructions collecté sur le terrain contient toujours des quasi-doublons. Deux transcriptions de la même réunion enregistrées par deux outils, deux comptes rendus rédigés par la même personne à un mois d'intervalle avec les mêmes tournures : ces répétitions ne sont pas apparentes à l'œil, mais gonflent artificiellement les motifs qu'elles portent et faussent la validation.

La contre-mesure minimale est un dédoublonnage par empreinte :

import hashlib

def empreinte(texte, longueur=64):
    return hashlib.sha256(texte.lower().encode("utf-8")).hexdigest()[:16]

vus = set()
propres = []
for ex in jeu:
    cle = empreinte(ex["messages"][1]["content"])
    if cle in vus:
        continue
    vus.add(cle)
    propres.append(ex)

Pour un dédoublonnage plus fin — même transcription reformulée, mêmes idées dans un ordre différent — on passe par un plongement dense (cours 18) et un seuil de similarité cosinus autour de 0,92. C'est plus lent, indispensable dès que le jeu dépasse quelques milliers d'exemples.

Découpage train, validation, test​

Le découpage précède tout prétraitement, comme dans les cours précédents. Trois blocs disjoints :

  • entraînement — 80 % : ce que le modèle voit et met à jour ;
  • validation — 10 % : ce qui mesure le surapprentissage à chaque époque (module 8) ;
  • test — 10 % : tenu à l'écart, utilisé une seule fois à la toute fin (module 10).

La contamination entre les trois blocs est l'erreur qui invalide toute l'évaluation. Elle survient quand un même document se retrouve dans deux blocs à la fois, ce qui fait remonter artificiellement les métriques. Pour nos réunions, la règle est de découper par identifiant de réunion, jamais par exemple : toutes les paires issues d'une même réunion vont dans le même bloc.

Génération synthétique : promesse et danger​

Générer artificiellement des exemples avec un modèle plus grand — GPT-4o, Claude — est aujourd'hui courant. C'est utile pour amorcer un jeu, atteindre une diversité difficile à obtenir en collectant, ou combler un motif rare. C'est aussi dangereux pour deux raisons.

D'abord le biais de style : le modèle générateur imprime sa signature dans chaque exemple, et le modèle affiné apprend à imiter cette signature plutôt que celle qu'on cherche vraiment. Un mélange 50/50 synthétique/humain limite l'effet.

Ensuite la licence : les conditions d'usage des grands modèles fermés interdisent souvent d'utiliser leurs sorties pour entraîner un modèle concurrent. Vérifier la clause avant de bâtir une chaîne complète.

Une porte d'entrée pratique

Commencez par 200 à 500 exemples humains soigneusement écrits, puis observez ce qui manque au modèle affiné. Générer 1 500 exemples synthétiques pour combler ces trous produit un jeu plus utile que 2 000 exemples synthétiques dès le départ.

En résumé​

  • Le format est conversationnel avec rôles system, user, assistant, appliqué par le tokeniseur du modèle cible.
  • Qualité, diversité, longueur se surveillent ensemble ; mille exemples homogènes valent mieux que deux mille inconstants.
  • Le dédoublonnage évite un biais silencieux ; par empreinte pour commencer, par plongement dense pour aller plus loin.
  • Le découpage par identifiant de la source évite la contamination train/validation/test.
  • La génération synthétique amorce, mais son excès imprime la signature du générateur.

Module suivant : le coût réel d'un affinage complet — celui que l'on va vouloir éviter par les techniques PEFT.