Aller au contenu
English

Mémoire, quantification et autres méthodes

  • Leçon 6
  • 40 min
  • Module 3 : Comprendre les méthodes d'adaptation

Où nous en sommes

Dans la dernière leçon, nous avons choisi un adaptateur LoRA, car il entraîne seulement 0,34 % des nombres du modèle. Mais moins de nombres entraînés ne nous disent pas si l'entraînement tient dans la mémoire de notre ordinateur. Dans cette leçon, nous estimons la mémoire du réglage fin complet, de LoRA et de QLoRA, voyons ce que la quantification économise et modifie, et choisissons une méthode pour trois budgets, en partant d'un livre sur un petit bureau.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 6 sur 12 · Réglage fin et adaptation des modèles d'IAMémoire, quantification et autres méthodes

Ce que vous saurez faire

Avant l’entraînement, vérifiez si votre ordinateur peut utiliser une méthode. Vous estimez la mémoire du réglage fin complet, de LoRA et de QLoRA à 4 bits. Vous voyez ce que la quantification économise et modifie. Ensuite, vous choisissez une méthode pour trois budgets matériels.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet à la fin de la dernière leçon : python -m pytest donne 19 passed (19 tests réussis). S’il ne fonctionne plus, copiez l’instantané end-of-m02 et refaites les étapes de la dernière leçon.
  • La variable du shell S de la dernière leçon. Dans un nouveau terminal, définissez-la de nouveau.

Vous devez corriger un livre sur un petit bureau. Le livre lui-même prend de la place. Pour chaque page que vous pouvez modifier, il vous faut aussi une feuille de brouillon et deux feuilles de notes. Si vous pouvez modifier toutes les pages, il vous faut le livre plus trois fois son volume. Si vous pouvez modifier seulement quelques pages, il vous faut le livre plus quelques feuilles. Et si le livre est imprimé en plus petit, il occupe moins d’espace sur le bureau.

Tomás a une nouvelle idée : « SmolLM2 est minuscule. Faisons un réglage fin d’un modèle à 7 milliards de paramètres. Il en sait beaucoup plus. » Kwame pose la première question : y a-t-il assez de mémoire?

L’entraînement avec l’optimiseur Adam en float32 conserve quatre nombres de 4 octets pour chaque poids entraîné. Ce sont le poids, son gradient et les deux moyennes mobiles d’Adam. Cela donne 16 octets par paramètre. Pour SmolLM2, 134 515 008 × 16 octets = 2,15 Go. Pour un modèle à 7 milliards de paramètres, 7 000 000 000 × 16 octets = 112 Go. L’ordinateur portable du cours a 16 Go.

Avec LoRA, chaque poids reste en mémoire, à 4 octets. Mais seuls les paramètres de l’adaptateur ont des gradients et des nombres d’Adam : 12 octets par paramètre. Pour SmolLM2 : 134 515 008 × 4 + 460 800 × 12 octets = 0,54 Go. Pour un modèle à 7 milliards de paramètres, les poids gelés seuls occupent 28 Go.

Les poids gelés occupent donc maintenant presque toute la mémoire. Pour économiser davantage, stockez-les avec moins d’octets.

La quantification stocke chaque poids avec moins de bits, en l’arrondissant. Une liste de prix arrondis aux 5 cents près suit la même idée. Les compromis sur les ressources, dans Les LLM : comment ils fonctionnent et comment en choisir un, l’explique. Voici un tout petit exemple à 4 bits.

Prenez 8 poids inventés. Le plus éloigné de zéro est −0,35. Quatre bits offrent 16 valeurs possibles; cet exemple utilise les paliers entiers de −7 à 7. Un palier vaut donc 0,35 ÷ 7 = 0,05. Chaque poids devient le palier le plus proche :

Poids (float32) 0,12 −0,05 0,31 −0,22 0,02 −0,35 0,18 0,07
Palier stocké 2 −1 6 −4 0 −7 4 1
Valeur relue (palier × 0,05) 0,10 −0,05 0,30 −0,20 0,00 −0,35 0,20 0,05
Erreur −0,02 0 −0,01 +0,02 −0,02 0 +0,02 −0,02

Les 8 poids occupaient 32 octets en float32. À 4 bits, ils occupent 4 octets, plus 4 octets pour la taille du palier. Les vrais formats à 4 bits utilisent des groupes de 64 poids et de meilleurs paliers. Mais l’idée reste la même.

Les mêmes 8 poids inventés avant et après l'arrondissement à 4 bits. Chaque poids passe au multiple de 0,05 le plus proche; aucun poids ne change de plus de 0,02.
Description textuelle du graphique

Deux rangées de 8 points sur un axe de −0,4 à 0,4. La rangée float32 contient les poids d’origine : −0,35, −0,22, −0,05, 0,02, 0,07, 0,12, 0,18 et 0,31. La rangée à 4 bits contient les valeurs arrondies : −0,35, −0,20, −0,05, 0, 0,05, 0,10, 0,20 et 0,30. Chaque valeur arrondie est un multiple de 0,05. Chaque point se trouve à au plus 0,02 de sa valeur d’origine.

QLoRA combine les deux idées : le modèle gelé à 4 bits, avec un adaptateur LoRA entraîné en pleine précision. Pour un modèle à 7 milliards de paramètres, cela donne 3,79 Go. Cette méthode a deux coûts. L’arrondissement modifie un peu les réponses du modèle, donc vous mesurez de nouveau la qualité. De plus, bitsandbytes, la bibliothèque habituelle d’entraînement à 4 bits, demande un GPU. QLoRA n’est donc pas une option sur le processeur de l’ordinateur portable du cours.

  1. Copiez l’estimateur et son test, puis exécutez-le :

    Fenêtre de terminal
    cp $S/adapt/memory.py adapt/
    cp $S/tests/test_memory.py tests/
    python -m adapt memory

    La sortie :

    ESTIMATE: weights + gradients + AdamW states. Activations are not included (measure them).
    model method GB laptop 16 GB GPU 24 GB GPU 80 GB
    SmolLM2-135M full fine-tuning (float32) 2.15 fits fits fits
    SmolLM2-135M LoRA, base in float32 0.54 fits fits fits
    SmolLM2-135M LoRA, base in bfloat16 0.27 fits fits fits
    SmolLM2-135M QLoRA, base in 4 bits 0.07 fits fits fits
    a 1.7B model full fine-tuning (float32) 27.20 no no fits
    a 1.7B model LoRA, base in float32 6.87 fits fits fits
    a 1.7B model LoRA, base in bfloat16 3.47 fits fits fits
    a 1.7B model QLoRA, base in 4 bits 0.92 fits fits fits
    a 7B model full fine-tuning (float32) 112.00 no no no
    a 7B model LoRA, base in float32 28.29 no no fits
    a 7B model LoRA, base in bfloat16 14.29 no fits fits
    a 7B model QLoRA, base in 4 bits 3.79 fits fits fits
    a 70B model full fine-tuning (float32) 1120.00 no no no
    a 70B model LoRA, base in float32 282.88 no no no
    a 70B model LoRA, base in bfloat16 142.88 no no no
    a 70B model QLoRA, base in 4 bits 37.88 no no fits
    fits = the estimate uses at most 70% of the memory (the rest: activations, the system).
    QLoRA needs a GPU library (bitsandbytes); on a laptop CPU it is not an option.
  2. Exécutez les tests. La dernière ligne indique 21 passed (21 tests réussis).

Les tailles autres que celle de SmolLM2 sont des tailles arrondies de familles de modèles courantes. C’est une hypothèse. L’estimateur suppose aussi que LoRA entraîne 0,34 % de chaque modèle, comme pour SmolLM2. Les modèles et les bibliothèques évoluent vite : ces nombres décrivent ce modèle et ces versions.

  • Réglage fin complet
  • LoRA
  • QLoRA, modèle de base à 4 bits
Le même modèle à 7 milliards de paramètres avec quatre méthodes (estimations, sans les activations). 70 % de 16 Go sur un portable donne 11,2 Go; de 24 Go sur un GPU, 16,8 Go; de 80 Go sur un GPU, 56 Go.
Description textuelle du graphique

Un diagramme à quatre colonnes, avec des estimations pour un modèle à 7 milliards de paramètres. Réglage fin complet en float32 : 112,0 Go. LoRA avec le modèle de base en float32 : 28,3 Go. LoRA avec le modèle de base en bfloat16 : 14,3 Go. QLoRA avec le modèle de base à 4 bits : 3,8 Go. Avec 70 % de mémoire utilisable, seul QLoRA tient dans les 16 Go du portable, mais il demande un GPU. LoRA en bfloat16 tient dans un GPU de 24 Go. Le réglage fin complet dépasse les trois budgets.

Deux autres méthodes reviennent dans toutes les discussions sur l’adaptation des modèles. Chacune demande des données différentes.

Méthode Ce qu’elle entraîne Les données nécessaires Pour la tâche de Larkfield
Distillation Un petit modèle « élève » copie les réponses d’un grand modèle « enseignant » Beaucoup de billets de soutien sans étiquette, et le coût des réponses de l’enseignant Possible plus tard; l’élève copie aussi les erreurs de l’enseignant, et les conditions du fournisseur doivent le permettre
Réglage par préférences (par exemple DPO) Le modèle apprend laquelle de deux réponses les gens préfèrent Des paires de réponses, dont une marquée comme meilleure Non : il change la façon dont le modèle écrit, et notre tâche a une seule bonne réponse

Kwame a trois options pour l’expérience : le portable (16 Go, sans GPU), un GPU loué de 24 Go ou un de 80 Go.

  • Tomás : « Le GPU de 24 Go. QLoRA sur un modèle à 7 milliards de paramètres. Un plus gros modèle en sait plus, en français aussi. »
  • Kwame : « La location coûte de l’argent et demande un compte. Le portable ne coûte rien de plus. »
  • Priya : « À quelle question doit répondre le premier entraînement? »
  • Grace : « N’oubliez pas que 10 des 102 cas de validation sont en français. »

Avant de poursuivre, répondez à ces questions :

  1. Quelles méthodes tiennent dans chaque option? Utilisez le tableau ci-dessus.
  2. Quelle défaillance un plus grand modèle de base pourrait-il réduire? Laquelle ne pourrait-il pas réduire?
  3. Quels résultats justifieraient la location du GPU?

La réponse du cours. Le portable, LoRA de rang 8, SmolLM2. Le premier entraînement doit montrer si nos exemples permettent d’apprendre le format et l’acheminement. Cette question demande un petit entraînement peu coûteux que tout le monde peut répéter. Le portable a assez de mémoire : le pic mesuré atteint 1,88 Go, comme le montre le cas d’échec ci-dessous. Un plus grand modèle peut mieux comprendre le français. Mais il ne peut pas apprendre les règles H2 à H5 ou les exemples français absents des données.

Ce qui changerait la réponse : le petit adaptateur pourrait apprendre l’acheminement en anglais, mais échouer en français. Cela pourrait venir d’une mauvaise compréhension du français par le modèle de base. QLoRA sur un modèle à 7 milliards de paramètres devient alors la prochaine étape à mesurer. Il faudrait aussi des exemples d’entraînement en français.

Erreur courante

L'estimation tient en mémoire, mais pas l'entraînement

Symptôme : Tomás lit le tableau : « LoRA sur un modèle à 7 milliards de paramètres en bfloat16 demande 14,29 Go. Le portable a 16 Go, donc ça tient. » L’estimateur indique no (non).

Cause : l’estimation compte seulement les poids, les gradients et les nombres d’Adam. Elle exclut les activations, qui augmentent avec la taille du lot et la longueur du texte, ainsi que le programme lui-même. L’entraînement du cours montre cet écart. Pour SmolLM2, l’estimation est de 0,54 Go, mais le processus d’entraînement a atteint un pic mesuré de 1 882 Mo.

  • Estimation : poids, gradients, Adam
  • Pic mesuré du processus d'entraînement
L'entraînement LoRA du cours, avec des lots de 8 : l'estimation est de 0,54 Go, le pic mesuré de 1,88 Go. La différence vient des activations et du programme lui-même.
Description textuelle du graphique

Deux colonnes. L’estimation des poids, des gradients et des nombres d’Adam pour LoRA sur SmolLM2-135M en float32 : 0,54 Go. Le pic de mémoire mesuré du processus d’entraînement complet, avec des lots de 8 : 1,88 Go. C’est environ trois fois et demie l’estimation.

Correction : considérez l’estimation comme le minimum possible et gardez 30 % de mémoire libre, comme le fait fits. Mesurez ensuite un court entraînement avant d’en lancer un long. Le module 4 le fait.

Copiez l’exemple détaillé de l’équipe et lisez-le :

Fenêtre de terminal
cp $S/docs/method-choice.md docs/
cp $S/README.md .

docs/method-choice.md reprend les trois budgets du tableau : le portable et les deux GPU. Pour chacun, il indique ce qui tient en mémoire, le choix et la raison. Chaque raison mentionne la tâche, la mémoire et les données. Votre projet correspond maintenant à l’instantané end-of-m03.

Choisissez une méthode pour chaque budget. Donnez une raison liée à la tâche et une autre liée à la mémoire.

  1. Un portable de bureau avec 8 Go et sans GPU.
  2. Un GPU de 48 Go.
  3. Un serveur avec 64 Go et sans GPU.
Afficher une solution détaillée

La mémoire utilisable est de 70 % : 5,6 Go, 33,6 Go et 44,8 Go.

  1. Portable de 8 Go : LoRA sur SmolLM2 (estimation de 0,54 Go). Le réglage fin complet (2,15 Go) tient aussi, mais les 900 exemples favorisent un adaptateur. Un modèle à 1,7 milliard de paramètres en float32 (6,87 Go) ne tient pas, et QLoRA demande un GPU.
  2. GPU de 48 Go : LoRA ou QLoRA sur un modèle à 7 milliards de paramètres tient (28,29, 14,29 et 3,79 Go). Utilisez-le seulement si l’évaluation du petit modèle révèle une défaillance qu’un plus grand modèle pourrait corriger. Le modèle à 70 milliards de paramètres (37,88 Go) ne tient pas.
  3. Serveur de 64 Go, sans GPU : LoRA sur un modèle à 7 milliards de paramètres en float32 (28,29 Go) tient en mémoire. Mais à chaque étape, ce modèle doit effectuer des calculs sur environ 52 fois plus de poids que SmolLM2. C’est une estimation. Sur un processeur, c’est trop lent pour une première expérience. Choisissez LoRA sur SmolLM2, comme dans le cours.

Vérification de fin de leçon : justifier une méthode

Section intitulée « Vérification de fin de leçon : justifier une méthode »

Une entreprise fictive, Harbour Bikes, veut répartir des demandes de réparation entre trois équipes, dans un format JSON strict. Elle a 400 demandes étiquetées, toutes en anglais, et un portable avec 16 Go, sans GPU. Les demandes ne doivent pas quitter ses ordinateurs. Écrivez cinq à huit phrases : la méthode, la taille du modèle, l’estimation de mémoire et un résultat qui changerait votre choix.

Afficher une solution détaillée et les critères des réviseurs

« Les demandes doivent rester sur nos ordinateurs, donc un modèle hébergé est exclu. D’abord, nous comparons une requête sur un petit modèle local à un classificateur fondé sur le comptage des mots. Si nous adaptons le modèle, nous utilisons LoRA de rang 8 sur un petit modèle comme SmolLM2-135M. L’estimation est de 0,54 Go, bien en dessous de 70 % de 16 Go. Avec 400 exemples, le réglage fin complet a trop de poids pour trop peu d’exemples. QLoRA demande un GPU, que nous n’avons pas. Si les deux pertes restent élevées, nous essayons un rang supérieur, puis un plus grand modèle avec LoRA en bfloat16. Pour 1,7 milliard de paramètres : 3,47 Go. »

Les réviseurs indiquent démontré quand la réponse remplit quatre critères. Elle nomme la méthode et le modèle, et utilise une estimation qui laisse une marge. Elle donne une raison liée aux données et nomme des résultats qui changeraient le choix. Ils indiquent partiellement démontré si un de ces éléments manque.

Vérifiez votre compréhension

Pourquoi le réglage fin complet en float32 demande-t-il environ 16 octets par paramètre, et pourquoi LoRA en demande-t-il beaucoup moins?

Afficher la réponse

Le réglage fin complet entraîne chaque poids. Chacun demande 4 octets pour le poids, 4 pour son gradient et 8 pour les deux moyennes mobiles d’Adam. Cela donne 16 octets. LoRA gèle le modèle. Chaque poids gelé demande encore 4 octets. Mais seuls les quelques paramètres de l’adaptateur ont des gradients et des nombres d’Adam. Pour SmolLM2, cela donne 0,54 Go au lieu de 2,15 Go.

Vérifiez votre compréhension

Qu'économise la quantification, et que peut-elle modifier? Pourquoi le cours n'utilise-t-il pas QLoRA sur son portable?

Afficher la réponse

La quantification stocke les poids avec moins de bits en les arrondissant. Le modèle gelé prend donc moins de mémoire : 4 bits représentent un huitième du float32. L’arrondissement modifie un peu chaque poids, donc les réponses du modèle peuvent changer. Il faut mesurer de nouveau la qualité. QLoRA conserve le modèle gelé à 4 bits et entraîne un adaptateur LoRA par-dessus. Sa bibliothèque habituelle, bitsandbytes, demande un GPU, et le portable du cours n’en a pas.

Vérifiez votre compréhension

L'estimation d'un entraînement est de 9 Go et votre ordinateur a 12 Go. Lancez-vous le long entraînement? Quels résultats vous feraient changer d'avis?

Afficher la réponse

Pas encore. 9 Go dépasse 70 % de 12 Go (8,4 Go), et l’estimation exclut les activations et le programme lui-même. L’entraînement LoRA du cours a demandé 1,88 Go, contre une estimation de 0,54 Go. Exécutez d’abord quelques étapes et mesurez le pic de mémoire. Si le pic mesuré reste bien en dessous de 12 Go, lancez le long entraînement. Sinon, utilisez un lot plus petit, des textes plus courts, un modèle plus petit ou plus de mémoire.

Récapitulatif

  • La mémoire d’entraînement commence à 16 octets par paramètre entraîné en float32 : 2,15 Go pour SmolLM2, 112 Go pour un modèle à 7 milliards de paramètres. LoRA entraîne peu de paramètres, donc les poids gelés dominent : 0,54 Go pour SmolLM2.
  • La quantification arrondit les poids pour utiliser moins de bits. QLoRA gèle le modèle à 4 bits sous un adaptateur LoRA : 3,79 Go pour un modèle à 7 milliards de paramètres. Il faut un GPU et une vérification de la qualité.
  • Une estimation donne le minimum possible. L’entraînement du cours a atteint 1,88 Go contre 0,54 Go estimé. Gardez donc 30 % de mémoire libre et mesurez.
  • La distillation demande un enseignant et beaucoup de billets; le réglage par préférences demande des paires de réponses. Aucune des deux méthodes ne convient à cette tâche pour le moment.
  • Le choix du module : LoRA de rang 8, sur SmolLM2-135M, sur le portable. Les données, et non le matériel, limitent ce que l’entraînement peut apprendre.

Ensuite, vous fixez la version du modèle, planifiez l’entraînement et définissez sa configuration.

Leçon suivante : Planifier et configurer l'entraînement