L'IA révolutionnée par la sparsité : vers des modèles plus efficaces

L'essor des modèles d'IA et leurs défis énergétiques

Dans le domaine de l'intelligence artificielle, la taille des modèles est souvent synonyme de puissance. Les modèles de langage, ou LLMs, sont au cœur de cette dynamique. Cependant, l'augmentation de leur taille ne va pas sans poser des problèmes. Bien que certains spécialistes soulignent que l'accroissement de la taille des modèles peut entraîner des rendements décroissants en termes de performance, les entreprises continuent de développer des outils de plus en plus volumineux. Par exemple, la dernière version de Llama, développée par Meta, se distingue par ses 2 trillions de paramètres.

Cette croissance exponentielle des modèles s'accompagne d'une augmentation des besoins en énergie et du temps nécessaire pour les faire fonctionner, ce qui alourdit considérablement leur empreinte carbone. Face à ces défis, les chercheurs ont exploré la possibilité de créer des modèles plus petits, utilisant des nombres de précision inférieure pour les paramètres, afin de réduire la consommation d'énergie.

Cependant, une autre approche prometteuse consiste à exploiter les zéros présents dans ces modèles massifs. En effet, dans de nombreux modèles, une grande partie des paramètres, tels que les poids et les activations, sont soit des zéros, soit si proches de zéro qu'ils peuvent être traités comme tels sans compromettre la précision. Cette caractéristique, connue sous le nom de sparsité, offre une opportunité de réduire considérablement les besoins en calcul : au lieu de gaspiller du temps et de l'énergie à multiplier ou additionner des zéros, ces opérations peuvent être omises, et seuls les paramètres non nuls doivent être stockés en mémoire.

La sparsité : un concept clé pour l'efficacité

Les réseaux neuronaux et les données qu'ils manipulent sont souvent représentés sous forme de tableaux numériques, qui peuvent être des vecteurs, des matrices ou des tenseurs. Lorsqu'un tableau contient principalement des zéros, il est qualifié de sparse. La sparsité peut être naturelle ou induite. Par exemple, un réseau social est naturellement sparse : chaque nœud représente une personne et chaque lien une amitié, mais la plupart des gens ne sont pas amis entre eux, ce qui se traduit par une matrice majoritairement composée de zéros.

Dans le cas d'une matrice de quatre par quatre, elle occupe 16 espaces en mémoire, quelle que soit la proportion de zéros. Si elle est sparse, elle peut être plus efficacement représentée sous forme de fibertree, une structure qui ne stocke que les coordonnées et les valeurs non nulles. Cette méthode permet de réduire l'espace mémoire nécessaire.

Outre la sparsité naturelle, il est possible d'induire la sparsité dans un modèle d'IA. Par exemple, l'entreprise Cerebras a démontré qu'il est possible de mettre jusqu'à 70 à 80 % des paramètres d'un modèle de langage à zéro sans perte de précision significative, comme cela a été réalisé avec le modèle Llama 7B de Meta.

Les avantages de la sparsité

L'efficacité du calcul sparse repose sur deux principes fondamentaux : la compression des zéros et les propriétés mathématiques des zéros. Les algorithmes et le matériel dédiés au calcul sparse exploitent ces deux idées.

Premièrement, les données sparse peuvent être compressées, ce qui rend leur stockage en mémoire plus efficace. Par exemple, une matrice de quatre par quatre avec seulement trois éléments non nuls nécessite traditionnellement 16 espaces mémoire. En la compressant, seuls les éléments non nuls sont conservés, réduisant ainsi l'espace mémoire requis.

Deuxièmement, les propriétés mathématiques du zéro permettent d'éviter de nombreux calculs. Multiplier un nombre par zéro donne toujours zéro, donc la multiplication peut être omise. De même, ajouter zéro à un nombre ne change pas ce nombre, ce qui permet d'éviter l'addition.

Dans le cadre d'une multiplication matrice-vecteur, une opération courante dans les charges de travail d'IA, seuls les calculs impliquant des éléments non nuls sont nécessaires. Par exemple, dans une matrice de quatre par quatre et un vecteur de quatre nombres, seules deux multiplications sont nécessaires dans un calcul sparse, contre 16 dans un calcul dense.

Les limites des GPU et CPU actuels

Malheureusement, le matériel informatique moderne n'est pas conçu pour tirer pleinement parti de la sparsité. Par exemple, dans une multiplication matrice-vecteur, un CPU classique multiplierait chaque élément du vecteur séquentiellement, ce qui est lent. Les CPU avec support vectoriel ou les GPU permettent d'effectuer ces multiplications en parallèle, accélérant ainsi le processus. Cependant, si les données sont extrêmement sparse, ces dispositifs passent la plupart de leur temps à multiplier par zéro, ce qui est inefficace.

Les GPU modernes peuvent exploiter la sparsité, mais seulement sous une forme particulière appelée sparsité structurée, qui suppose que deux des quatre paramètres adjacents sont nuls. Cependant, certains modèles bénéficient davantage de la sparsité non structurée, où n'importe quel paramètre peut être nul, indépendamment de sa position. Les GPU peuvent exécuter des calculs spars non structurés via des bibliothèques logicielles comme cuSparse, mais le support est souvent limité, et le matériel est sous-utilisé, gaspillant ainsi de l'énergie.

Les CPU modernes, bien que plus flexibles, sont souvent ralentis par les recherches indirectes nécessaires pour trouver les données non nulles. Ils préchargent des données en fonction de ce qu'ils anticipent avoir besoin, mais...

L'innovation de Stanford : un matériel révolutionnaire

À l'Université de Stanford, un groupe de chercheurs a franchi une étape significative en développant un matériel capable de gérer efficacement tous types de charges de travail, qu'elles soient sparse ou traditionnelles. Ce matériel innovant a été conçu pour exploiter pleinement la sparsité, permettant ainsi de réaliser des économies d'énergie considérables.

Les résultats obtenus avec ce nouveau matériel sont impressionnants. En moyenne, la puce développée consomme un soixantième de l'énergie nécessaire à un CPU classique, tout en exécutant les calculs huit fois plus rapidement. Cette avancée a été rendue possible grâce à une réinvention complète du matériel, du firmware de bas niveau et du logiciel d'application, tous repensés pour tirer parti de la sparsité.

Les chercheurs de Stanford espèrent que cette innovation n'est que le début d'une nouvelle ère de développement de matériel et de modèles d'IA plus économes en énergie. En optimisant l'utilisation de la sparsité, ils ouvrent la voie à des modèles d'IA qui non seulement maintiennent des performances élevées, mais réduisent également leur impact environnemental.

Qu'est-ce que la sparsité ?

Les réseaux neuronaux, ainsi que les données qui les alimentent, sont représentés sous forme de tableaux de nombres. Ces tableaux peuvent être unidimensionnels (vecteurs), bidimensionnels (matrices) ou plus (tensors). Un vecteur, une matrice ou un tenseur sparse contient principalement des éléments nuls. Le niveau de sparsité varie, mais lorsque les zéros représentent plus de 50 % de n'importe quel type de tableau, il peut bénéficier de méthodes de calcul spécifiques à la sparsité. En revanche, un objet qui n'est pas sparse — c'est-à-dire qui a peu de zéros par rapport au nombre total d'éléments — est appelé dense.

La sparsité peut être naturellement présente ou induite. Par exemple, un graphe de réseau social sera naturellement sparse. Imaginez un graphe où chaque nœud (point) représente une personne, et chaque arête (un segment de ligne reliant les points) représente une amitié. Comme la plupart des gens ne sont pas amis les uns avec les autres, une matrice représentant tous les arêtes possibles sera principalement composée de zéros. D'autres applications populaires de l'IA, telles que d'autres formes d'apprentissage par graphe et les modèles de recommandation, contiennent également une sparsité naturellement présente.

Normalement, une matrice de quatre par quatre occupe 16 espaces en mémoire, quelle que soit la quantité de valeurs nulles. Si la matrice est sparse, c'est-à-dire qu'une grande fraction des valeurs est nulle, elle est plus efficacement représentée sous forme d'un fibertree : un "fibre" de coordonnées i représentant les lignes contenant des éléments non nuls, relié à des fibres de coordonnées j représentant les colonnes avec des éléments non nuls, se connectant enfin aux valeurs non nulles elles-mêmes. Pour stocker un fibertree en mémoire informatique, les "segments", ou points d'extrémité, de chaque fibre sont sauvegardés avec les coordonnées et les valeurs.

Au-delà de la sparsité naturellement présente, la sparsité peut également être induite dans un modèle d'IA de plusieurs manières. Il y a deux ans, une équipe de Cerebras a montré qu'il est possible de mettre jusqu'à 70 à 80 % des paramètres d'un LLM à zéro sans perdre de précision. Cerebras a démontré ces résultats spécifiquement sur le modèle Llama 7B de Meta, mais les idées s'étendent à d'autres modèles LLM comme ChatGPT et Claude.

L'argument en faveur de la sparsité

L'efficacité du calcul sparse découle de deux propriétés fondamentales : la capacité à compresser les zéros et les propriétés mathématiques pratiques des zéros. Les algorithmes utilisés dans le calcul sparse et le matériel qui leur est dédié tirent parti de ces deux idées de base.

D'abord, les données sparse peuvent être compressées, rendant leur stockage plus efficace en mémoire. La compression rend également le déplacement des données plus économe en énergie lorsqu'il s'agit de grandes quantités. Par exemple, une matrice de quatre par quatre avec trois éléments non nuls serait traditionnellement stockée en mémoire telle quelle, occupant 16 espaces. Cette matrice peut également être compressée en un type de données sparse, éliminant les zéros et ne conservant que les éléments non nuls. Dans notre exemple, cela donne 13 espaces mémoire au lieu de 16 pour la version dense non compressée. Ces économies en mémoire augmentent avec la sparsité et la taille de la matrice.

Multiplier un vecteur par une matrice prend traditionnellement 16 étapes de multiplication et 16 étapes d'addition. Avec un format de nombre sparse, le coût computationnel dépend du nombre de valeurs non nulles qui se chevauchent dans le problème. Ici, l'ensemble du calcul est réalisé en trois étapes de recherche et deux étapes de multiplication.

En plus des valeurs de données réelles, les données compressées nécessitent également des métadonnées. Les emplacements des lignes et des colonnes des éléments non nuls doivent également être stockés. Cela est généralement considéré comme un "fibertree" : les étiquettes de ligne contenant des éléments non nuls sont listées et liées aux étiquettes de colonne des éléments non nuls, qui sont ensuite liées aux valeurs stockées dans ces éléments.

En mémoire, les choses deviennent un peu plus compliquées : les étiquettes de ligne et de colonne pour chaque valeur non nulle doivent être stockées ainsi que les "segments" qui indiquent combien de telles étiquettes s'attendre, afin que les métadonnées et les données puissent être clairement délimitées.

Dans un type de données de matrice dense non compressée, les valeurs peuvent être accessibles soit une à la fois, soit en parallèle, et leurs emplacements peuvent être calculés directement avec une simple équation. Cependant, accéder à des valeurs dans des données compressées et sparse nécessite de rechercher les coordonnées de l'index de ligne et d'utiliser cette information pour rechercher "indirectement" les coordonnées de l'index de colonne avant d'atteindre finalement la valeur. Selon les emplacements réels des valeurs de données sparse, ces recherches indirectes peuvent être extrêmement aléatoires, rendant le calcul dépendant des données et nécessitant l'allocation de recherches mémoire à la volée.

Deuxièmement, deux propriétés mathématiques du zéro permettent aux logiciels et au matériel de sauter beaucoup de calculs. Multiplier n'importe quel nombre par zéro donnera un zéro, donc il n'est pas nécessaire de faire la multiplication. Ajouter zéro à n'importe quel nombre renverra toujours ce nombre, donc il n'est pas nécessaire de faire l'addition non plus.

Dans la multiplication matrice-vecteur, l'une des opérations les plus courantes dans les charges de travail d'IA, tous les calculs sauf ceux impliquant deux éléments non nuls peuvent simplement être omis. Prenons, par exemple, la matrice de quatre par quatre de l'exemple précédent et un vecteur de quatre nombres. Dans le calcul dense, chaque élément du vecteur doit être multiplié par l'élément correspondant dans chaque ligne, puis additionné pour calculer le vecteur final. Dans ce cas, cela nécessiterait 16 opérations de multiplication et 16 additions (ou quatre accumulations).

Dans le calcul sparse, seuls les éléments non nuls du vecteur doivent être pris en compte. Pour chaque élément non nul du vecteur, une recherche indirecte peut être utilisée pour trouver tout élément de matrice non nul correspondant, et seuls ceux-ci doivent être multipliés et additionnés. Dans l'exemple présenté ici, seules deux étapes de multiplication seront effectuées, au lieu de 16.

Les problèmes avec les GPU et les CPU

Malheureusement, le matériel moderne n'est pas bien adapté pour accélérer le calcul sparse. Par exemple, disons que nous voulons effectuer une multiplication matrice-vecteur. Dans le cas le plus simple, sur un seul cœur de CPU, chaque élément du vecteur serait multiplié séquentiellement puis écrit en mémoire. Cela est lent, car nous ne pouvons effectuer qu'une seule multiplication à la fois. C'est pourquoi les gens utilisent des CPU avec support vectoriel ou des GPU. Avec ce matériel, tous les éléments seraient multipliés en parallèle, accélérant considérablement l'application. Maintenant, imaginez que la matrice et le vecteur contiennent des données extrêmement sparse. Le CPU et le GPU vectorisés passeraient la plupart de leurs efforts à multiplier par zéro, effectuant des calculs complètement inefficaces.

Les générations plus récentes de GPU sont capables de tirer parti de la sparsité dans leur matériel, mais seulement d'un type particulier, appelé sparsité structurée. La sparsité structurée suppose que deux des quatre paramètres adjacents sont nuls. Cependant, certains modèles bénéficient davantage de la sparsité non structurée — la capacité pour n'importe quel paramètre (poids ou activation) d'être nul et compressé, peu importe où il se trouve et ce qui l'entoure. Les GPU peuvent exécuter des calculs spars non structurés dans le logiciel, par exemple, grâce à l'utilisation de la bibliothèque cuSparse pour GPU. Cependant, le support pour les calculs spars est souvent limité, et le matériel GPU est sous-utilisé, gaspillant des calculs énergivores sur des surcharges.

Lors de l'exécution de calculs spars dans le logiciel, les CPU modernes peuvent être une meilleure alternative au calcul GPU, car ils sont conçus pour être plus flexibles. Cependant, les calculs spars sur le CPU sont souvent freinés par les recherches indirectes utilisées pour trouver des données non nulles. Les CPU sont conçus pour "précharger" des données en fonction de ce qu'ils s'attendent à avoir besoin de la mémoire, mais...