MINI-COURS #35 ⏱️ 45 – 49 minutes de lecture
🔒 Contenu réservé aux membres du Cercle des Experts
Débloque la leçon complète et tous les autres mini-cours.
Au programme
Introduction
Grâce aux avancées des frameworks open-source comme PyTorch, exploiter un GPU pour accélérer l'entraînement d'un modèle de deep learning tient en une seule ligne, comme illustré ci-dessous :

Si cette encapsulation est aussi simple que possible, l'implémentation sous-jacente, celle qui permet aux GPU d'accélérer les calculs, reste un mystère pour beaucoup.

Plus précisément : que se passe-t-il réellement quand on appelle .cuda() ?
Dans ce deep dive, on va décortiquer la mécanique de la programmation GPU.
Plus précisément, on va comprendre comment CUDA, une interface de programmation développée par NVIDIA, permet aux développeurs d'exécuter des processus sur leurs GPU, et comment cette implémentation fonctionne en coulisses.
Pour ça, on va faire un vrai travail pratique de programmation CUDA et implémenter des versions parallélisées de plusieurs opérations qu'on utilise en permanence en deep learning.
C'est parti !
Qu'est-ce que CUDA ?
En résumé, CUDA (Compute Unified Device Architecture) est une plateforme de calcul parallèle et un modèle d'interface de programmation (API) créés par NVIDIA.
Il permet aux développeurs d'utiliser un GPU compatible CUDA pour du calcul généraliste.

💡 Pour donner un peu de contexte : le calcul généraliste, c'est le fait de détourner une capacité de calcul vers un usage large, au-delà de sa fonction spécialisée d'origine. Dans le cas des GPU, conçus à la base pour le rendu graphique dans les jeux vidéo, le calcul généraliste permet de les réorienter vers des tâches intensives en calcul, sans lien direct avec le graphisme.
Pour exploiter la puissance de calcul du GPU, CUDA fournit une interface implémentée en C/C++. Elle permet d'accéder à la mémoire du GPU et d'y exécuter des opérations de calcul.
Dans le contexte du deep learning, ce sont typiquement des opérations mathématiques et générales comme :
Additionner des matrices/vecteurs
Multiplier des matrices
Transformer une matrice en lui appliquant une fonction, comme une fonction d'activation, un dropout, etc.
Déplacer des données du CPU vers le GPU, puis les rapatrier
Et bien plus encore
Autrement dit : tout comme Pandas permet aux développeurs d'interagir facilement avec des données tabulaires via des structures et opérations haut niveau, CUDA offre un niveau d'abstraction équivalent, mais pour le calcul sur GPU NVIDIA.

En masquant la complexité sous-jacente liée au GPU (gestion de la mémoire, gestion des threads, gestion des blocs), CUDA permet aux développeurs de se concentrer sur le problème de calcul à résoudre plutôt que sur les subtilités du matériel sur lequel il tourne.
Bien sûr, comme évoqué plus haut, CUDA fournit une interface C/C++, et les frameworks de deep learning comme PyTorch ont simplifié tout ça en construisant un wrapper Python autour :

Donc quand on développe des modèles de deep learning, on utilise une API Python qui, en coulisses, s'appuie sur des instructions C/C++ fournies par CUDA pour dialoguer avec le GPU.
Pour être clair, l'objectif de ce dossier est de comprendre ce chemin CUDA → instructions GPU, et comment il est implémenté.

Une certaine aisance en C/C++ est un plus, mais ce n'est pas indispensable : le design de l'API est plutôt intuitif. Cela dit, je t'apporterai des explications complémentaires à chaque étape si tu n'as jamais touché au C++.
Le problème avec les CPU
Quand il s'agit de paralléliser, l'approche traditionnelle avec les CPU repose sur les threads (fils d'exécution), qui portent des instructions que le processeur peut exécuter indépendamment.
Prenons par exemple cette simple boucle for en C, qui réalise les opérations d'une couche linéaire classique :
Observe cette boucle for dans le code ci-dessus. Elle parcourt les éléments des tableaux un par un, calcule le résultat individuel, et le stocke dans le tableau de sortie.
Si tu regardes de près, toutes ces opérations individuelles sont indépendantes les unes des autres.

la i-ème opération ne dépend pas de la j-ème opération
Elles pourraient donc être exécutées en parallèle. Pourtant, l'implémentation ci-dessus utilise une approche séquentielle : chaque opération attend que la précédente se termine avant de démarrer.
Les CPU modernes peuvent gérer plusieurs threads simultanément grâce à des techniques comme le multi-threading. On peut donc s'en servir pour que la boucle génère plusieurs threads, potentiellement un par cœur, afin de traiter différentes parties du tableau en même temps.
Et c'est assez intuitif : plus on ajoute de threads, plus le niveau de parallélisme qu'on peut atteindre est élevé.
En deep learning, les choses sont différentes.
Les briques de base des modèles de deep learning, les vecteurs et les matrices, peuvent contenir des millions d'éléments.
Or, par nature, les CPU sont limités dans leur degré de parallélisme à cause d'un nombre de cœurs restreint (même les CPU grand public haut de gamme dépassent rarement 16 cœurs).
Les GPU, eux, sont des architectures modernes capables de faire tourner des millions de threads en parallèle. Ça améliore considérablement les performances de ces opérations mathématiques quand on manipule des vecteurs et des matrices de très grande taille.
Un exemple pour illustrer
Prenons l'opération de multiplication matricielle ci-dessous, omniprésente en deep learning :

Fondamentalement, une multiplication matricielle n'est qu'une série de produits scalaires indépendants entre vecteurs, comme illustré dans l'animation ci-dessous :

La 1ʳᵉ ligne de la matrice de gauche est multipliée avec :
La 1ʳᵉ colonne de la matrice de droite
La 2ᵉ colonne de la matrice de droite
La 3ᵉ colonne de la matrice de droite
Et ainsi de suite
La 2ᵉ ligne de la matrice de gauche est multipliée avec :
La 1ʳᵉ colonne de la matrice de droite
La 2ᵉ colonne de la matrice de droite
La 3ᵉ colonne de la matrice de droite
Et ainsi de suite
Et ainsi de suite...
Si tu regardes bien, toutes ces opérations sont indépendantes les unes des autres. Elles pourraient donc, en théorie, toutes être exécutées en parallèle.
Mais comme on l'a vu, les CPU disposant d'un nombre de threads assez limité, ils ne sont pas idéaux pour exploiter tout le potentiel de parallélisation de ces multiplications matricielles.
Autrement dit, les CPU ne gèrent généralement qu'une poignée de dizaines de threads simultanément, ce qui limite leur efficacité pour exécuter un grand nombre d'opérations indépendantes en même temps, comme celles requises par des multiplications matricielles à grande échelle.
Comment les GPU aident-ils ?
Il faut clarifier un point important : les CPU ne sont pas "mauvais".
Il y a une raison pour laquelle tous les ordinateurs modernes embarquent systématiquement un CPU, mais pas nécessairement un GPU "rapide". C'est parce que le CPU et le GPU sont conçus pour atteindre des objectifs complètement différents.
Pour commencer, les calculs CPU sont généralement plus rapides que ceux du GPU pour une opération unique. Autrement dit, ils sont conçus pour exécuter rapidement une séquence d'opérations mono-thread. Pour maintenir cette vitesse, ils ne peuvent exécuter qu'un nombre limité de threads en parallèle.
À l'inverse, les GPU sont conçus pour exécuter des millions de threads en parallèle, au prix de la vitesse de chaque thread pris individuellement.
Donc même si un thread met moins de temps à s'exécuter sur un CPU, le fait que les GPU puissent en exécuter des millions en parallèle démultiplie considérablement le temps d'exécution global.
Une analogie tirée de la vraie vie
Une analogie que j'ai entendue il y a des années, quand j'ai découvert ces concepts, compare le CPU à une voiture de F1 et le GPU à un bus.

Si l'objectif est de déplacer une seule personne d'un point A à un point B, alors la voiture de F1, c'est-à-dire le CPU, sera le choix idéal.
En revanche, si l'objectif est de déplacer beaucoup de personnes d'un point à un autre, alors le bus, c'est-à-dire le GPU, sera le choix idéal. Et ce, même si une F1 mettra moins de temps à parcourir la distance entre A et B.
Le bus peut transporter tout le monde en un seul trajet, là où la F1 devrait multiplier les allers-retours.
💡 En continuant, tu vas découvrir :
Les trois composants fondamentaux de CUDA : host, device et kernel, et comment ils s'articulent
Comment naviguer la hiérarchie thread → block → grid, et calculer l'index global d'un thread en 1D comme en 2D
L'implémentation pas à pas d'une couche linéaire en CUDA C/C++, du
cudaMallocaucudaMemcpy, jusqu'à la compilation avecnvccsur Google ColabComment structurer une addition et une multiplication de matrices avec des configurations de threads en 2D grâce au type
dim3Pourquoi ajouter des blocs change tout quand tu dépasses la limite de threads par bloc
La suite de ce mini-cours est réservée aux membres du Cercle des Experts.
Tu as déjà le début. Pour accéder à l’explication complète et aux autres mini-cours, rejoins le Cercle des Experts.
Rejoindre le Cercle des ExpertsDéjà abonné(e) ? Se connecter
En devenant membre, tu débloques :
- L’intégralité de ce mini-cours, sans coupure
- Tous les mini-cours et les ressources associées
- Chaque nouveau mini-cours dès sa sortie
