Comprendre le calcul sur GPU

Par Gaël Pegliasco

Dans cette première partie vous appren­drez les diffé­rences entre un CPU et un GPU et les clés qui vous permet­tront de choi­sir votre carte graphique pour travailler avec Python.

Source Pixa­bay par Laura­Tara

Les GPU (Graphics Proces­sing Unit) sont les proces­seurs de vos cartes graphiques. Typique­ment, il s’agit des cartes graphiques comme NVIDIA/AMD.

Les CPU(Central Proces­sing Unit) sont les proces­seurs de vos PC et smart­phones qui font fonc­tion­ner vos systèmes d’ex­ploi­ta­tion. Typique­ment il s’agit des proces­seurs comme les Intel Core (i7/i9), AMD Ryzen ou ARM qui font fonc­tion­ner vos PC Linux/Mac/Windows ou Smart­phones Android.

Comme nous l’avons vu dans le chapitre Les concepts du paral­lé­lisme les GPU se diffé­ren­cient des CPU par le fait qu’ils possèdent des milliers d’uni­tés de calcul (cœurs) contre seule­ment quelques dizaines – au mieux – pour les CPU.

Les cœurs de vos proces­seurs ont la charge d’exé­cu­ter vos programmes. Si vous dispo­sez de 10 cœurs dans un proces­seur vous pouvez faire fonc­tion­ner jusqu’à 10 programmes en paral­lèle.

Une carte graphique comme la carte NVIDIA RTX 5090 possède 21 760 cœurs contre 192 pour le meilleur CPU du moment (janvier 2025) : l’AMD Epyc 9965

Ques­tion : Pourquoi alors les GPU n’ont pas déjà remplacé les CPU dans les système d’ex­ploi­ta­tion ?

Si je dispose d’une carte graphique avec des milliers de cœurs, j’en dédie une centaine pour l’OS – ce sera déjà bien mieux que ce que propose la plupart des CPU ayant moins de 10 cœurs – et je garde les autres pour la vidéo et le machine lear­ning ?

Ce sera à peine plus lent pour la vidéo et mons OS ira bien plus vite…

Ainsi j’éco­no­mise le prix du CPU dans mon prochain PC de {del}gamer data-scien­tist !

Effec­ti­ve­ment, pourquoi ?

---

À la diffé­rence des CPU où chaque unité de calcul peut réali­ser ses propres instruc­tions indé­pen­dam­ment des autres unités, toutes les unités de calcul d’un GPU réalisent la même instruc­tion en même temps.

Ainsi, un cœur d’un CPU pourra surfer sur inter­net pendant qu’un second cœur fera de la bureau­tique et qu’un troi­sième jouera de la musique. Dans un GPU tous les cœurs feront la même opéra­tion en même temps.

Un CPU est donc très bien taillé pour faire tour­ner un système d’ex­ploi­ta­tion (OS) car dans un OS de nombreux programmes diffé­rents s’exé­cutent en paral­lèle. C’est le 4×4 qui passe partout.

Quant au GPU il est parti­cu­liè­re­ment adapté au calcul massi­ve­ment paral­lèle sur de grandes quan­ti­tés de données.

Imagi­nons ce cas de figure : vous dispo­sez d’une carte graphique possé­dant 10 000 cœurs et vous souhai­tez incré­men­ter de 1 toutes les cases d’un tableau de 10 000 éléments.

• Avec votre GPU chaque cœur se verra confier le calcul sur l’un des éléments du tableau : vous allez mettre à jour toutes les cases du tableau en 1 seule instruc­tion qui sera exécu­tée sur chacun des cœurs en paral­lèle.
• Avec un CPU vous allez devoir utili­ser un cœur qui va itérer sur chaque case du tableau avec une boucle et répé­ter l’opé­ra­tion 10 000 fois, ce sera indé­nia­ble­ment plus long. Bien sûr, vous pour­riez utili­ser tous vos cœurs, mais comme vous en avez bien moins, vous n’échap­pe­rez pas à de bien plus longues boucles.

C’est l’idée globale, même si dans la pratique les choses sont un peu plus fines que cela, et que, par exemple, les CPU peuvent aller plus vite grâce aux instruc­tions SIMD…

C’est donc pour ces raisons que les CPU font toujours tour­ner nos OS et que les GPU sont recom­man­dés pour le calcul numé­rique et le machine lear­ning.

Ques­tion : mais alors pourquoi les CPU n’ont-ils pas plus de cœurs ?

Ce serait quand même bien pratique, ils font pâle figure en regard des cartes graphiques.

---

Effec­ti­ve­ment. En fait, pour que les cœurs d’un CPU soient indé­pen­dants les uns des autres, ceux-ci disposent d’un compo­sant appelé ordon­nan­ceur dont le rôle est de répar­tir les instruc­tions sur ces derniers, et, malheu­reu­se­ment, sa complexité augmente propor­tion­nel­le­ment au carré du nombre de cœurs.

Ceci rend donc très diffi­cile la concep­tion de CPU massi­ve­ment paral­lèles.

Aujour­d’hui trois construc­teurs dominent le marché des cartes graphiques : NVIDIA, AMD(ancien­ne­ment ATI) et Intel.

Les cartes graphiques des deux premiers sont aujour­d’hui inté­grées à votre ordi­na­teur via des bus de données PCI Express. Elles sont de plus en plus volu­mi­neuses et consom­ma­trices d’éner­gie.

Par exemple le presque déjà ancien modèle NVIDIA RTX 2080 Super mesure 11×26 cm et utilise le volume de 2 slots PCIE ! Une alimen­ta­tion de 650 Watts est recom­man­dée !

Les cartes AMD/NVIDIA sont parti­cu­liè­re­ment adap­tées pour le jeu vidéo et le machine lear­ning. Elles disposent de milliers de cœurs.

Les proces­seurs graphiques Intel sont géné­ra­le­ment inté­grés aux CPU et disposent de peu de cœurs.

Par exemple le proces­seur i9–14900KS intègre un proces­seur graphique Intel® UHD Graphics 770.

Ce dernier permet de faire tour­ner sans problème des appli­ca­tions bureau­tiques et de regar­der des vidéos mais n’est pas aussi perfor­mant que les 2 autres concur­rents pour les jeux vidéo modernes ou le calcul scien­ti­fique. Comme il est inté­gré avec le CPU il est nette­ment moins encom­brant et consom­ma­teur d’éner­gie. C’est pour cela qu’il est bien souvent utilisé comme unique carte graphique sur les ordi­na­teurs portables de type bureau­tique.

Les proces­seurs AMD comme le Ryzen 9 9950X disposent aussi de mini cartes graphiques inté­grées.

Cela semble moins connu, mais Intel propose aussi des cartes graphiques externes/PCI Express via la gamme ARC ; cepen­dant elles disposent seule­ment d’une ving­taine de cœurs.

Quand nous parlons de calcul sur GPU, nous parlons de calcul sur des proces­seurs graphiques dédiés et non sur ceux inté­grés à vos CPU qui offrent beau­coup moins de puis­sance.

Pourquoi est-il utile de dispo­ser d’un petit GPU ?

Il est aujour­d’hui très fréquent de dispo­ser de plusieurs GPU sur sa machine. Parfois même sans le savoir.

Imagi­nons que vous ayez installé dans votre PC votre carte graphique dernier cri dispo­sant de milliers de cœurs, mais vous avez aussi un proces­seur Intel/AMD équipé d’un petit GPU.

Vous dispo­sez donc de 2 GPU qui peuvent l’un comme l’autre gérer votre vidéo et c’est une très bonne chose – même si le second n’est pas assez puis­sant pour jouer à vos jeux favo­ris !

Dans cette confi­gu­ra­tion, géné­ra­le­ment, votre système d’ex­ploi­ta­tion vous permet de choi­sir quelle carte graphique utili­ser pour la vidéo voire même selon l’ap­pli­ca­tion exécu­tée.

• Sous Windows vous pouvez iden­ti­fier si vous dispo­sez de plusieurs GPU dans le gestion­naire de péri­phé­riques.

• Sous Linux il existe de nombreuses manières de lister les GPUs/cartes graphiques dispo­nibles.
  La commande lscpi est peut-être le moyen le plus simple.

bash$ lspci | grep -i VGA  # à saisir dans un terminal
01:00.0 VGA compatible controller: NVIDIA Corporation TU106BM [GeForce RTX 2070 Mobile] (rev a1)
08:00.0 VGA compatible controller: NVIDIA Corporation TU104 [GeForce RTX 2080 Rev. A] (rev a1)

Ce fil de discus­sion propose beau­coup d’autres commandes pour lister la confi­gu­ra­tion de votre carte graphique avec linux.
Parmi celles-ci, la commande inxi offre de nombreuses infor­ma­tions sur votre maté­riel :

$ inxi -Fzxd

System:
  Host: <ComputerHostNameHere> Kernel: 5.3.0-53-generic x86_64 bits: 64 compiler: gcc 
  ...
Machine:
  ...
Battery:
  ...
CPU:
  Topology: 6-Core model: Intel Core i7-8700 bits: 64 type: MT MCP 
  arch: Kaby Lake rev: A L2 cache: 12.0 MiB 
  flags: lm nx pae sse sse2 sse3 sse4_1 sse4_2 ssse3 vmx bogomips: 76799 
  Speed: 1100 MHz min/max: 800/4600 MHz Core speeds (MHz): 1: 1100 2: 1101 
  3: 1100 4: 1100 5: 1100 6: 1100 7: 1100 8: 1100 9: 1100 10: 1100 11: 1100 
  12: 1100 
Graphics:
  Device-1: NVIDIA TU106BM [GeForce RTX 2070 Mobile] vendor: CLEVO/KAPOK 
  driver: NVIDIA v: 440.64.00 bus ID: 01:00.0 
  Display: x11 server: X.Org 1.19.6 driver: NVIDIA 
  resolution: 1680x1050~60Hz, 2560x1440~120Hz 
  OpenGL: renderer: GeForce RTX 2070/PCIe/SSE2 v: 4.6.0 NVIDIA 440.64.00 
  direct render: Yes 
Audio:
  ...
Network:
  ...
Drives:
  ...
  Message: No Optical or Floppy data was found. 
Partition:
  ...
Sensors:
  System Temperatures: cpu: 46.0 C mobo: N/A gpu: NVIDIA temp: 41 C 
  Fan Speeds (RPM): N/A 
Info:
  ...

Si l’on reprend la confi­gu­ra­tion affi­chée par la commande lspci propo­sant 2 cartes NVIDIA RTX 2070 et 2080 il s’agit d’une machine ou la première carte est inté­grée au PC portable ; la seconde est une carte connec­tée via un boîtier externe sur port Thun­der­bolt 3. Cela ne se devine pas avec la commande.

En fait ce listing est incom­plet.

Il en manque même une troi­sième, celle du proces­seur Intel i7 – 8700 qui équipe le PC et qui dispose d’une puce Intel® UHD Graphics 630. Mais elle est inuti­li­sable en raison d’une connec­tique un peu parti­cu­lière du portable utilisé.

Vous allez penser ironique­ment « Oh la malheu­reuse personne ! » : ce n’est pas bien grave, les 2 premières suffisent large­ment et le proces­seur UHD Graphics 630 ne nous inté­resse pas.
Et bien, si, cela peut être vrai­ment péna­li­sant de ne pas avoir cet autre proces­seur de dispo­nible, aussi petit soit-il.

Nous allons expliquer pourquoi dans un instant.

Reve­nons à des sorties plus fréquentes. En géné­ral vous voyez plutôt quelque chose comme ceci avec la commande lspci:

$ lspci | grep -i VGA
00:02.0 VGA compatible controller: Intel/AMD Corporation Device XXX
01:00.0 3D controller: NVIDIA/AMD Corporation YYY

Dans cette confi­gu­ra­tion vous dispo­sez d’une carte vidéo 3D hautes perfor­mances et d’une carte plus modeste inté­grée au proces­seur.
Quand vous calcu­lez avec le GPU de votre PC portable/desk­top, il est très utile de dispo­ser des deux.

Comme votre système d’ex­ploi­ta­tion vous permet de choi­sir la carte graphique à utili­ser pour l’af­fi­chage vidéo vous pouvez indif­fé­rem­ment bascu­ler sur l’une ou l’autre.

Et cela est vrai­ment très pratique :

• Sur batte­rie vous utili­sez la carte la moins consom­ma­trice, celle du proces­seur, et vous pouvez termi­ner de saisir votre rapport dans le train avant de vider la batte­rie de votre portable.
• Sur courant, vous bascu­lez sur la carte hautes perfor­mances pour vos appli­ca­tions les plus exigeantes.

Linux possède des commandes pour bascu­ler l’af­fi­chage graphique d’un GPU à l’autre : Une recherche Inter­net vous retour­nera de nombreuses réponses comme ce tuto­rial Howto switch Intel and NVIDIA

Pour les cartes NVIDIA la commande est prime-select

Lister les cartes dispo­nibles :

$ sudo prime-select query
NVIDIA
intel

Sélec­tion­ner une carte:

$ sudo prime-select intel

Mais pourquoi sélec­tion­ner la carte la moins perfor­mante ! Nous voulons utili­ser toute la puis­sance de ce PC !

Juste­ment : nous allons lancer des calculs sur GPU. Nous allons les exécu­ter sur la carte la plus puis­sante, donc NVIDIA dans cet exemple.

Si vous lancez les calculs sur le GPU utilisé pour l’af­fi­chage graphique, ce qui est tout à fait possible, vous risquez de ralen­tir consi­dé­ra­ble­ment le rafrai­chis­se­ment de l’écran quand la carte tour­nera à plein régime pour vos calculs.

C’est ce qui se passe sur mon PC quand je fais du machine lear­ning et que je n’ai pas connecté le boîtier externe : je ne peux même plus surfer sur inter­net pendant que le GPU calcule car le proces­seur graphique n’a pas le temps de rafraî­chir l’écran, il calcule des descentes de gradients à tours de bras…

Et fran­che­ment c’est pénible. Ne vous plai­gnez plus d’avoir un chip­set graphique moins perfor­mant que vous n’uti­li­siez pas. Aujour­d’hui il va vous permettre de pour­suivre la lecture de ce tuto­riel pendant vos calculs !

C’est même une condi­tion d’achat du CPU si vous souhai­tez calcu­ler sur votre machine person­nelle : le CPU doit dispo­ser d’un petit GPU interne pour déchar­ger le GPU qui calcu­lera.

Un mot sur les boîtiers externes – eGPU

En termes de calcul sur GPU, il devient de plus en plus fréquent d’uti­li­ser des cartes graphiques placées dans des boîtiers externes (eGPU – exter­nal GPU), ce qui offre de nombreux avan­tages comme de pouvoir chan­ger la carte plus faci­le­ment ou ne pas la bran­cher si vous n’en avez pas l’usage, ou de doper un laptop qui ne serait pas évolu­tif, ou encore de la prêter à votre collègue, car il faut le dire, vous n’uti­li­sez pas tout le temps votre GPU à 100% de ses capa­ci­tés.

Dans ce cas vous devez utili­ser une connexion entre le boitier et le PC qui puisse offrir un débit suffi­sant pour les échanges de données avec le CPU.
À défaut, les perfor­mances ne seront pas au rendez-vous.

Aujour­d’hui, les ports Thun­der­bolt 3 et 4 offrant un débit de 40Gbit/sec sont adap­tés à ce type de trans­fert.

Les versions précé­dentes de la norme, comme Thun­der­bolt 2 avec 20Gbit/sec de débit ne sont pas suffi­santes. Si vous utili­sez ce type de confi­gu­ra­tion, tout le temps de calcul gagné en utili­sant la carte graphique externe sera reperdu par les échanges entre le CPU et le GPU en raison de leur trop grande lenteur.

Il convient donc d’être vigi­lant sur le choix de la connec­tique.

Le câble doit aussi être adapté au type de la connexion.

Pour creu­ser le sujet, voici deux articles qui vous donne­ront quelques pistes pour trans­for­mer votre laptop en une machine de guerre utili­sant un GPU externe : * 9 Things You Need to Know About Exter­nal GPUs * How to use an exter­nal GPU on a Laptop?

Le site eGPU.io propose un inté­res­sant listing pour vous aider à choi­sir votre GPU externe ou construire le vôtre.

Un mot sur la mémoire de votre carte graphique

Vous avez investi. Vous avez un ordi­na­teur portable avec un maxi­mum de RAM, disons 64Go, et une carte graphique aux perfor­mances fabu­leuses équi­pée de seule­ment 4Go de RAM.

Ce n’est pas grave pensez-vous, 4Go c’est suffi­sant pour l’écran et pour les data il y a 64Go du CPU, le GPU n’aura qu’à y piocher ce qu’il veut, de toute façon j’uti­lise rare­ment tout.

Ce n’est pas une solu­tion.

Les calculs sur GPU se font dans la mémoire de la carte graphique. Et les échanges avec la mémoire du PC sont un véri­table goulot d’étran­gle­ment. Il est donc impor­tant de dispo­ser d’une carte graphique possé­dant beau­coup de mémoire si vous envi­sa­gez de lui confier des données volu­mi­neuses à trai­ter.
Sinon, vous décou­vri­rez rapi­de­ment les drames du Memory Over­flow.

Calcu­ler sur GPU – GPGPU

Gene­ral Purpose compu­ting on GPU est le terme dési­gnant le calcul sur GPU pour des problé­ma­tiques habi­tuel­le­ment confiées à des CPU.

Le calcul sur GPU a commencé à deve­nir popu­laire vers 2001 lorsque les proces­seurs graphiques ont inté­gré des unités de calcul en virgule flot­tante. Puis des opéra­tions d’al­gèbre liné­raire comme le calcul vecto­riel et matri­ciel.

En 2005, la décom­po­si­tion LU fut un des premiers programmes ayant réussi à fonc­tion­ner plus rapi­de­ment sur GPU que sur CPU.

Mais la program­ma­tion pour GPU était alors très diffé­rente de la program­ma­tion pour CPU, plus labo­rieuse et compliquée, bas niveau. Les GPU ont des instruc­tions moins riches que les CPU et des concepts bien diffé­rents.

L’ar­ri­vée de librai­ries comme CUDA et OpenCL a permis d’écrire des programmes pour GPU en s’af­fran­chis­sant de nombreux concepts bas niveau spéci­fiques à chaque modèle de carte graphique. Ceci a boosté le déve­lop­pe­ment du calcul sur GPU qui est alors devenu beau­coup plus acces­sible.

Enfin, l’ar­ri­vée du BigData et du Machine Lear­ning mani­pu­lant des données très volu­mi­neuses (géné­ra­le­ment de grands vecteurs) ont trouvé dans les opéra­tions matri­cielles offertes par les GPU modernes le moyen de mettre en œuvre tout leur poten­tiel. Offrant ainsi à ces disci­plines leurs lettres de noblesse.

Les librai­ries Python pour calcu­ler sur GPU

Python possède plusieurs librai­ries permet­tant d’exé­cu­ter des calculs sur GPU:

• PyOpenCL, comme son nom l’in­dique, implé­mente l’API OpenCL en Python. Cette API offre l’avan­tage de suppor­ter tout type de maté­riel, CPU, GPU, FPGA, DSP, …
  C’est une des rares librai­ries qui permet d’écrire un code compa­tible avec les 2 modèles de cartes AMD et NVIDIA (et bien d’autres).
• PyCuda est un projet proche de PyOpenCL qui permet d’uti­li­ser à l’API Cuda des cartes NVIDIA.
  Mais cette librai­rie ne fonc­tionne qu’avec les cartes NVIDIA.
• pygpu implé­mente des tableaux à N dimen­sions pour GPU.
  La librai­rie se veut simple, cross archi­tec­ture OpenCL/Cuda et riche en fonc­tion­na­li­tés – mais n’est plus main­te­nue depuis quelques années déjà.
  Elle reste inté­res­sante pour comprendre la diffi­culté de mise en œuvre de la disci­pline.
• Scikit-cuda four­nit une inter­face Python pour de nombreuses fonc­tions des API CUDA, CUBLAS, CUFFT, et CUSOL­VER de NVIDIA et réim­plé­mente ainsi tout une partie de la librai­rie Scipy sur GPU.
• Numba est une librai­rie de compi­la­tion Just In Time/A la volée permet­tant notam­ment la compi­la­tion pour CPU et GPU.
  Elle suppor­tait ancien­ne­ment les archi­tec­tures NVIDIA – CUDA et AMD – ROCm (avec certaines restric­tions). Cepen­dant ROCm n’est plus géré aujour­d’hui.
  Elle reste un choix très inté­res­sant pour certains codes de calculs mais demande un refac­to­ring non trivial.
• Cupy est une librai­rie d’al­gèbre linéaire opti­mi­sée avec NVIDIA CUDA. Elle propose aussi un support expé­ri­men­tal pour AMD Rocm (4 & 5).
  Elle utilise aussi les autres librai­ries NVIDIA comme cuBLAS, cuDNN, cuRand, cuSol­ver, cuSPARSE, cuFFT et NCCL ce qui permet d’uti­li­ser tout le poten­tiel de votre GPU.
  Son API est calquée sur celle de Numpy ; elle peut très souvent rempla­cer sans effort cette dernière.
• Le projet RAPIDS AI soutenu par NVIDIA propose de multiples librai­ries de datas­cience ré-écrites pour fonc­tion­ner sur GPU NVIDIA via CUDA.
  Le projet permet réim­plé­mente des clones de plusieurs librai­ries Python phares pour leur permettre de fonc­tion­ner sur GPU:
  • cuDF propose des Data­Frames à la pandas fonc­tion­nant sur GPU
  • cuML ré-implé­mente les algo­rithmes clas­siques de machine lear­ning (arbres de déci­sion, svm…) avec une API calquée sur scikit-learn mais sur GPU
  • cuGraph propose des algo­rithmes de gestion de graphes avec une API inspi­rée de NetworkX
  • D’autres librai­ries sont aussi dispo­nibles
    Enfin, le projet propose une page pour vous aider à confi­gu­rer votre envi­ron­ne­ment virtuel conda/pip ou docker: https://docs.rapids.ai/install/#selec­tor
• Depuis décembre 2023 la librai­rie de calcul distri­bué dask permet d’uti­li­ser des GPU NVIDIA via Cupy et cuDF au lieu de tableaux numpy/pandas
• Depuis septembre 2024 la librai­rie polars offre un support expé­ri­men­tal sur GPU
• Enfin, xarray dispose aussi d’un support expé­ri­men­tal sur GPU

Pour les réseaux de neurones, les prin­ci­pales librai­ries: PyTorch, Tensor­flow, Mxnet sont compa­tibles avec les GPU AMD/NVIDIA depuis leur créa­tion. Toute­fois pour calcu­ler sur plusieurs GPU sur plusieurs machines, la librai­rie Horo­vod est une solu­tion qui peut gran­de­ment vous simpli­fier la tâche.

Quel GPU utili­ser avec Python ?

Si vous faîtes du machine lear­ning, peu importe, pour les réseaux de neurones, les 2 librai­ries phares du marché Tensor­flow et PyTorch fonc­tionnent indif­fé­rem­ment sur GPU NVIDIA/AMD.

Si vous utili­sez pandas, numpy, polars, scikit-learn, networkx, dask ou xarray, pas d’hé­si­ta­tion, leurs équi­va­lents respec­tifs pour GPU, à savoir cudf, cupy, polars(gpu), cuML, cuGraph et xarray(gpu) ne fonc­tionnent que sur des cartes graphiques de la marque NVIDIA.

Si vous souhai­tez compi­ler du code python sur GPU avec numba, là encore NVIDIA reste le choix favo­ris, l’ar­chi­tec­ture ROCm n’est plus testée/gérée par numba depuis sa version 0.6

NVIDIA semble avoir bien compris que la datas­cience fait vendre des GPU et que Python est le langage de prédi­lec­tion de la datas­cience. Aussi NVIDIA se donne beau­coup de moyens pour que ses cartes graphiques soit parfai­te­ment gérées par Python. NVIDIA est d’ailleurs à l’ori­gine du projet Rapids AI.

AMD ne semble pas concerné par la ques­tion. Toute­fois cela ne l’em­pêche pas de percer dans le milieu avec ses cartes accé­lé­ra­teurs AMD Instinct MI puisque les 2 plus perfor­mants super­cal­cu­la­teurs au monde en sont équi­pés en novembre 2024

Mais si vous ne faîtes pas de machine lear­ning, il faut actuel­le­ment oublier AMD avec Python et utili­ser des cartes NVIDIA.

Toute­fois cupy propose un support AMD-ROCm expé­ri­men­tal ce qui devrait permettre aussi à dask.array et xarray de fonc­tion­ner avec les cartes de cette marque.

Il existe une version numba-hip dédiée à l’ar­chi­tec­ture ROCm pour les cartes AMD MI unique­ment.

Instal­la­tion des librai­ries liées à votre maté­riel

Pour calcu­ler sur GPU vous devez dispo­ser des librai­ries/drivers corres­pon­dant à votre maté­riel avant d’ins­tal­ler les librai­ries Python présen­tées précé­dem­ment.
Nous nous foca­li­se­rons donc sur NVIDIA puisqu’AMD n’est pour le moment pas un choix à rete­nir pour Python.

NVIDIA

Concer­nant les drivers graphiques proprié­taires NVIDIA, ceux four­nis par votre distri­bu­tion Linux font norma­le­ment l’af­faire. Sinon, quel que soit votre système, vous pouvez suivre les instruc­tions de la page de télé­char­ge­ment des pilotes NVIDIA.

Puis, il convient d’ins­tal­ler la librai­rie CUDA.
NVIDIA propose un formu­laire de confi­gu­ra­tion pour sélec­tion­ner la version de la librai­rie à instal­ler.

Ensuite, les commandes devant être exécu­tées sont présen­tées.
Exemple pour CUDA 12.6 sur Linux Ubuntu 22.04 :

bash$ wget https://developer.download.NVIDIA.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
bash$ sudo dpkg -i cuda-keyring_1.1-1_all.deb
bash$ sudo apt-get update
bash$ sudo apt-get -y install cuda-toolkit-12-6

N’ou­bliez pas les drivers CUDA :

bash$ sudo apt-get -y install cuda-drivers

Ensuite, les commandes devant être exécu­tées sont présen­tée.
Exemple pour CUDA 12.6 sur Linux Ubuntu 22.04 :

bash$ wget https://developer.download.NVIDIA.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
bash$ sudo dpkg -i cuda-keyring_1.1-1_all.deb
bash$ sudo apt-get update
bash$ sudo apt-get -y install cuda-toolkit-12-6

N’ou­bliez pas les drivers CUDA :

bash$ sudo apt-get -y install cuda-drivers

Vous pouvez véri­fier la bonne confi­gu­ra­tion de votre instal­la­tion avec les commandes suivantes :

$ nvidia-smi
Wed Jan 15 00:04:22 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 555.42.06              Driver Version: 555.42.06      CUDA Version: 12.6     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 2070        Off |   00000000:01:00.0  On |                  N/A |
| N/A   53C    P0             32W /  115W |    1734MiB /   8192MiB |      2%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

Le tool­kit CUDA four­nit aussi quelques programmes d’exemples comme devi­ceQuery si vous instal­lez la suite de démons­tra­tion :

bash$ sudo apt install cuda-demo-suite-12-6

$ locate deviceQuery
/usr/local/cuda-12.6/extras/demo_suite/deviceQuery
/usr/local/cuda-12.6/samples/1_Utilities/deviceQuery
/usr/local/cuda-12.6/samples/1_Utilities/deviceQueryDrv
/usr/local/cuda-12.6/samples/1_Utilities/deviceQuery/Makefile
/usr/local/cuda-12.6/samples/1_Utilities/deviceQuery/NsightEclipse.xml
/usr/local/cuda-12.6/samples/1_Utilities/deviceQuery/deviceQuery.cpp
/usr/local/cuda-12.6/samples/1_Utilities/deviceQuery/readme.txt
/usr/local/cuda-12.6/samples/1_Utilities/deviceQueryDrv/Makefile
/usr/local/cuda-12.6/samples/1_Utilities/deviceQueryDrv/NsightEclipse.xml
/usr/local/cuda-12.6/samples/1_Utilities/deviceQueryDrv/deviceQueryDrv.cpp
/usr/local/cuda-12.6/samples/1_Utilities/deviceQueryDrv/readme.txt

$ /usr/local/cuda/extras/demo_suite/deviceQuery 
Device 0: "GeForce RTX 2080"
  CUDA Driver Version / Runtime Version          10.1 / 10.1
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 7952 MBytes (8338604032 bytes)
  (46) Multiprocessors, ( 64) CUDA Cores/MP:     2944 CUDA Cores
  GPU Max Clock rate:                            1815 MHz (1.81 GHz)
  Memory Clock rate:                             7000 Mhz
  Memory Bus Width:                              256-bit
  L2 Cache Size:                                 4194304 bytes
  ...
  Device PCI Domain ID / Bus ID / location ID:   0 / 8 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

Device 1: "GeForce RTX 2070"
  CUDA Driver Version / Runtime Version          10.1 / 10.1
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 7930 MBytes (8315076608 bytes)
  (36) Multiprocessors, ( 64) CUDA Cores/MP:     2304 CUDA Cores
  GPU Max Clock rate:                            1440 MHz (1.44 GHz)
  Memory Clock rate:                             7001 Mhz
  Memory Bus Width:                              256-bit
  L2 Cache Size:                                 4194304 bytes
  ...
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
> Peer access from GeForce RTX 2080 (GPU0) -> GeForce RTX 2070 (GPU1) : No
> Peer access from GeForce RTX 2070 (GPU1) -> GeForce RTX 2080 (GPU0) : No

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 10.1, CUDA Runtime Version = 10.1, NumDevs = 2, Device0 = GeForce RTX 2080, Device1 = GeForce RTX 2070
Result = PASS

Si vous souhai­tez utili­ser d’an­ciennes versions de CUDA repor­tez-vous à ce formu­laire d’ar­chives NVIDIA : https://deve­lo­per.NVIDIA.com/cuda-tool­kit-archive

Enfin, nous pouvons véri­fier que le compi­la­teur NVIDIA nvcc est dispo­nible.

Sous Linux

$ wich nvcc 

Sous Windows

$ where nvcc 

Si la commande précé­dente n’af­fiche rien, il convient de l’ajou­ter au PATH système.
Le compi­la­teur se trouve norma­le­ment dans le dossier /usr/local/cuda-<version>/bin qui doit pouvoir être acces­sible via le lien symbo­lique /usr/local/cuda/bin

$ export PATH=/usr/local/cuda/bin:$PATH  # sous Linux/Unix

C:> set PATH=%PATH%;"C:\Dossier\Contenant\Le\Compilateur"  # sous Windows

$ nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2019 NVIDIA Corporation
Built on Sun_Jul_28_19:07:16_PDT_2019
Cuda compilation tools, release 10.1, V10.1.243

L’ajout du compi­la­teur au PATH système sera néces­saire notam­ment pour la compi­la­tion de la librai­rie PyCuda.

Vous voilà prêt à travailler sur GPU et prendre en main votre carte graphique avec Python !