Habr AI montre comment construire une Linear Layer en C++ et CUDA dans sa série « De MNIST à Transformer »

Habr AI a publié la troisième partie de sa série « De MNIST à Transformer », qui détaille le passage des matrices ordinaires aux tenseurs et montre comment construire à la main une Linear Layer de base, sans PyTorch. Le contenu mène le lecteur jusqu'à un réseau de neurones simple pour reconnaître MNIST et se concentre non pas sur les API des bibliothèques, mais sur la façon dont ces opérations s'exécutent réellement sur le GPU.

De quoi parle la troisième partie

Le nouvel article poursuit le parcours du code CUDA bas niveau vers les architectures sur lesquelles reposent ensuite Transformer et les LLM modernes. Au lieu d'abstractions toutes faites, l'auteur propose de regarder directement le calcul : comment les données sont rangées en mémoire, comment le GPU lance les opérations et pourquoi même une couche de réseau de neurones d'apparence élémentaire demande beaucoup de travail d'ingénierie. C'est un bon format pour ceux qui n'en peuvent plus de voir les frameworks de ML comme de la magie en une ligne de code.

Le principal basculement de cette partie est le passage des matrices aux tenseurs. Pour l'apprentissage automatique appliqué, c'est un sujet de base, car les données réelles se limitent rarement à deux dimensions. L'auteur montre comment la façon de penser du développeur change lorsqu'il travaille non plus seulement avec des tableaux de nombres, mais avec des structures multidimensionnelles, dont on assemble ensuite les batchs, les poids des couches, les représentations intermédiaires et d'autres briques du futur modèle. C'est à ce niveau que commence la préparation à des blocs plus complexes comme l'attention et les embeddings.

Ce qui est implémenté à la main

La partie pratique s'articule autour de code maison en C++ et CUDA. Il n'y a aucune tentative de masquer la complexité derrière une interface pratique : au contraire, le lecteur parcourt le chemin qui mène de la formule mathématique à l'implémentation manuelle. Cette approche est utile parce qu'elle relie l'algèbre linéaire abstraite à des étapes concrètes de développement : placement des données, appels de kernels, vérification des formes des dimensions et compréhension de l'endroit exact où apparaissent les erreurs ou les pertes de performance. Sans ce maillon, il est difficile de sentir la différence entre un exemple pédagogique et un système réel.

• Implémentation de la multiplication de tenseurs
• Création de la première Linear Layer, c'est-à-dire d'une couche entièrement connectée
• Travail sur la mémoire et le placement des données sur le GPU
• Lien entre mathématiques et code pour l'entraînement sur MNIST
• Assemblage d'un réseau simple de reconnaissance de chiffres manuscrits

« C'est la seule façon de vraiment comprendre comment fonctionnent les LLM. »

Après l'implémentation des opérations de base, l'article conduit à une couche entièrement connectée maison, puis à un petit réseau de reconnaissance de chiffres manuscrits de MNIST. C'est un point important : le contenu ne s'arrête pas à des primitives isolées, mais montre comment les assembler en une chaîne fonctionnelle. On comprend aussi que même un classificateur simple repose sur une pile de connaissances assez profonde, des mathématiques à l'organisation de la mémoire vidéo et aux particularités du calcul parallèle.

Pourquoi c'est important

La valeur de ces analyses tient à ce qu'elles dissipent l'illusion de facilité que crée souvent l'enveloppe Python. Quand le développeur ne voit que des appels de bibliothèques tout faits, il lui est difficile d'estimer le coût de chaque opération et de comprendre pourquoi le modèle se heurte soudain aux limites de la mémoire, de la bande passante ou de la taille de batch. Une analyse au niveau des tenseurs et des couches aide à mieux lire les profileurs, à concevoir l'architecture plus soigneusement et à arbitrer plus consciemment entre vitesse, précision et complexité d'implémentation.

La série « De MNIST à Transformer » est particulièrement utile à ceux qui veulent non seulement exécuter les modèles des autres, mais comprendre la mécanique des systèmes d'IA modernes. Elle ne promet pas une entrée rapide et prévient sans détour : il y aura beaucoup de code, de CUDA, de mathématiques et de travail manuel sur la mémoire. Mais ce format donne un socle qui servira aussi bien à optimiser l'inférence qu'à lire des implémentations CUDA tierces, ou à comprendre pourquoi certains choix d'architecture sont plus rapides que d'autres.

Ce que cela signifie

Pour le public russophone, c'est un bon signal : la demande se déplace des tutoriels superficiels vers l'analyse d'ingénierie des entrailles de la pile d'IA. Plus ces contenus se multiplient, moins les LLM sont perçus comme une boîte noire et plus il est facile pour les développeurs de passer de l'utilisation de modèles prêts à l'emploi à leur réglage et à leur optimisation en connaissance de cause. C'est d'autant plus important que la demande d'optimisation GPU et de compréhension du fonctionnement interne des modèles croît rapidement chez les ingénieurs en activité.