Programme Leçon 204 sur 250 · Le fine-tuning, en concepts
Le fine-tuning, en concepts

Empreinte mémoire : 4 bits contre 16 bits

Voici l'arithmétique qui décide si un modèle tient seulement sur ton matériel, et pourquoi les modèles « quantifiés » sont partout. Les poids d'un modèle ne sont que des nombres, et chaque nombre prend un certain nombre d'octets selon sa précision. L'empreinte est simple :

bytes = params * bits_per_param / 8
# (8 bits per byte)

L'entraînement et l'inférence en pleine précision utilisent souvent des floats sur 16 bits (2 octets chacun). Pour faire tourner un modèle sur un portable ou un téléphone, tu le quantifies : tu stockes chaque poids sur moins de bits. La quantification sur 4 bits utilise un quart des octets, parce que 4 bits, c'est un quart de 16 bits. Même nombre de paramètres, un quart de la mémoire.

Fais le calcul pour un modèle de 7 milliards de paramètres :

16-bit: 7e9 * 16 / 8 = 1.4e10 bytes  ~= 13.04 GiB
 4-bit: 7e9 *  4 / 8 = 3.5e9  bytes  ~=  3.26 GiB   (exactly 1/4)

C'est la différence entre un modèle qui a besoin d'un gros GPU et un modèle qui tourne sur un portable. C'est exactement pour ça qu'un assistant sur l'appareil (comme celui qui fait tourner le tuteur IA de ce cours) est livré avec un modèle en 4 bits : le coût en qualité est faible, le gain en mémoire et en bande passante est énorme. C'est aussi pour ça que le fine-tuning économe en paramètres (LoRA) est attirant : tu ne stockes et ne livres jamais que quelques petits poids d'adaptateur par-dessus une base gelée, éventuellement quantifiée.

Ce que la formule simple laisse de côté. Elle ne compte que les poids, donc considère-la comme un plancher. Les vrais formats en 4 bits stockent aussi une échelle pour chaque petit groupe de poids, ce qui les amène à environ 4.5 à 5 bits par poids (un modèle de 7B est plus proche de 4 GiB que de 3.26). Faire tourner le modèle demande de la place pour le cache KV, qui grandit avec la longueur du contexte. Et l'entraînement demande bien plus que les poids : le fine-tuning complet avec l'optimiseur Adam garde des gradients et deux états d'optimiseur par poids, environ 16 octets par paramètre en précision mixte, donc à peu près 100 GiB pour un modèle de 7B avant même les activations. Cet écart est la vraie raison d'être de LoRA et du fine-tuning quantifié.

On donne l'empreinte en GiB (gibioctets), en divisant les octets par 1024 ** 3. Garde un float exact, n'arrondis pas, pour que les relations ci-dessous tiennent précisément.

Construis deux fonctions.

  • model_memory(params, bits_per_param) -> l'empreinte en GiB sous forme de float : params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, où before_gb et after_gb sont les deux empreintes et ratio vaut from_bits / to_bits (combien de fois le modèle quantifié est plus petit).

Les maths sont réelles et notables ; l'entraînement sur GPU qu'elles permettent, ce bac à sable ne peut pas le faire tourner. Appuie sur Run pour afficher l'empreinte d'un modèle de 7B à quelques précisions.

À ton tour

Écris model_memory(params, bits_per_param) qui renvoie l'empreinte en GiB sous forme de float (params * bits_per_param / 8 / (1024 ** 3)), et quantization_savings(params, from_bits, to_bits) qui renvoie {"before_gb", "after_gb", "ratio"}, où les deux empreintes viennent de model_memory et ratio vaut from_bits / to_bits. N'arrondis pas ; garde des floats exacts pour que 4 bits donne exactement un quart de 16 bits.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.