Les modèles de langage économes en énergie n’ont besoin que d’additions

 (arxiv.org)
2 points par GN⁺ 2024-10-10 | 1 commentaires | Partager sur WhatsApp
  • L-Mul est un algorithme de multiplication à complexité linéaire qui part du constat que le coût énergétique élevé des LLM provient de la multiplication en virgule flottante, et cherche à l’approximer par des additions d’entiers
  • Une multiplication fp32 coûte 37 fois plus d’énergie qu’une addition int32 ; appliqué au matériel de traitement tensoriel, L-Mul pourrait réduire de 95 % l’énergie des multiplications tensorielles en virgule flottante élément par élément, et de 80 % celle des produits scalaires
  • Le mode de calcul omet la multiplication des mantisses et l’arrondi, traite le signe par XOR, et construit les bits restants sous forme d’addition x[1:] + y[1:] - offset
  • Dans les expériences, L-Mul avec mantisse 4 bits a montré une précision comparable à la multiplication float8 e4m3, tandis que L-Mul avec mantisse 3 bits a obtenu de meilleurs résultats que float8 e5m2
  • En appliquant l’attention L-Mul à des LLM préentraînés sans entraînement supplémentaire, la perte moyenne sur les tâches d’inférence en langage naturel a été de 0,07 %, tandis que, sur les tâches de vision, la précision moyenne a augmenté de 0,12 %

Le goulot d’étranglement visé par L-Mul

  • Les grands réseaux de neurones consacrent une grande partie de leurs calculs à la multiplication tensorielle en virgule flottante, une opération plus coûteuse en énergie que l’addition
  • L-Mul est un algorithme de multiplication à complexité linéaire qui approxime la multiplication de nombres en virgule flottante par des additions d’entiers
  • Ses cibles d’application couvrent plusieurs étapes de calcul
    • Les multiplications internes au mécanisme d’attention
    • La multiplication de matrices
    • La multiplication élément par élément
  • Dans les LLM basés sur Transformer, l’attention a une complexité O(N²) par rapport à la longueur N du contexte d’entrée et, avec les multiplications de tenseurs de grande dimension, devient un goulot d’étranglement majeur pour l’efficacité du calcul

Coût énergétique par opération arithmétique

  • Le tableau des coûts d’opérations de Horowitz (2014) montre directement l’écart énergétique entre addition et multiplication
    • Addition int8 : 0,03 pJ
    • Addition int32 : 0,1 pJ
    • Addition fp16 : 0,4 pJ
    • Addition fp32 : 0,9 pJ
    • Multiplication int8 : 0,2 pJ
    • Multiplication int32 : 3,1 pJ
    • Multiplication fp16 : 1,1 pJ
    • Multiplication fp32 : 3,7 pJ
  • La multiplication fp32 consomme 4 fois plus d’énergie que l’addition fp32, et 37 fois plus que l’addition int32
  • Dans PyTorch, la précision d’accumulation par défaut des résultats de multiplication tensorielle est réglée sur fp32
  • En excluant les opérations d’I/O et de contrôle, approximer une multiplication fp32 par une addition int32 ramène la consommation d’énergie à environ 1/37 ≈ 2,7 %
  • Même en abaissant la précision d’accumulation à fp16, l’addition entière n’utilise qu’environ 4,7 % de l’énergie d’une multiplication en virgule flottante

Mode de calcul de L-Mul

  • Une multiplication classique en virgule flottante prend, pour deux nombres x et y, la forme suivante
    • (1 + xm) · 2^xe · (1 + ym) · 2^ye
    • Le résultat est composé de (1 + xm + ym + xm · ym) · 2^(xe+ye) et d’un XOR sur le signe
  • Le goulot d’étranglement du calcul est la multiplication des mantisses à m bits, de complexité O(m²)
  • L-Mul supprime xm · ym et l’approxime sous la forme suivante
    • (1 + xm + ym + 2^-l(m)) · 2^(xe+ye)
  • l(m) varie selon le nombre de bits de mantisse
    • m ≤ 3 : m
    • m = 4 : valeur distincte
    • m > 4 : valeur distincte
  • L’implémentation au niveau des bits se résume à une expression plus simple
    • Bit de signe : x[0] ⊕ y[0]
    • Bits restants : x[1:] + y[1:] - offset
  • Comme le format en virgule flottante gère implicitement 1 + xm, L-Mul peut, dans l’implémentation réelle, être constitué d’un seul additionneur
  • Si la somme des mantisses dépasse 2, la retenue est automatiquement transmise à l’exposant
  • Il réduit la quantité de calcul en contournant la multiplication des mantisses et l’étape d’arrondi nécessaires à la multiplication classique en virgule flottante

Application à l’attention des Transformers

  • L’attention basée sur L-Mul génère Q, K et V, puis remplace les multiplications de matrices du calcul d’attention par L-matmul
  • La forme du calcul est la suivante
    • K = H · Wk
    • Q = H · Wq
    • V = H · Wv
    • A = softmax[L-matmul(Q, Kᵀ) / √d]
    • H′ = L-matmul(A, H)
  • L-matmul est une multiplication de matrices dans laquelle toutes les multiplications en virgule flottante classiques sont implémentées avec L-Mul
  • Cette structure réduit l’utilisation des ressources de calcul en remplaçant les multiplications en virgule flottante par des additions d’entiers

Analyse de précision et de complexité, et résultats expérimentaux

  • L’analyse de précision consiste à évaluer jusqu’à combien de bits de fraction d’un nombre en virgule flottante L-Mul équivaut à conserver
  • Dans une analyse fondée sur des opérandes à distribution uniforme, L-Mul est plus précis que fp8 e5m2
  • Dans une analyse pratique basée sur la distribution combinée des poids de cinq LLM préentraînés, il peut atteindre une précision supérieure à fp8 e4m3 avec des opérandes à mantisse 5 bits
  • Les résultats expérimentaux concordent avec l’estimation théorique de l’erreur
    • L-Mul avec mantisse 4 bits offre une précision comparable à la multiplication float8 e4m3
    • L-Mul avec mantisse 3 bits offre une précision supérieure à float8 e5m2
  • Pour les LLM préentraînés, l’implémentation standard de l’attention a été directement remplacée par l’attention L-Mul, sans entraînement supplémentaire
    • Perte moyenne de performance sur les tâches de commonsense, structured reasoning et language understanding : 0,07 %
    • Variation moyenne de précision sur les tâches de visual question answering, object hallucination et free-form visual instruction : amélioration de 0,12 %
  • Dans les expériences de fine-tuning, un modèle où toutes les multiplications de l’attention, des transformations linéaires et des multiplications élément par élément étaient remplacées par L-Mul à mantisse 3 bits a obtenu des performances similaires à celles d’un modèle standard utilisant une précision d’accumulation float8 e4m3
  • Dans l’estimation de la quantité de calcul au niveau des portes, les multiplications classiques se situent aux niveaux suivants
    • Multiplication fp16 : environ 584
    • Multiplication fp8 e4m3 : environ 325
    • Multiplication fp8 e5m2 : environ 296
  • Les estimations de quantité de calcul au niveau des portes pour L-Mul sont plus faibles
    • L-Mul fp16 : environ 256
    • L-Mul fp8 : environ 157
  • Les GPU ne disposent pas d’implémentation native de L-Mul, ce qui rend difficile l’exploitation complète de son efficacité ; il est recommandé d’entraîner et d’héberger les modèles basés sur L-Mul sur des dispositifs intégrant une conception d’architecture spécialisée
  • Cette technologie est en statut patent pending

À lire aussi

1 commentaires

 
GN⁺ 2024-10-10
Avis Hacker News

  • Je me souviens qu’à l’époque où les calculs en virgule flottante coûtaient cher sur les CPU Intel, les programmeurs avaient plusieurs astuces à base d’entiers pour les contourner.
    Chuck Moore, connu pour Forth, montrait une méthode consistant à traiter des valeurs comme 1,6 × 4,1 sous forme d’entiers, par exemple 16 × 41, pendant les calculs intermédiaires, puis à remettre la virgule décimale au « bon endroit » lors de l’affichage. Tant que la plage des valeurs en virgule flottante ne dépassait pas 65536 même après multiplication par 10, cela fonctionnait bien avec des entiers 16 bits, et convenait aux puces embarquées qui devaient calculer rapidement plusieurs fois par seconde des valeurs analogiques avec une précision de 10 bits.
    J’ai aussi discuté il y a longtemps avec un ingénieur Microsoft qui avait travaillé sur Microsoft Streets and Trips ; il disait qu’eux aussi plaçaient des nombres et calculs qui auraient normalement été en virgule flottante dans une sorte de format entier compacté ne contenant que la précision réellement nécessaire, ce qui les rendait plus rapides sur les CPU de l’époque et plus faciles à compresser pour tenir sur un CD-ROM. Des captures d’écran sont disponibles sur https://archive.org/details/3135521376_qq_CD1

    • Cette technique s’appelle l’arithmétique en virgule fixe, et c’est une excellente méthode que davantage de programmeurs devraient connaître.
      Le code financier sérieux devrait l’utiliser, mais dans le secteur financier que j’ai vu, ce n’était pas très courant sauf quand il s’agissait de mainframes. Curieusement, j’ai vu beaucoup plus d’arithmétique en virgule fixe dans des rastériseurs logiciels comme FreeType, GDI, WPF ou WARP (le rastériseur de référence D3D11).
    • Je me souviens avoir manipulé FRACTINT, un générateur de fractales de l’époque où les coprocesseurs en virgule flottante n’étaient pas courants. Il calculait et affichait les fractales avec des maths en virgule fixe ; c’était une période où les fractales avaient l’air incroyablement cool, où tout le monde voulait se lancer dans le business des fractales et où tous les prix Nobel semblaient revenir aux chercheurs en fractales.
    • Ozaki a fait de la multiplication de matrices fp64 avec des tensor cores int8.
      https://arxiv.org/html/2306.11975v4
      Vraiment intéressant.
    • À ma connaissance, c’est encore aujourd’hui la meilleure façon de gérer l’argent ou les nombres financiers.
    • Cette astuce précise est connue sous le nom d’arithmétique en virgule fixe. C’est un concept différent des points fixes de fonctions.

  • L’affirmation est du genre « on peut potentiellement réduire le coût énergétique de 95 % pour la multiplication élément par élément de tenseurs en virgule flottante, et de 80 % pour le produit scalaire » ; si l’on parlait de réseaux de neurones convolutifs, l’optimisation du calcul aurait eu beaucoup plus de sens.
    Mais les transformers sont plutôt légers en calcul et lourds en mémoire. Le goulet d’étranglement est le transfert des poids du modèle vers les cœurs, et les économies d’énergie citées de 95 % et 80 % ne concernent que les opérations de multiplication prises isolément, pas l’ensemble du processus d’inférence.

    • Le prefill reste dominé par le calcul, même avec un seul batch, tout comme le décodage multi-batch.
      Le refrain selon lequel « l’inférence des transformers decoder-only est limitée par la bande passante mémoire » n’est strictement vrai que pour le décodage en batch unique de taille 1. Dans ce cas, on fait surtout des produits vecteur-matrice.
    • C’est pire que ça. Le gain énergétique est mesuré par rapport à du calcul fp32, alors qu’en fp8 les multiplicateurs sont vraiment petits, et les additionneurs et shifters représentent une part plus importante de l’énergie et de la surface de l’unité de calcul ; les gains de cet article seraient donc plus faibles.
      En fp8, le nombre de portes estimé est de 296 pour un multiplicateur fp8 classique, contre 157 avec cette technique, donc le gain de puissance sur le multiplicateur serait bien plus faible. Une estimation d’environ 50 % serait plus raisonnable et, encore une fois, en fp8 l’addition représente une grosse partie des opérations dans un produit scalaire.
      Globalement, revendiquer un gain de puissance de 80 % avec une faible baisse de précision me semble assez malhonnête. Le gain de puissance ne s’applique qu’aux opérations fp32, tandis que la faible baisse de précision ne s’applique qu’à l’opérateur fp8. Ils n’ont pas analysé la perte de précision en fp32, ni présenté la puissance économisée dans les produits scalaires fp8.
    • Le fp8 est suffisamment petit pour que la multiplication puisse probablement être réalisée avec des circuits bien plus simples que pour des formats en virgule flottante plus grands.
      Pour des formats encore plus petits comme fp4, on pourrait simplement utiliser une table de correspondance, ce qui revient en pratique à quelque chose d’assez proche d’une méthode de quantification standardisée.
    • Une très bonne architecture pour les transformers semble être une forme de colocalisation de la mémoire et du calcul.
    • Ce n’est vrai que pour un utilisateur unique ou une inférence légère. Pour l’entraînement et l’inférence par lots, on peut très vite se retrouver avec un goulet d’étranglement côté calcul.

  • [2023] GradIEEEnt half decent: The hidden power of imprecise lines
    http://tom7.org/grad/murphy2023grad.pdf
    Il y a aussi une vidéo : https://www.youtube.com/watch?v=Ae9EKCyI1xU

    • Il y avait aussi d’anciens posts HN.
      GradIEEEnt half decent: The hidden power of imprecise lines [video] - https://news.ycombinator.com/item?id=36806970 - juillet 2023, 9 commentaires
      GradIEEEnt half decent - https://news.ycombinator.com/item?id=35780921 - mai 2023, 32 commentaires
    • J’aurais aimé que l’article le cite comme un « travail étayant une exploration précédente » ou quelque chose du genre, mais malheureusement ce n’était pas le cas.

  • Je ne l’ai pas lu, mais j’ai l’impression que cela utilise une forme ou une autre de table de logarithmes.
    Ce n’est pas pour dénigrer ; je pose la question parce que j’ai l’impression de ne pas vraiment comprendre les logarithmes à un niveau plus fondamental, comme celui des portes logiques. Si l’on peut remplacer la multiplication par une consultation de table et une addition, alors, inversement, il devrait aussi exister des circuits offrant une addition difficile et une multiplication facile, ou des combinaisons de ces compromis.

    • L’espace logarithmique est intéressant, parce qu’il permet de remplacer la multiplication par l’addition.
      Cette partie est simple, et n’importe qui peut l’implémenter en matériel. La partie délicate, c’est l’accumulation, surtout quand on accumule sur une grande plage tout en restant en permanence dans l’espace logarithmique.
    • Oui, c’est ainsi que fonctionne un système de nombres logarithmiques.

  • Je trouve étrange que l’article ne semble pas contenir de dérivation ni de discussion correcte du terme d’erreur. Tout est traité seulement indirectement à travers les résultats d’inférence.

    • Moi aussi, cet article m’a paru un peu étrange. Quand on ne donne l’estimation des portes que sous forme d’explication textuelle, sans schéma, il est trop facile de rater des éléments nécessaires.
      Même sans aller jusqu’à une description complète au niveau des portes, il aurait fallu un diagramme avec des blocs étiquetés comme « additionneur ». Voir le nom de Vries dès le premier paragraphe n’a pas non plus aidé à inspirer confiance.

  • Une note de bas de page de la section méthode indique que les « modèles basés sur L-Mul » sont recommandés pour l’entraînement et l’hébergement sur des appareils intégrant une conception d’architecture spécialisée. Brevet en cours de dépôt.

  • La quantité de calcul semble devoir diminuer, mais comme cela utilise toujours 8 bits par valeur, cela ne réduit pas les besoins mémoire nécessaires à l’exécution de l’inférence.
    Il est donc difficile de dire que cela rend les modèles plus accessibles pour l’inférence. Si ce mode de stockage convient aussi à l’entraînement, cela pourrait avoir des applications potentiellement intéressantes.

    • En réalité, du point de vue de la précision et de la plage, c’est environ 0,5 bit moins efficace par poids, et l’article ne met pas du tout cet aspect en avant.

  • Déplacer des octets consomme plus de 10 fois plus d’énergie que le calcul. L’efficacité du calcul n’est pas un problème aussi important que les gens le pensent.
    Pour l’instant, le calcul est simplement au mauvais endroit ; au moins pour l’agrégation initiale des produits scalaires, il devrait contourner le bus mémoire et se trouver juste à côté des cellules mémoire.

    • Cela pourrait quand même être utile pour des appareils contraints par la batterie, non ?

  • D’après mon expérience, les vrais magiciens des maths en virgule fixe étaient les concepteurs de jeux vidéo 8 bits et 16 bits.
    Les optimisations qu’ils réalisaient étaient stupéfiantes et ont par exemple permis de calculer en temps réel des maths matricielles 3D pour créer les premiers simulateurs de vol et jeux de tir à la première personne.

    • Redéfinir les angles avec 2π = 256 était une astuce assez ingénieuse.