Tensor Cores, Triton, réseaux résiduels et transformeurs de vision
Entre 2015 et aujourd'hui, l'apprentissage profond est passé du code GPU C++ réglé à la main et des réseaux convolutifs aux moteurs matriciels accélérés matériellement et aux architectures Transformer. Ces trois jalons définissent la conception et la mise à l'échelle des modèles d'IA modernes.
1. L'évolution du CUDA moderne : Tensor Cores et OpenAI Triton
En 2012, Alex Krizhevsky écrivait du CUDA C++ de bas niveau (cuda-convnet) pour calculer des opérations individuelles en virgule flottante sur des cœurs CUDA standards. Aujourd'hui, l'apprentissage profond repose sur du matériel matriciel spécialisé et des compilateurs de haut niveau.
- Des cœurs CUDA aux Tensor Cores. Les cœurs CUDA traditionnels effectuent une multiplication et une addition scalaires par cycle d'horloge. À partir de l'architecture Volta (2017), NVIDIA a introduit les Tensor Cores, qui multiplient de petites matrices entières (comme des blocs 4×4 ou 16×16) en un seul cycle d'horloge. Les Tensor Cores modernes utilisent des formats à précision mixte comme FP16, BF16 et FP8, accélérant les multiplications matricielles d'un ordre de grandeur.
- cuDNN et la sélection automatique des noyaux. Au lieu que les chercheurs écrivent leurs propres convolutions C++, la bibliothèque cuDNN de NVIDIA contient désormais des centaines de noyaux en assembleur précompilés. À l'exécution, des frameworks comme PyTorch mesurent les performances de différents algorithmes pour la forme exacte de votre tenseur et choisissent automatiquement la routine Tensor Core la plus rapide.
- OpenAI Triton (programmation GPU fondée sur Python). Écrire directement en CUDA C++ exige de gérer manuellement l'indexation des threads, les conflits de banques de mémoire partagée et la synchronisation des warps. Publié par OpenAI, Triton permet aux chercheurs d'écrire des noyaux GPU haute performance directement en Python. Vous définissez les opérations au niveau des blocs (tuiles de données), et le compilateur Triton gère automatiquement la coalescence mémoire, le découpage en tuiles dans la mémoire partagée et l'ordonnancement des Tensor Cores, égalant ou dépassant souvent le CUDA C++ réglé à la main.
2. Les connexions de saut de ResNet et le flux de rétropropagation
Avant ResNet (2015), empiler plus d'environ 20 couches convolutives faisait bondir l'erreur d'entraînement. En parcourant à rebours des dizaines d'étapes de multiplication, les gradients diminuaient vers zéro (disparition des gradients) ou devenaient instables.
- Apprendre les résidus plutôt que les sorties brutes. Dans un bloc de réseau standard, les couches empilées cherchent à apprendre une fonction directe H(x) à partir de l'entrée x. ResNet introduit une connexion de saut (raccourci d'identité) qui ajoute l'entrée originale x directement à la sortie du bloc :
y=F(x)+x
Ici, F(x) représente les couches convolutives empilées. Au lieu de reconstruire toute la représentation à partir de zéro, les couches n'ont besoin d'apprendre que le résidu (le petit ajustement F(x) = y - x). Si une couche n'est pas nécessaire, le réseau peut facilement rapprocher F(x) de zéro, ne laissant qu'un passage d'identité intact.
- Une voie rapide ininterrompue pour les gradients. Pendant la rétropropagation, la règle de dérivation en chaîne calcule le gradient de la perte (L) par rapport à l'entrée x :
(∂ L)/(∂ x)=(∂ L)/(∂ y)((∂ F(x))/(∂ x)+1)
Grâce au terme + 1 créé par le raccourci d'identité, le gradient en amont ((∂ L)/(∂ y)) remonte directement vers les couches antérieures sans être réduit par de petites matrices de poids dans (∂ F(x))/(∂ x). Cela permet aux gradients de se propager sans entrave à travers plus de 100, voire plus de 1 000 couches.
3. Le passage des CNN aux transformeurs de vision (ViT)
Pendant près d'une décennie après AlexNet, les réseaux de neurones convolutifs (CNN) ont dominé la vision par ordinateur en faisant glisser de petits filtres locaux sur les images. En 2020, Google a introduit le Vision Transformer (ViT), adaptant aux images l'architecture Transformer issue du traitement du langage naturel.
| Caractéristique | Réseaux de neurones convolutifs (CNN) | Transformeurs de vision (ViT) |
|---|---|---|
| Traitement de l'entrée | Traite toute la grille 2D de l'image à l'aide de filtres glissants (par exemple, 3×3). | Divise l'image en zones de taille fixe (par exemple, 16×16 pixels) et les aplatit en une séquence de tokens. |
| Champ réceptif | D'abord local. Les premières couches ne voient que les pixels voisins ; le contexte global se construit lentement dans les couches profondes. | Immédiatement global. L'auto-attention relie chaque zone de l'image à toutes les autres dès la couche 1. |
| Biais inductif | Élevé. Des hypothèses intégrées sur l'invariance par translation et la localité spatiale 2D aident les CNN à bien apprendre sur de plus petits jeux de données. | Faible. Aucune règle spatiale 2D intégrée (recours à des plongements positionnels), ce qui nécessite des jeux de données massifs pour apprendre la structure visuelle. |
| Mise à l'échelle matérielle | Repose sur des noyaux de convolution spécialisés et des schémas complexes d'accès à la mémoire. | Repose presque entièrement sur des multiplications matricielles denses (GEMM), qui saturent les Tensor Cores des GPU modernes avec une efficacité maximale. |
- Pourquoi les ViT se sont imposés dans l'IA moderne. Si les CNN restent efficaces sur les appareils mobiles légers et les appareils en périphérie, les transformeurs de vision passent bien mieux à l'échelle lorsqu'ils sont entraînés sur des centaines de millions d'images. De plus, comme les ViT représentent les images sous forme de séquences de tokens, exactement le même format que pour le texte et l'audio, ils ont permis aux modèles d'IA multimodaux modernes (comme GPT-4o et Gemini) de traiter la vision et le langage dans une seule architecture unifiée.