Equivalence Checking of ML GPU Kernels
Cet article présente Volta, le premier vérificateur d'équivalence sonore et complet pour les noyaux GPU, qui vérifie formellement l'exactitude des calculs d'apprentissage automatique optimisés à la main, par des compilateurs ou par des LLM.
Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète
Dans l'immense machinerie invisible de l'intelligence artificielle moderne, le travail le plus critique ne se déroule pas dans le cloud, mais sur des puces informatiques spécialisées appelées GPU. Ces puces sont conçues pour effectuer des millions de calculs minuscules simultanément, une nécessité pour l'entraînement des grands modèles de langage qui écrivent désormais du code, traduisent des langues et génèrent de l'art. Pour que ces modèles fonctionnent assez rapidement pour être utiles, les ingénieurs doivent écrire des instructions hautement spécialisées, appelées noyaux (kernels), qui indiquent au GPU exactement comment déplacer les données et effectuer les calculs mathématiques. Au cours des dernières années, des entreprises ont commencé à utiliser l'intelligence artificielle elle-même pour écrire ces noyaux, espérant trouver des moyens plus rapides d'accomplir le travail que les ingénieurs humains. Cependant, cette rapidité s'accompagne d'un risque : lorsqu'une IA ou un compilateur réécrit un morceau de code pour le rendre plus rapide, il peut accidentellement introduire des erreurs subtiles. Ces erreurs pourraient amener l'ordinateur à produire un mauvais résultat ou, pire encore, à planter silencieusement de manières presque impossibles à détecter par des tests standards. Le défi central est que ces puces exécutent des milliers de fils d'exécution (threads) de travail en même temps, et si elles ne se coordonnent pas parfaitement, elles peuvent se marcher sur les pieds, créant une condition de concurrence (race condition) où le résultat final dépend de l'ordre imprévisible dans lequel les événements se produisent.
Une équipe de chercheurs a développé un nouvel outil appelé Volta pour résoudre ce problème. Au lieu de deviner si une nouvelle version plus rapide d'un noyau est correcte, Volta agit comme un vérificateur formel qui prouve mathématiquement que les deux versions produisent des résultats identiques. Les chercheurs ont construit un système qui prend les instructions de bas niveau d'un noyau de référence — la version originale et fiable — et du noyau optimisé — la nouvelle version plus rapide — et les fait passer par un moteur symbolique. Plutiment que de nourrir le code avec des nombres spécifiques pour voir ce qui en ressort, le moteur traite les entrées comme des symboles abstraits. Il trace chaque chemin possible que le code pourrait emprunter, suivant comment les données circulent à travers les milliers de fils parallèles et comment ils se synchronisent les uns avec les autres. Si le code tente d'accéder à la mémoire d'une manière qui pourrait causer un conflit, ou si les fils restent bloqués à attendre indéfiniment, l'outil signale immédiatement l'erreur. Si le code s'exécute sans erreur, l'outil traduit la sortie finale des deux noyaux en expressions mathématiques complexes et vérifie si ces expressions sont fondamentalement les mêmes, quels que soient les nombres spécifiques injectés en entrée.
Les chercheurs ont testé Volta sur une grande variété de tâches d'apprentissage automatique réelles, incluant les multiplications de matrices, les convolutions et les mécanismes d'attention qui alimentent les grands modèles de langage. Ils ont constaté que l'outil pouvait vérifier avec succès des noyaux optimisés à la main, par des compilateurs, et même par de grands modèles de langage. Dans un cas, ils ont examiné un noyau généré par une IA qui avait été optimisé par treize cycles d'amélioration automatisée. Volta a confirmé que ce code généré par l'IA était mathématiquement équivalent au noyau de référence écrit par l'humain, prouvant que les optimisations agressives n'avaient pas brisé la logique. L'outil a également prouvé sa valeur en détectant des erreurs que d'autres méthodes avaient manquées. Par exemple, il a détecté des conflits de données (data races) dans un tutoriel populaire et largement cité de programmation GPU, utilisé par des milliers de développeurs depuis des années. Ces erreurs étaient cachées car elles n'apparaissaient que sous des conditions de synchronisation très spécifiques que les tests standards capturent rarement. L'outil a également identifié un bug dans un noyau généré par l'IA où le code tentait de lire des données à partir d'un emplacement mémoire inexistant ; bien que le matériel actuel ait eu la particularité d'ignorer cette erreur, les chercheurs ont montré que le code était fondamentalement dangereux et pourrait échouer sur de futures machines.
La force de cette approche réside dans sa capacité à gérer la complexité unique de la programmation GPU, où des milliers de fils doivent coordonner leurs actions. Les outils précédents pouvaient vérifier des programmes mono-thread ou des opérations mathématiques de haut niveau, mais ils peinaient à décomposer le parallélisme massif d'un GPU en morceaux gérables. Volta surmonte cela en supposant que les noyaux qu'il analyse suivent un modèle spécifique et structuré courant dans l'apprentissage automatique, où le nombre de fils et la taille des données sont connus à l'avance. Dans ce cadre, l'outil peut prouver avec certitude qu'une condition de concurrence existe si les fils ne sont pas correctement synchronisés, et il peut prouver que deux versions différentes d'un programme sont équivalentes si elles produisent le même résultat symbolique. Les chercheurs ont démontré que leur outil pouvait vérifier ces propriétés en quelques secondes ou minutes, même pour des noyaux contenant des centaines de milliers d'instructions. Ils ont également prouvé que la logique mathématique derrière leur outil est saine, ce qui signifie que si l'outil affirme que deux programmes sont égaux, ils sont réellement égaux pour toutes les entrées possibles.
Ce travail représente une étape significative vers la sécurisation et la fiabilisation du développement de l'intelligence artificielle. Alors que les entreprises comptent de plus en plus sur des systèmes automatisés pour générer le code qui alimente leurs modèles, le besoin d'un moyen rigoureux pour vérifier ce code devient critique. Les chercheurs ont démontré qu'il est possible d'aller au-delà du simple test, qui ne peut vérifier qu'un nombre limité de scénarios, pour passer à une méthode qui fournit une garantie formelle de correction. En vérifiant l'équivalence des noyaux optimisés, Volta donne aux développeurs la confiance nécessaire pour utiliser des optimisations plus rapides et plus agressives sans craindre l'introduction de bugs silencieux. L'outil est actuellement disponible à l'utilisation, et les chercheurs ont rendu leur code et les preuves qui sous-tendent l'outil publics, permettant à d'autres de construire sur cette base. Bien que l'outil ne couvre pas encore tous les types de code GPU, il traite avec succès la vaste majorité des noyaux qui pilotent l'apprentissage automatique moderne, offrant un nouveau standard de confiance pour la génération automatisée de code de calcul haute performance.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.