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
1. Décider s'il faut adapter le modèle
2. Préparer des données d'entraînement fiables
3. Comprendre les méthodes d'adaptation
4. Mener une expérience contrôlée
5. Évaluer au-delà de la perte d'entraînement
6. Empaqueter et maintenir l'adaptation
7. Études de cas
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 main
Ce que vous devez savoir
- Ce que LoRA entraîne (rang 8 sur les couches de requête et de valeur : 460 800 paramètres, 0,34 % du modèle), dans Réglage fin complet et réglage efficace en paramètres.
- L’estimation de mémoire pour LoRA sur ce modèle, dans Mémoire, quantification et autres méthodes.
- Les lots, les époques et les données de validation, dans Lots, époques et validation du cours L’apprentissage profond et les transformeurs expliqués.
- Le taux d’apprentissage, dans Taux d’apprentissage et optimiseurs.
Ce qu’il vous faut sur votre ordinateur
- Le projet
~/projects/ticket-adapterà la fin du module 3 :python -m pytestaffiche21 passed(21 tests réussis). Sinon, copiez l’instantanéend-of-m03comme 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.
Planifier un long trajet
Section intitulée « Planifier un long trajet »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 :
name = "lora-r8"seed = 12threads = 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 onmax_tokens = 320 # longer examples lose the end of the ticket text, never the answer
[lora]rank = 8alpha = 16 # the update is scaled by alpha / rank = 2dropout = 0.05targets = ["q_proj", "v_proj"]
[train]learning_rate = 2e-4batch_size = 8epochs = 2eval_every = 25 # steps between validation lossescheckpoint_every = 50 # steps between checkpoints (a stopped run loses at most 50 steps)gradient_checkpointing = true # less memory, about 20% more timekeep_checkpoints = 2Vous connaissez la plupart des noms grâce au module 3 et au cours sur l’apprentissage profond. Quatre sont nouveaux ici :
max_tokensest 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.seedfixe les choix aléatoires, comme l’ordre des lots. La même graine donne le même entraînement sur le même ordinateur.threadslimite 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.
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.
MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"REVISION = "12fd25f77366fa6b3b4b768ec3050bf629380bac"Temps et mémoire, estimés puis mesurés
Section intitulée « Temps et mémoire, estimés puis mesurés »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.)
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 :
- Quel entraînement lanceriez-vous d’abord, et pourquoi?
- Que faudrait-il observer avant d’entraîner plus longtemps?
- 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.
Exercice guidé : préparer l’entraînement
Section intitulée « Exercice guidé : préparer l’entraînement »Travaillez dans le dossier du projet, avec l’environnement virtuel activé.
-
Obtenez les fichiers d’exercices les plus récents :
git -C ../nextia-learning-labs pull. -
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-m04mkdir configscp $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/Fenêtre de terminal $S = "..\nextia-learning-labs\C12\snapshots\end-of-m04"mkdir configsCopy-Item $S\requirements.txt, $S\pytest.ini .Copy-Item $S\adapt\__main__.py, $S\adapt\model.py, $S\adapt\config.py adapt\Copy-Item $S\configs\lora-r8.toml configs\ -
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/cpupython -m pip install -r requirements-dev.txtFenêtre de terminal python -m pip install torch==2.14.1 --index-url https://download.pytorch.org/whl/cpupython -m pip install -r requirements-dev.txtCela prend quelques minutes. L’environnement atteint environ 720 Mo.
-
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/12fd25f77366fa6b3b4b768ec3050bf629380bacVotre dossier de cache est différent. Un avertissement sur les « requêtes non authentifiées » est normal : aucun compte n’est nécessaire.
-
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 recordsbatch 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 threadsLe 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.
-
Exécutez les tests :
python -m pytest. La dernière ligne indique21 passed. Les tests du code d’entraînement arrivent dans la prochaine leçon.
À vous de jouer : un lot plus petit
Section intitulée « À vous de jouer : un lot plus petit »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 threads900 ÷ 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 1Cause : 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érification des connaissances
Section intitulée « Vérification des connaissances »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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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.
planle 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