Automated Numerical Stability Analysis of Deep Learning Operators

Imaginez que vous construisez un château géant et complexe avec de minuscules briques Lego légèrement bancales. Dans le monde de l'informatique, ces briques sont des nombres, et le château est un modèle de « deep learning » (apprentissage profond) — un cerveau super intelligent capable de reconnaître des chats, d'écrire des poèmes ou de conduire des voitures. Pendant longtemps, les scientifiques ont construit ces châteaux en utilisant de grosses briques solides et doubles (appelées « double précision ») qui étaient très précises mais lourdes et lentes à déplacer. Pour rendre les choses plus rapides et économiser de l'énergie, les ingénieurs ont commencé à utiliser des briques plus petites et plus légères (appelées « précision réduite »). C'est comme remplacer la pierre lourde par de la mousse légère ; le château s'élève beaucoup plus vite, mais il y a un bémol : les briques de mousse sont un peu spongieuses. Si vous les empilez mal, ou si vous essayez de faire tenir un petit caillou sur un énorme bloc de mousse, tout l'édifice risque de vaciller, de s'effondrer ou de donner un résultat qui semble correct mais qui est en réalité un peu « pollué » par des erreurs.

C'est le problème de l'« instabilité numérique ». Ce n'est pas que l'ordinateur est cassé ; c'est que les mathématiques deviennent floues lorsque vous essayez de les effectuer avec moins de chiffres. Parfois, un ordinateur peut soustraire deux nombres énormes, presque identiques, pour trouver une différence minuscule, et dans le processus, il peut accidentellement jeter toute l'information importante, ne laissant derrière lui que du bruit. Pendant longtemps, comprendre exactement où dans un réseau neuronal massif et complexe ce vacillement se produit a été comme essayer de trouver une brique lâche dans un château pendant que celui-ci est en construction, dans l'obscurité. Vous savez que le château tremble, mais vous ne voyez pas quelle brique en est la cause.

Entrez en scène un nouvel outil appelé noisefloat, créé par des chercheurs de Sorbonne Université. Considérez cet outil comme des lunettes de « test de résistance » magiques pour votre château Lego. Au lieu de construire le château une seule fois, l'outil construit trois versions légèrement différentes du même château exact en même temps, en utilisant de minuscules poussées aléatoires sur les briques pour voir comment elles réagissent. Si les trois versions finissent par se ressembler presque parfaitement, les briques sont stables. Mais si l'une des versions s'effondre ou ressemble totalement aux autres, l'outil pointe instantanément du doigt la brique spécifique (ou l'« opérateur ») qui est bancale. Les chercheurs ont utilisé cet outil pour tester des modèles de deep learning et ont découvert qu'il peut identifier avec succès ces briques cachées et instables, même au milieu d'un processus d'entraînement complexe. Ils ont montré que si certains tours mathématiques sont sûrs, d'autres — comme essayer d'annuler de grands nombres pour en trouver un minuscule — sont dangereux et peuvent ruiner la précision du modèle sans que personne ne s'en aperçoisse avant qu'il ne soit trop tard.

La magie des nombres « bruyants »

Le deep learning est partout aujourd'hui, des filtres sur les photos de vos téléphones aux chatbots avec lesquels vous discutez. Mais pour rendre ces systèmes assez rapides pour fonctionner sur votre téléphone ou dans un centre de données, les scientifiques utilisent la « précision réduite ». Imaginez que vous mesuriez la longueur d'une pièce. Si vous utilisez une règle avec des graduations tous les millimètres (haute précision), vous obtenez un nombre très exact. Si vous utilisez une règle avec des graduations uniquement tous les centimètres (basse précision), vous gagnez du temps, mais votre mesure est un peu plus floue. En informatique, cela signifie utiliser moins de « bits » (ces petits 0 et 1) pour stocker les nombres. Cela rend les calculs plus rapides et consomme moins d'énergie, mais cela introduit des « erreurs d'arrondi ».

Habituellement, ces erreurs sont si petites qu'elles n'ont pas d'importance. Mais parfois, elles s'accumulent ou sont amplifiées, menant à une « instabilité numérique ». C'est comme essayer de faire tenir un château de cartes dans une pièce venteuse ; un petit coup de vent (une erreur d'arrondi) peut tout renverser. Le problème est qu'en deep learning, ces erreurs peuvent survenir silencieusement. Le modèle peut encore sembler fonctionner, mais son calcul interne est en fait « pollué », ce qui pourrait entraîner des erreurs étranges plus tard.

La solution : Un système de triple vérification

L'article présente noisefloat, un outil logiciel qui agit comme un détective pour ces erreurs mathématiques cachées. L'idée centrale provient d'une méthode appelée CESTAC (Control and Estimation of Stochastic Arithmetic). Voici comment cela fonctionne en termes simples :

Au lieu d'exécuter un calcul une seule fois, noisefloat l'exécute trois fois simultanément. Mais voici l'astuce : dans chacune des trois exécutions, il ajoute une petite « poussée » aléatoire aux nombres. C'est comme demander à trois personnes différentes de mesurer la même table, mais en donnant à chacune d'elles une règle légèrement différente qui est décalée d'une quantité microscopique.

• Si les trois personnes obtiennent presque exactement la même réponse, la mesure est stable. Les petites poussées n'ont pas changé le résultat, ce qui signifie que le calcul est solide.
• Si les trois personnes obtiennent des réponses très différentes, la mesure est instable. Le calcul est si sensible qu'une petite poussée a complètement changé le résultat.

L'outil calcule ensuite combien de « chiffres significatifs » (nombres fiables) restent dans le résultat. Si la réponse est de « zéro chiffre fiable », cela signifie que le résultat n'est que du bruit.

Ce qu'ils ont trouvé : Les « briques bancales »

Les chercheurs ont testé cet outil sur diverses parties de modèles de deep learning, qui sont composés de nombreuses petites opérations mathématiques appelées « opérateurs » (comme l'addition de nombres, la multiplication de matrices ou la normalisation de données). Ils ont créé des cas « pathologiques » — des problèmes mathématiques conçus pour être instables intentionnellement — pour voir si l'outil pouvait les trouver.

1. Le piège de la « l'annulation »
L'un des plus grands dangers est l'« annulation catastrophique ». Cela se produit lorsqu'on soustrait deux grands nombres qui sont presque identiques pour trouver une petite différence.

• L'analogie : Imaginez que vous avez deux piles de 1 000 000 de briques Lego. Vous retirez 999 999 de chaque côté. Il vous reste 1 brique. Mais si votre règle est un peu imprécise, vous pourriez accidentellement compter 999 999,5 comme 999 999 dans une pile et 999 999,5 comme 1 000 000 dans l'autre. Maintenant, vous pensez qu'il reste 0 brique, ou peut-être même un nombre négatif !
• Le résultat : L'outil a découvert que lorsque les modèles tentaient de faire ce genre de soustraction (comme dans certaines couches linéaires ou mécanismes d'attention), le nombre de chiffres fiables tombait à zéro. L'outil a réussi à signaler ces opérations comme étant « polluées ».

2. Le désastre de l'« overflow » (dépassement de capacité)
Certaines opérations, comme la fonction « Softmax » (utilisée pour transformer des nombres en probabilités), peuvent exploser si les nombres deviennent trop grands.

• L'analogie : C'est comme essayer de verser un seau d'eau dans un dé à coudre. Si l'eau (le nombre) est trop grande, elle déborde (overflow) et le dé à coudre se casse.
• Le résultat : Les chercheurs ont testé une version « naïve » de Softmax qui ne protège pas contre les grands nombres. L'outil a immédiatement signalé 0 chiffre significatif et l'a marqué comme instable. Cependant, une version « décalée » de Softmax (qui soustrait d'abord un grand nombre pour garder les valeurs petites) est restée stable, conservant environ 3 à 12 chiffres significatifs selon la précision utilisée.

3. Le problème du « match nul proche »
Dans les mécanismes d'« Attention » (qui aident les modèles à se concentrer sur les mots importants), le modèle calcule des scores pour décider à quoi prêter attention. Si deux scores sont presque identiques, le calcul devient très sensible.

• Le résultat : Lorsque les chercheurs ont créé un scénario où deux scores étaient presque à égalité, l'outil a détecté une chute massive de la fiabilité. La « décision » du modèle (quel mot focaliser) devenait aléatoire car le calcul était trop bancal pour faire la différence.

Est-ce que cela casse le modèle ?

Une question clé est la suivante : si le calcul est bancal à l'intérieur, est-ce que la réponse finale (comme reconnaître un chat) fonctionne toujours ?
Les chercheurs ont lancé des simulations d'entraînement complètes sur des jeux de données comme Fashion-MNIST (images de vêtements) et CIFAR-10 (objets colorés). Ils ont inséré ces opérateurs « bancals » dans les modèles et ont observé ce qui se passait.

• Local vs Global : Ils ont découvert que parfois, un opérateur perdait tous ses chiffres fiables (devenait du pur bruit), mais que la précision finale du modèle ne chutait pas immédiatement. C'est comme avoir une jambe tremblante sur un robot, mais le robot peut toujours marcher parce que les autres jambes sont assez fortes pour compenser.
• Le signal d'alarme : Cependant, lorsque l'instabilité était sévère (comme dans le cas de l'attention de type « match nul proche »), les prédictions du modèle commençaient à diverger. L'outil a réussi à prédire que le modèle allait échouer avant même qu'il ne le fasse réellement.

Le compromis : Vitesse vs Sécurité

Il y a un coût à l'utilisation de cet outil. Parce qu'il exécute le calcul trois fois (ou plus) pour vérifier la stabilité, il est plus lent. L'article note que cela peut entraîner un ralentissement de 3x à 100x par rapport à un calcul normal, selon la précision de la vérification.

• Le verdict : Les auteurs suggèrent de ne pas utiliser cet outil sur l'ensemble de votre jeu de données d'entraînement à chaque fois (cela prendrait trop de temps). Au lieu de cela, ils recommandent de l'utiliser sur un petit « sous-ensemble de calibration » pour trouver les opérateurs dangereux, puis de corriger ces parties spécifiques du modèle.

Conclusion

L'article ne prétend pas avoir résolu tous les problèmes mathématiques du monde, mais il fournit une nouvelle lampe torche puissante. noisefloat permet aux développeurs de voir les fissures invisibles dans leurs modèles de deep learning. Il prouve qu'en utilisant une arithmétique stochastique (aléatoire), nous pouvons détecter automatiquement quelles parties d'un réseau neuronal sont numériquement instables. C'est crucial pour construire une IA qui soit non seulement rapide, mais aussi fiable et sûre, surtout alors que nous nous dirigeons vers l'utilisation de matériel encore plus petit, plus rapide et plus économe en énergie. L'outil suggère qu'avec les bons contrôles, nous pouvons construire des châteaux en briques de mousse qui sont aussi solides que ceux faits de pierre.