Aller au contenu
English

Planifier et configurer l'entraînement

  • Leçon 7
  • 45 min
  • Module 4 : Mener une expérience contrôlée

Où nous en sommes

Dans le module 3, nous avons choisi la méthode : LoRA, rang 8, sur SmolLM2-135M, sur l'ordinateur portable. Maintenant, nous sommes prêts à entraîner. Mais un entraînement que personne n'a noté ne peut pas être répété, comparé au suivant ou repris après un arrêt. Dans cette leçon, nous plaçons chaque paramètre dans un seul fichier, fixons les versions et planifions le temps et la mémoire, comme un long trajet planifié avant le départ.

Leçon 7 sur 12 · Réglage fin et adaptation des modèles d'IAPlanifier et configurer l'entraînement

Ce que vous saurez faire

Notez tous les paramètres d’un entraînement avant de le lancer. Vérifiez aussi son coût en temps et en mémoire. Vous pourrez ensuite le répéter, l’arrêter sans risque et le comparer au suivant.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 45 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet ~/projects/ticket-adapter à la fin du module 3 : python -m pytest affiche 21 passed (21 tests réussis). Sinon, copiez l’instantané end-of-m03 comme dans Utiliser un instantané.
  • Le dépôt des exercices du cours dans ~/projects/nextia-learning-labs (la même page explique comment l’obtenir).
  • Environ 1,2 Go d’espace disque libre : environ 720 Mo pour PyTorch et les autres bibliothèques, et 269 Mo pour le modèle.

Testé sur macOS (Apple silicon) avec Python 3.12.13, PyTorch 2.14.1, transformers 5.19.0 et peft 0.21.2. Les commandes Windows et Linux sont écrites, mais non testées.

Avant un long trajet en voiture, vous faites un plan. Le trajet fait 450 km. À environ 90 km à l’heure, il prend donc environ cinq heures. Vous arrêtez pour faire le plein tous les 150 km. Chaque heure, vous consultez la carte et vérifiez que vous êtes encore sur la bonne route. Vous notez le plan pour qu’un ami puisse refaire le même trajet. Et vous vérifiez que la voiture peut tout transporter avant de partir.

Un entraînement a besoin du même plan. Le nombre d’étapes représente la distance. Les vérifications de la carte représentent les pertes de validation. Les arrêts pour faire le plein représentent les points de contrôle, qui permettent de reprendre un entraînement arrêté. L’espace dans la voiture représente la mémoire de l’ordinateur.

Le problème : un entraînement que personne ne peut répéter

Section intitulée « Le problème : un entraînement que personne ne peut répéter »

Imaginez que Tomás entraîne un adaptateur dans un carnet (notebook) Jupyter. Il change le taux d’apprentissage deux fois et arrête après « environ une heure ». Il charge le modèle uniquement par son nom, HuggingFaceTB/SmolLM2-135M-Instruct. L’adaptateur semble bon. Deux semaines plus tard, Priya pose trois questions. Quel taux d’apprentissage a produit cet adaptateur? Combien d’étapes? Quels fichiers du modèle de base? Personne ne le sait.

La dernière question est la pire. Un nom de modèle sans révision signifie « les fichiers les plus récents ». Si les propriétaires du modèle publient de nouveaux poids ou un nouveau segmenteur en jetons, la même commande obtient d’autres fichiers. Aucune erreur ne vous en avertit. Un segmenteur en jetons transforme le texte en jetons (tokens) numérotés. S’il change, l’adaptateur voit d’autres numéros pour les mêmes mots. Le résultat ne peut donc pas être répété, ni comparé à celui du prochain entraînement.

L’idée : un fichier pour l’entraînement, un plan et des versions fixes

Section intitulée « L’idée : un fichier pour l’entraînement, un plan et des versions fixes »

La solution comporte trois parties.

Un fichier de configuration contient tous les paramètres qui changent le résultat. Un paramètre choisi avant l’entraînement, que le modèle n’apprend pas, est un hyperparamètre. L’entraînement du cours utilise configs/lora-r8.toml :

configs/lora-r8.toml
name = "lora-r8"
seed = 12
threads = 2 # CPU threads: the run must leave the rest of the computer usable
[data]
train = "data/prepared/train.jsonl" # from: python -m adapt prepare (900 records)
val = "data/prepared/val.jsonl" # 100 records, the same teams, never trained on
max_tokens = 320 # longer examples lose the end of the ticket text, never the answer
[lora]
rank = 8
alpha = 16 # the update is scaled by alpha / rank = 2
dropout = 0.05
targets = ["q_proj", "v_proj"]
[train]
learning_rate = 2e-4
batch_size = 8
epochs = 2
eval_every = 25 # steps between validation losses
checkpoint_every = 50 # steps between checkpoints (a stopped run loses at most 50 steps)
gradient_checkpointing = true # less memory, about 20% more time
keep_checkpoints = 2

Vous connaissez la plupart des noms grâce au module 3 et au cours sur l’apprentissage profond. Quatre sont nouveaux ici :

  • max_tokens est la longueur de séquence : le nombre maximal de jetons qu’un exemple d’entraînement peut contenir. Un billet de soutien plus long perd la fin de son texte, jamais la réponse. Un test du projet le vérifie.
  • checkpoint_every : un point de contrôle est une copie sauvegardée de l’état d’entraînement qui permet de reprendre un entraînement arrêté. Vous l’utilisez dans Surveiller et reprendre.
  • seed fixe les choix aléatoires, comme l’ordre des lots. La même graine donne le même entraînement sur le même ordinateur.
  • threads limite l’entraînement à 2 cœurs du processeur pour que l’ordinateur reste utilisable.

Un plan transforme le fichier en nombres avant le début de l’entraînement. Voici le calcul, avec toutes les valeurs visibles. 900 enregistrements d’entraînement en lots de 8 donnent 112,5 lots, donc 113 étapes par époque. Le dernier lot contient seulement 4 enregistrements. Deux époques donnent 226 étapes. Une perte de validation toutes les 25 étapes en donne 9 (25, 50, …, 225). Un point de contrôle toutes les 50 étapes en donne 4 (50, 100, 150, 200). L’entraînement fait aussi une validation et une sauvegarde à sa dernière étape, 226.

900 enregistrements d'entraînement divisés par une taille de lot de 8 donnent 113 étapes par époque; multipliées par 2 époques, cela donne 226 étapes. En dessous, une ligne du temps montre les 226 étapes en deux époques. Des points bleus au-dessus de la ligne marquent une perte de validation toutes les 25 étapes et à l'étape 226. Des carrés foncés en dessous marquent les points de contrôle aux étapes 50, 100, 150, 200 et 226. Une ligne rouge pointillée à l'étape 120 indique : arrêt à l'étape 120, reprise au point de contrôle de l'étape 100, donc 20 étapes sont refaites.
Le plan de l'entraînement du cours : 226 étapes, une perte de validation toutes les 25 étapes et un point de contrôle toutes les 50 étapes. Un arrêt perd au plus les étapes depuis le dernier point de contrôle.
Description textuelle du diagramme

La rangée du haut montre le calcul. 900 enregistrements d’entraînement, divisés par une taille de lot de 8, donnent 113 étapes par époque. Deux époques donnent 226 étapes pour l’entraînement. En dessous se trouve une ligne du temps de l’étape 0 à l’étape 226. Sa première moitié est l’époque 1 (étapes 1 à 113), et sa deuxième moitié est l’époque 2 (étapes 114 à 226). Au-dessus de la ligne, un point bleu marque chaque perte de validation : aux étapes 25, 50, 75, 100, 125, 150, 175, 200, 225 et 226. En dessous, un carré foncé marque chaque point de contrôle : aux étapes 50, 100, 150, 200 et 226. Une ligne rouge pointillée à l’étape 120 montre un arrêt. L’entraînement reprend au point de contrôle de l’étape 100. Les étapes 101 à 120 sont donc refaites.

Les versions fixes déterminent chaque fichier et chaque bibliothèque. adapt/model.py indique le modèle et sa révision exacte. Les fichiers du segmenteur en jetons dans model/ viennent de la même révision. download refuse les poids dont le fichier config.json diffère de model/config.json. requirements.txt indique une version exacte de chaque bibliothèque, comme torch==2.14.1 et peft==0.21.2.

adapt/model.py (part)
MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
REVISION = "12fd25f77366fa6b3b4b768ec3050bf629380bac"

Mémoire, quantification et autres méthodes estimait 0,54 Go pour LoRA sur ce modèle : les poids, les gradients et l’état de l’optimiseur. Cette estimation exclut les activations, les résultats intermédiaires de chaque couche que l’entraînement conserve pour la passe arrière. Nous avons donc mesuré le processus entier. L’entraînement du cours a atteint un pic de 1 882 Mo.

La sauvegarde des activations par points de contrôle économise de la mémoire. Elle conserve seulement certaines activations et recalcule les autres pendant la passe arrière. Elle coûte donc du temps. Lors d’une courte mesure de 8 étapes avec des lots de 4, les étapes prenaient 5,5 s avec cette méthode. Sans elle, elles prenaient 4,3 s. (Les points de contrôle de l’entraînement, les fichiers sauvegardés, sont une autre chose.)

Mémoire maximale mesurée sur l'ordinateur du cours. L'entraînement avec des lots de 8 nécessite 1 882 Mo. Sans sauvegarde des activations par points de contrôle, même des lots de 4 nécessitent 2 472 Mo.
Description textuelle du graphique

Le diagramme montre quatre pics de mémoire mesurés pour le processus Python entier. Répondre aux billets avec l’adaptateur chargé nécessite 1 262 Mo. Avec la sauvegarde des activations par points de contrôle, l’entraînement nécessite 1 724 Mo avec des lots de 4 (8 étapes). Il nécessite 1 882 Mo avec des lots de 8 (l’entraînement du cours). Sans cette méthode, l’entraînement avec des lots de 4 nécessite 2 472 Mo, plus que celui du cours avec des lots de 8. Chaque exécution est restée sous la limite du cours de 3 000 Mo.

L’entraînement du cours a pris 367 secondes (environ 6 minutes) sur un Apple M4 avec 2 fils d’exécution. Les durées dépendent de votre ordinateur et des autres programmes qui y tournent; la mémoire et les résultats, non. Ces nombres représentent un instantané : les bibliothèques et les modèles changent vite.

Quand le plan dit non. N’entraînez pas si votre ordinateur a moins d’environ 4 Go de mémoire libre ou manque d’espace pour 1,2 Go de fichiers. Les entraînements enregistrés du cours sont dans le projet, dans runs/. Toutes les leçons suivantes fonctionnent avec eux, sans entraînement.

Discussion : quelle taille choisir pour le premier entraînement?

Section intitulée « Discussion : quelle taille choisir pour le premier entraînement? »

Lundi matin. L’équipe décide d’essayer un adaptateur. Elle doit maintenant choisir ses paramètres.

  • Tomás : « Allons-y avec un gros entraînement. Rang 64, les sept couches, dix époques. Ça tourne pendant la nuit. Pourquoi entraîner un adaptateur faible d’abord? »
  • Kwame : « Cet ordinateur portable exécute aussi d’autres tâches. Je veux un entraînement sous 30 minutes et 3 Go. S’il s’arrête, il ne faut pas perdre la nuit. »
  • Priya : « Le premier entraînement devrait être petit. Ça nous donne vite une courbe complète. Ensuite, on change une chose et on compare. »

Avant de poursuivre, répondez à ces questions :

  1. Quel entraînement lanceriez-vous d’abord, et pourquoi?
  2. Que faudrait-il observer avant d’entraîner plus longtemps?
  3. Si un paramètre est mauvais, que coûte chaque choix?

La réponse du cours. Commencez par l’entraînement de Priya : rang 8 sur deux couches, 2 époques. Il a pris environ 6 minutes et 1 882 Mo. Une erreur coûte donc des minutes, pas une nuit. L’entraînement de Tomás change beaucoup de choses à la fois. S’il fonctionne, personne ne sait quel changement a aidé; s’il échoue, personne ne sait quel changement a nui. Il n’a pas non plus de mesure. Le rang 64 sur les sept couches entraîne 19 537 920 paramètres, soit 42 fois plus (python -m adapt params --rank 64 avec les sept --targets). Sa mémoire et sa durée sont des suppositions. Un petit entraînement d’abord, puis un changement à la fois, donne des preuves pour chaque choix. Dans la prochaine leçon, la courbe de ce premier entraînement détermine le deuxième.

Ce qui changerait la réponse : un ordinateur avec une carte graphique et un budget mesuré, ou une tâche déjà bien comprise. Un premier entraînement plus grand peut alors être raisonnable, mais toujours avec un seul fichier de configuration et un plan.

Travaillez dans le dossier du projet, avec l’environnement virtuel activé.

  1. Obtenez les fichiers d’exercices les plus récents : git -C ../nextia-learning-labs pull.

  2. Copiez les fichiers de cette leçon depuis l’instantané end-of-m04 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C12/snapshots/end-of-m04
    mkdir configs
    cp $S/requirements.txt $S/pytest.ini .
    cp $S/adapt/__main__.py $S/adapt/model.py $S/adapt/config.py adapt/
    cp $S/configs/lora-r8.toml configs/
  3. Installez les bibliothèques. Sur Windows et Linux, installez d’abord PyTorch depuis son index réservé aux processeurs. Sinon, pip sur Linux obtient la version pour cartes graphiques, beaucoup plus volumineuse.

    Fenêtre de terminal
    # Linux only, first: python -m pip install torch==2.14.1 --index-url https://download.pytorch.org/whl/cpu
    python -m pip install -r requirements-dev.txt

    Cela prend quelques minutes. L’environnement atteint environ 720 Mo.

  4. Téléchargez les poids du modèle : python -m adapt download. La dernière ligne affiche la révision, la taille et le dossier :

    HuggingFaceTB/SmolLM2-135M-Instruct at revision 12fd25f77366: 269 MB in <your cache>/hub/models--HuggingFaceTB--SmolLM2-135M-Instruct/snapshots/12fd25f77366fa6b3b4b768ec3050bf629380bac

    Votre dossier de cache est différent. Un avertissement sur les « requêtes non authentifiées » est normal : aucun compte n’est nécessaire.

  5. Planifiez l’entraînement : python -m adapt plan configs/lora-r8.toml. Comparez chaque nombre avec le calcul ci-dessus :

    lora-r8: 900 training records, 100 validation records
    batch 8, 2 epochs = 113 steps per epoch, 226 steps (1808 examples seen)
    validation loss every 25 steps (9 times), checkpoint every 50 steps (4)
    LoRA rank 8, alpha 16, dropout 0.05, on q_proj, v_proj; learning rate 0.0002; at most 320 tokens per example; 2 threads

    Le plan compte 226 × 8 = 1 808 exemples. Le dernier lot de chaque époque contient seulement 4 enregistrements. L’entraînement voit donc réellement 1 800 exemples.

  6. Exécutez les tests : python -m pytest. La dernière ligne indique 21 passed. Les tests du code d’entraînement arrivent dans la prochaine leçon.

Copiez configs/lora-r8.toml vers configs/batch4.toml. Dans la copie, remplacez name par "batch4" et batch_size par 4. Avant d’exécuter python -m adapt plan configs/batch4.toml, prédisez les étapes par époque, les étapes, les validations et les points de contrôle. Puis exécutez la commande.

Afficher la réponse
batch4: 900 training records, 100 validation records
batch 4, 2 epochs = 225 steps per epoch, 450 steps (1800 examples seen)
validation loss every 25 steps (18 times), checkpoint every 50 steps (9)
LoRA rank 8, alpha 16, dropout 0.05, on q_proj, v_proj; learning rate 0.0002; at most 320 tokens per example; 2 threads

900 ÷ 4 = exactement 225 étapes par époque. Les 1 800 exemples du plan sont donc maintenant corrects. L’entraînement a deux fois plus d’étapes. Il valide et sauvegarde donc deux fois plus souvent sur les mêmes données. Il n’est pas plus rapide : il voit les mêmes 1 800 exemples, en plus petits lots. Il fait aussi deux fois plus de mises à jour avec le même taux d’apprentissage. Son résultat peut donc différer. Changez une chose et mesurez. Supprimez configs/batch4.toml quand vous avez terminé : les prochaines leçons ne l’utilisent pas.

Erreur courante

Une faute de frappe dans le taux d'apprentissage

Symptôme : Sam copie la configuration et écrit learning_rate = 2e4 (le signe moins manque). python -m adapt plan configs/typo.toml s’arrête avec une trace d’erreur. Sa dernière ligne :

ValueError: configs/typo.toml: learning_rate must be between 0 and 1

Cause : 2e4 vaut 20 000, pas 0,0002. load_config() dans adapt/config.py vérifie les valeurs avant toute exécution. Il refuse un taux d’apprentissage hors de l’intervalle de 0 à 1 et moins de 64 jetons par exemple. Il refuse aussi un rang, une taille de lot ou un nombre d’époques inférieur à 1.

Correction : écrivez learning_rate = 2e-4, puis exécutez plan à nouveau.

Conséquence dans le travail en IA : sans vérification, l’entraînement démarre. La perte augmente brusquement ou devient « nan » (pas un nombre) après quelques étapes. Cela coûte des minutes ici et des heures sur un grand modèle. Une vérification qui refuse les paramètres impossibles avant l’entraînement coûte peu. Elle ne détecte pas une valeur possible mais mauvaise, comme 2e-3. Seules les courbes de la prochaine leçon le montrent.

Vérifiez votre compréhension

Une configuration contient 900 enregistrements d'entraînement, batch_size 6, epochs 3, eval_every 25 et checkpoint_every 50. Combien d'étapes l'entraînement a-t-il, et à quelles étapes sauvegarde-t-il un point de contrôle?

Afficher la réponse

900 ÷ 6 = 150 étapes par époque, et 3 époques donnent 450 étapes. Il sauvegarde un point de contrôle toutes les 50 étapes (50, 100, …, 450) : 9 points de contrôle. L’étape 450 est aussi la dernière. Aucune sauvegarde supplémentaire n’est donc nécessaire. Il valide toutes les 25 étapes : 18 fois.

Vérifiez votre compréhension

Tomás dit : « Le nom du modèle suffit; tout le monde sait quel modèle on a utilisé. » Quelles deux choses peuvent mal tourner sans révision, et comment ce projet s'en protège-t-il?

Afficher la réponse

Sans révision, le nom signifie les fichiers les plus récents. De nouveaux poids donneraient une autre base à l’adaptateur. Un nouveau segmenteur en jetons donnerait d’autres numéros de jetons pour les mêmes mots. Aucun de ces changements ne déclenche d’erreur. Le projet fixe la révision exacte dans adapt/model.py et conserve les fichiers du segmenteur de cette révision dans model/. download refuse les poids dont le fichier config.json diffère, et requirements.txt fixe la version de chaque bibliothèque.

Vérifiez votre compréhension

Quelles preuves vous feraient accepter le gros premier entraînement de Tomás (rang 64 sur toutes les couches, dix époques, pendant la nuit)?

Afficher la réponse

Des preuves mesurées, pas de l’espoir. D’abord, sa mémoire maximale et sa durée, mesurées sur l’ordinateur qui l’exécute, sous les limites (ici 3 Go et 30 minutes). Ensuite, une raison de croire que le petit entraînement ne suffit pas. Par exemple : un petit entraînement dont la perte de validation a cessé de diminuer, avec des résultats encore trop faibles. Même alors, changez une chose à la fois. Chaque résultat montrera ainsi quel changement a fait la différence.

Récapitulatif

  • Un fichier de configuration contient tous les paramètres qui changent le résultat : données, LoRA, taux d’apprentissage, taille des lots, époques, longueur des séquences, graine, fils d’exécution, validation et points de contrôle. Le fichier est la trace de l’entraînement.
  • plan le transforme en nombres avant l’entraînement. 900 enregistrements en lots de 8 donnent 113 étapes par époque et 226 étapes. L’entraînement a 9 validations et 4 points de contrôle, plus un de chaque à la dernière étape.
  • Fixez la révision du modèle et de son segmenteur en jetons, ainsi que la version de chaque bibliothèque. Un nom seul signifie « les fichiers les plus récents », et un changement ne déclenche aucune erreur.
  • Une estimation omet certaines choses. Le pic mesuré de l’entraînement était de 1 882 Mo. La sauvegarde des activations par points de contrôle économise de la mémoire (2 472 Mo sans elle avec des lots de 4), mais coûte du temps.
  • Le premier entraînement est petit et rapide. Le suivant change une chose, choisie à partir des preuves.

Ensuite, vous lancez l’entraînement, lisez ses deux courbes, puis l’arrêtez et le reprenez depuis un point de contrôle.

Leçon suivante : Surveiller et reprendre