Aller au contenu
English

Réglage fin complet et réglage efficace en paramètres

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

Où nous en sommes

Dans le module 2, nous avons préparé des données d'entraînement propres, avec leur provenance, des séparations équitables et le compte de ce qu'elles ne montrent jamais. Maintenant, nous choisissons ce que l'entraînement peut modifier dans le modèle. Le réglage fin complet change chaque poids, et chaque version est une copie complète du modèle. Dans cette leçon, nous le comparons à un petit adaptateur LoRA sur un modèle gelé, comme un livret de notes attaché à un gros manuel.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 5 sur 12 · Réglage fin et adaptation des modèles d'IARéglage fin complet et réglage efficace en paramètres

Ce que vous saurez faire

Décidez quelles parties d’un modèle l’entraînement peut modifier. Le réglage fin complet change chaque poids; un adaptateur LoRA garde le modèle gelé et entraîne une petite partie supplémentaire. Vous comptez les deux dans le modèle réel du cours.

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 ~/projects/ticket-adapter à la fin du module 2, avec son environnement actif : python -m pytest donne 17 passed (17 tests réussis). S’il ne fonctionne plus, copiez l’instantané end-of-m02, comme l’explique la page des instantanés.
  • Le dépôt des exercices dans ~/projects/nextia-learning-labs, à côté de votre projet. Récupérez ses fichiers les plus récents avec git -C ../nextia-learning-labs pull.

Ce module ne nécessite ni PyTorch ni téléchargement. Les comptes viennent du fichier de configuration du modèle. Testé sur macOS avec Python 3.12; les commandes Windows sont fournies, mais non testées.

Un nouvel agent de soutien reçoit le gros manuel de l’entreprise. Le manuel est bon, mais il ne connaît pas les équipes de Larkfield. Vous pouvez régler cela de deux façons. Vous pouvez réimprimer tout le manuel en modifiant chaque page. Ou vous pouvez garder le manuel tel quel et y fixer un mince livret de notes. L’agent lit les deux ensemble.

Le livret a trois avantages. Il coûte peu à écrire et à copier. Vous pouvez écrire un deuxième livret pour une autre tâche et garder le même manuel. Et si un livret donne de mauvais conseils, vous l’enlevez et retrouvez le manuel original.

Le problème : le réglage fin complet change chaque poids

Section intitulée « Le problème : le réglage fin complet change chaque poids »

Le réglage fin complet est la réimpression. L’entraînement peut changer chaque poids du modèle. Vous l’avez fait avec DistilBERT dans le cours sur l’apprentissage profond. Pour SmolLM2-135M, le modèle du cours, cela représente 134 515 008 nombres.

Chaque version modifiée est une nouvelle copie du modèle entier : 538 Mo en float32. L’entraînement nécessite les poids, leurs gradients et les deux nombres par poids de l’optimiseur : 2 152 Mo. C’est ce que mesurait Les coûts de l’inférence. Et Larkfield n’a que 900 enregistrements d’entraînement. Avec si peu d’exemples et autant de poids, l’entraînement peut modifier des compétences que la tâche ne demandait jamais. C’est l’oubli catastrophique : un modèle entraîné pour une tâche précise perd des capacités qu’il avait avant.

L’idée : geler le modèle, entraîner un petit adaptateur

Section intitulée « L’idée : geler le modèle, entraîner un petit adaptateur »

Un adaptateur est le livret. Les poids du modèle sont gelés : l’entraînement ne les change pas. À côté de certaines matrices de poids, l’entraînement ajoute quelques nombres et ne modifie que ceux-là. On appelle ces méthodes le réglage fin efficace en paramètres, ou PEFT.

L’adaptateur le plus courant est LoRA, l’adaptation de faible rang. Entraîner une matrice de poids consiste à apprendre une modification à lui ajouter. LoRA n’apprend pas cette modification nombre par nombre. Il la construit à partir de deux matrices minces, A et B, et apprend seulement celles-ci.

Un petit exemple : 16 modifications à partir de 8 nombres

Section intitulée « Un petit exemple : 16 modifications à partir de 8 nombres »

Prenez une matrice de poids de 4 × 4 : 16 nombres. Le réglage fin complet apprend une modification pour chacun. LoRA de rang 1 apprend une colonne B de 4 nombres et une ligne A de 4 nombres. La modification est B fois A : chaque ligne est A multipliée par un nombre de B.

A : 0,1 0 −0,2 0,3
B : 1 0,1 0 −0,2 0,3
B : 2 0,2 0 −0,4 0,6
B : 0 0 0 0 0
B : −1 −0,1 0 0,2 −0,3

Huit nombres appris donnent 16 modifications. Le rang est la largeur des matrices minces. Au rang 8, B a 8 colonnes et A a 8 lignes. La modification peut donc suivre 8 directions indépendantes. C’est le « faible rang » du nom.

Pour une matrice avec out lignes et in colonnes, LoRA entraîne rang × (in + out) nombres plutôt que out × in. La couche de requête de SmolLM2, q_proj, mesure 576 × 576 : 331 776 poids. Le rang 8 entraîne 8 × (576 + 576) = 9 216 nombres, soit 36 fois moins. Au début de l’entraînement, B ne contient que des zéros. Le modèle adapté répond donc exactement comme le modèle de base.

Le cours place des adaptateurs sur deux couches d’attention dans chacun des 30 blocs : la couche de requête q_proj et la couche de valeur v_proj.

SmolLM2-135M-Instruct comme une pile : plongements, bloc 1, bloc 2, points, bloc 30, scores du prochain jeton. Chaque partie est sombre (gelée); chaque bloc porte une petite étiquette LoRA bleue. Un bloc est agrandi. Attention : q_proj est un carré W sombre de 576 par 576, plus une mince colonne B bleue (576 par 8) multipliée par une mince ligne A bleue (8 par 576), 9 216 nombres entraînés. k_proj est une bande sombre de 192 par 576, gelée. v_proj est une bande sombre de 192 par 576 plus B (192 par 8) multipliée par A (8 par 576), 6 144 nombres entraînés. o_proj est un carré sombre de 576 par 576, gelé. Propagation avant : gate_proj 1536 par 576, up_proj 1536 par 576 et down_proj 576 par 1536, toutes gelées. Un bloc : 15 360 nombres entraînés. Multiplié par 30 blocs : 460 800 sur 134 515 008 (0,34 %).
Le modèle gelé avec ses adaptateurs entraînables. Dans chaque bloc, seules les matrices minces bleues A et B changent pendant l'entraînement.
Description textuelle du diagramme

À gauche, le modèle est une pile : les plongements (embeddings), les blocs 1 à 30, puis les scores du prochain jeton (token). Chaque partie est sombre, parce qu’elle est gelée. Chaque bloc porte une petite étiquette LoRA bleue. À droite, un bloc est agrandi; les 30 sont identiques. Dans l’attention, q_proj est un carré W sombre de 576 × 576 poids. À côté se trouvent un signe plus, une mince colonne B bleue (576 × 8), un signe de multiplication et une mince ligne A bleue (8 × 576). B et A entraînent 9 216 nombres. k_proj (192 × 576) est gelée. v_proj (192 × 576) a ses propres B (192 × 8) et A (8 × 576) : 6 144 nombres entraînés. o_proj (576 × 576) est gelée, tout comme les trois couches à propagation avant. Un bloc entraîne 15 360 nombres; 30 blocs en entraînent 460 800 sur les 134 515 008 du modèle, soit 0,34 %.

Le projet compte ces nombres à partir de model/config.json seulement. Ce fichier indique les dimensions du modèle, donc aucun téléchargement n’est nécessaire.

  1. Définissez une variable pour l’instantané et copiez les petits fichiers du modèle, le compteur et son test :

    Fenêtre de terminal
    S=../nextia-learning-labs/C12/snapshots/end-of-m03
    cp -R $S/model .
    cp $S/adapt/params.py adapt/
    cp $S/tests/test_params.py tests/
  2. Exécutez la commande :

    Fenêtre de terminal
    python -m adapt params

    La sortie est une erreur :

    usage: python -m adapt [-h]
    {cases,show,systems,failures,score,targets,sources,record,prepare}
    ...
    python -m adapt: error: argument command: invalid choice: 'params' (choose from cases, show, systems, failures, score, targets, sources, record, prepare)

    Le code est là, mais la ligne de commande ne connaît pas encore la nouvelle commande.

  3. Copiez la nouvelle ligne de commande et exécutez de nouveau la commande :

    Fenêtre de terminal
    cp $S/adapt/__main__.py adapt/
    python -m adapt params

    La sortie :

    SmolLM2-135M-Instruct: 30 blocks, hidden size 576
    Linear layers in one block (out x in): q_proj 576x576, k_proj 192x576, v_proj 192x576, o_proj 576x576, gate_proj 1536x576, up_proj 1536x576, down_proj 576x1536
    method trainable share file (MB)
    full fine-tuning 134,515,008 100.00% 538.1
    LoRA rank 4 on q_proj, v_proj 230,400 0.17% 0.9
    LoRA rank 8 on q_proj, v_proj 460,800 0.34% 1.8
    LoRA rank 16 on q_proj, v_proj 921,600 0.69% 3.7
    LoRA rank 64 on q_proj, v_proj 3,686,400 2.74% 14.7
    LoRA rank 8 on all 7 linear layers 2,442,240 1.82% 9.8
  4. Vérifiez avec les tests :

    Fenêtre de terminal
    python -m pytest

    La dernière ligne indique 19 passed (19 tests réussis). Un test vérifie que 460 800 correspond au nombre affiché par la bibliothèque d’entraînement peft pour le même adaptateur.

Lisez la ligne du cours : le rang 8 sur q_proj et v_proj entraîne 460 800 nombres, soit 0,34 % du modèle. En float32, cela donne un fichier de 1,8 Mo plutôt que de 538,1 Mo. L’adaptateur réel entraîné au module 4 fait 1 858 776 octets : ces nombres plus un petit en-tête.

Explorer

Ce qu'un adaptateur LoRA entraîne dans SmolLM2-135M

Nombres entraînables
460 800
Part du modèle
0,34 % de 134 515 008
Fichier de l’adaptateur (float32)
1,8 Mo
Par rapport au réglage complet
292 fois plus petit qu’un réglage complet (538,1 Mo)

Rang 8 sur q_proj et v_proj : l’adaptateur entraîne 460 800 nombres, un fichier de 1,8 Mo. Les 134 515 008 poids du modèle restent gelés. C’est le choix du cours : rang 8 sur q_proj et v_proj.

LoRA de rang 8 sur q_proj et v_proj : formes en sortie × entrée, nombres pour un bloc
CoucheW geléABEntraînés
q_proj576 × 5768 × 576576 × 89 216
v_proj192 × 5768 × 576192 × 86 144
Un bloc15 360
× 30 blocs460 800
Chaque couche ciblée reçoit A (rang × in) et B (out × rang) dans chacun des 30 blocs. Les comptes correspondent à python -m adapt params.
Description textuelle de l’explorateur

L’explorateur a un curseur pour le rang, de 1 à 64. Deux boutons choisissent les couches : q_proj et v_proj, ou les 7 couches linéaires. Il affiche les nombres entraînables, leur part des 134 515 008 nombres du modèle et la taille du fichier en float32. Un tableau montre A et B pour chaque couche d’un bloc. Au rang 8 sur q_proj et v_proj : 460 800 nombres, 0,34 %, 1,8 Mo. Au rang 16 : 921 600 nombres et 3,7 Mo, exactement deux fois plus. Au rang 64 : 3 686 400 et 14,7 Mo. Le rang 8 sur les 7 couches entraîne 2 442 240 nombres, soit 9,8 Mo, car les couches à propagation avant sont plus larges. Le modèle gelé ne change jamais.

Le compte augmente proportionnellement au rang, parce que chaque matrice A et B s’élargit. Le modèle gelé reste le même.

Utilisez un adaptateur si vous avez peu d’exemples, peu de mémoire ou plusieurs tâches sur un même modèle de base. Il est aussi facile à retirer : enlevez l’adaptateur, et le modèle de base répond de nouveau. LoRA est généralement le premier choix pour une tâche précise.

Il a aussi des coûts. Un adaptateur a moins de capacité pour changer le modèle. Un grand changement de comportement peut donc nécessiter un rang plus élevé ou davantage de couches. Il fonctionne seulement avec le modèle de base exact sur lequel il a été entraîné. Le module 6 montre comment consigner cela. Et l’entraînement nécessite toujours le modèle entier en mémoire, ce que la prochaine leçon calcule.

Kwame demande à l’équipe de s’entendre sur une méthode avant l’entraînement du module 4.

  • Tomás : « LoRA entraîne 0,34 % du modèle. C’est un jouet. Entraînons tous les poids, et il apprendra nos politiques. »
  • Kwame : « Le réglage fin complet crée une copie de 538 Mo pour chaque version. Ça tient sur cet ordinateur portable, mais chaque nouvel entraînement en crée une autre. »
  • Priya : « Avec quoi les poids supplémentaires apprendraient-ils? Sur les 900 enregistrements, 78 nécessitent une personne, tous selon la règle H1, et aucun n’est en français. »
  • Grace : « Les clients ne voient pas la méthode. Ils voient si un billet de soutien lié à la sécurité arrive à une personne. »

Avant de poursuivre, répondez à ces questions :

  1. Le réglage fin complet de SmolLM2 tient-il sur l’ordinateur portable du cours? La mémoire est-elle le facteur décisif ici?
  2. Que pourrait apprendre le rang 64 que le rang 8 ne peut pas apprendre? Que ne pourraient-ils apprendre ni l’un ni l’autre avec ces 900 enregistrements?
  3. Quel résultat de l’entraînement vous ferait augmenter le rang?

La réponse du cours. LoRA, rang 8, sur q_proj et v_proj. La mémoire n’est pas le facteur décisif : l’estimation de 2,15 Go pour le réglage fin complet tient en mémoire. Ce sont les données qui décident. Avec 900 enregistrements, une méthode pouvant changer les 134 515 008 poids risque davantage le surapprentissage et l’oubli. L’adaptateur protège le modèle de base et reste amovible. Et aucune méthode n’apprend une règle à partir d’exemples inexistants : aucun enregistrement ne montre les règles H2 à H5 ou un billet en français. Plus de nombres entraînables n’ajoutent pas d’exemples.

Ce qui changerait la réponse : supposez que la perte d’entraînement et la perte de validation restent toutes deux élevées. L’adaptateur est alors trop petit pour s’ajuster même aux données d’entraînement. Augmentez le rang ou ajoutez des couches, puis mesurez de nouveau. Le module 4 entraîne le rang 8 et montre ses courbes.

À vous : un adaptateur sur une couche à propagation avant

Section intitulée « À vous : un adaptateur sur une couche à propagation avant »

Kwame demande ce qu’entraînerait le rang 8 sur gate_proj seulement. Prédisez-le à la main à partir de la forme dans la sortie ci-dessus. Puis exécutez :

Fenêtre de terminal
python -m adapt params --rank 8 --targets gate_proj
Afficher la réponse

gate_proj mesure 1536 × 576. Un bloc entraîne 8 × (576 + 1536) = 16 896 nombres, et 30 blocs en entraînent 506 880. La commande affiche :

LoRA rank 8 on gate_proj 506,880 0.38% 2.0

Une seule couche large à propagation avant entraîne plus de nombres que q_proj et v_proj ensemble (460 800), car son côté out vaut 1 536.

Erreur courante

Un nom de couche qui n'existe pas

Symptôme : Sam veut les couches de requête et de valeur et tape des noms courts :

Fenêtre de terminal
python -m adapt params --rank 8 --targets q v
LoRA rank 8 on q, v 0 0.00% 0.0

Il n’y a pas d’erreur. L’adaptateur n’entraîne rien.

Cause : les noms doivent correspondre exactement aux noms des couches du modèle. Aucune couche ne s’appelle q ou v, donc aucune ne reçoit d’adaptateur.

Correction : copiez les noms de la ligne Linear layers in one block (couches linéaires dans un bloc) : --targets q_proj v_proj. Avant un entraînement, vérifiez que le compte des nombres entraînables n’est pas zéro. La commande train du module 4 l’affiche d’abord : 460,800 of 134,975,808 parameters trainable (0.34%) (460 800 paramètres entraînables sur 134 975 808, soit 0,34 %). Le total inclut l’adaptateur.

Vérifiez votre compréhension

Quels nombres changent avec le réglage fin complet, et lesquels avec LoRA? Pour SmolLM2-135M, quelle taille de fichier chaque méthode sauvegarde-t-elle pour une version?

Afficher la réponse

Le réglage fin complet peut changer les 134 515 008 poids. Chaque version est donc un modèle entièrement nouveau : 538,1 Mo en float32. LoRA gèle chaque poids du modèle. Il ajoute deux matrices minces, A et B, à côté des couches choisies, et entraîne seulement celles-ci. Le rang 8 sur q_proj et v_proj entraîne 460 800 nombres : un fichier de 1,8 Mo, utilisé avec le modèle de base inchangé.

Vérifiez votre compréhension

Prédisez : le cours passe du rang 8 au rang 32, sur les deux mêmes couches. Combien de nombres l'adaptateur entraîne-t-il, et quelle est la taille de son fichier? Que devient le modèle de base?

Afficher la réponse

Le compte suit le rang : 32 vaut 4 fois 8, donc 4 × 460 800 = 1 843 200 nombres. En float32, cela donne 1 843 200 × 4 octets, soit environ 7,4 Mo. Vous pouvez le vérifier avec python -m adapt params --rank 32. Le modèle de base ne change pas : ses 134 515 008 poids restent gelés, quel que soit le rang.

Vérifiez votre compréhension

Tomás veut le rang 64 parce que « plus de nombres entraînables apprennent plus ». Quelles observations vous feraient augmenter le rang? Quelles observations ne justifient pas de l'augmenter?

Afficher la réponse

Une raison : la perte d’entraînement et la perte de validation restent toutes deux élevées. L’adaptateur ne peut alors même pas s’ajuster à ses exemples d’entraînement, et une capacité accrue pourrait aider. Mesurez donc un rang plus élevé. Pas une raison : des erreurs sur des cas qu’aucun enregistrement d’entraînement ne montre, comme les billets en français ou les règles H2 à H5. Un adaptateur plus grand n’a aucun exemple pour les apprendre. Ces cas nécessitent de nouvelles données ou une autre méthode, pas un rang plus élevé.

Récapitulatif

  • Le réglage fin complet peut changer chaque poids : 134 515 008 nombres et une copie de 538,1 Mo par version pour SmolLM2-135M. Avec peu d’exemples, il risque l’oubli catastrophique.
  • Un adaptateur gèle le modèle et entraîne quelques nouveaux nombres. LoRA construit chaque modification avec deux matrices minces, A (rang × in) et B (out × rang) : rang × (in + out) nombres plutôt que out × in.
  • L’adaptateur du cours, de rang 8 sur q_proj et v_proj, entraîne 460 800 nombres (0,34 %) : un fichier de 1,8 Mo. python -m adapt params les compte à partir de model/config.json.
  • Les données, pas la mémoire, ont déterminé la méthode. Aucun rang n’ajoute d’exemples absents des données.

Ensuite, vous estimez la mémoire nécessaire à l’entraînement et voyez ce que changent la quantification et d’autres méthodes.

Leçon suivante : Mémoire, quantification et autres méthodes