1 · Obtenir un GPU¶

Vous n'avez pas besoin d'un H100 pour apprendre. Vous avez besoin d'une carte sur laquelle compiler, exécuter et profiler.

1.1 Les trois voies¶

Voie	Coût	Ce que ça permet
Gratuit	0	apprendre les bases, jusqu'au profilage
Location à l'heure	0,3 à 40 $/h	tout, y compris Hopper et Blackwell
Achat	500 à 3 000 €	tout sauf les fonctionnalités de centre de données

1.2 Le gratuit¶

Google Colab¶

Le point d'entrée universel.

# Vérifier la carte attribuée
!nvidia-smi

Niveau gratuit : GPU T4 (Turing, sm_75) ou parfois mieux, avec des quotas variables et des déconnexions.
Colab Pro (~10 $/mois) : accès prioritaire, parfois L4 ou A100.

Ce que le T4 permet : tout le contenu des parties 1 à 3 et 5 à 7. Tensor cores de 2^e génération, mma.m16n8k8, profilage complet.

Ce qu'il ne permet pas : cp.async (Ampere), TMA, wgmma, clusters (Hopper), tcgen05 (Blackwell). Donc pas la partie 4, ni la partie 8.

Colab suffit pour 70 % de ce document

Ne laissez pas l'absence de H100 vous arrêter. La coalescence, les conflits de banc, la mémoire partagée, les réductions, la GEMM par tuiles, Triton : tout cela s'apprend sur un T4.

Kaggle Notebooks¶

30 heures de GPU par semaine, T4 ou P100. Sessions plus longues que Colab gratuit, et l'attribution est plus prévisible.

Les crédits d'essai¶

La plupart des fournisseurs cloud offrent des crédits à l'inscription (montants variables et changeants). C'est un moyen d'accéder ponctuellement à du matériel récent.

Les programmes académiques¶

Si vous êtes étudiant ou chercheur : les centres de calcul nationaux (Jean Zay en France, JUWELS en Allemagne, les installations du DOE aux États-Unis) donnent accès à des A100, H100, MI250X. Les procédures sont longues mais les ressources considérables.

1.3 La location à l'heure¶

C'est la meilleure option pour travailler sérieusement sans immobiliser de capital.

Les catégories de fournisseurs¶

Catégorie	Exemples	Caractéristiques
Places de marché	Vast.ai, RunPod (Community)	les moins chers, matériel de particuliers, fiabilité variable
Spécialistes GPU	Lambda Labs, CoreWeave, Together, Modal, Jarvislabs, Thunder Compute	bon compromis prix/fiabilité, préinstallé
Hyperscalers	AWS, GCP, Azure, OCI	les plus chers, intégration entreprise, quotas à demander

Les ordres de grandeur de prix¶

Ces prix varient constamment ; ils donnent l'ordre de grandeur en 2026.

Carte	Prix indicatif à l'heure
T4	0,15 – 0,40 $
RTX 4090 / 5090	0,30 – 0,90 $
L4 / L40S	0,50 – 1,50 $
A100 40/80 Go	1,00 – 2,50 $
H100	2,00 – 5,00 $
H200	3,00 – 6,00 $
B200	5,00 – 12,00 $
MI300X	2,00 – 4,00 $

Les pièges de la location

Le stockage persistant est facturé même à l'arrêt. Une machine éteinte avec 500 Go de disque coûte tous les jours.
Vérifiez que la carte est celle promise. nvidia-smi en premier.
Les instances spot sont 2 à 5× moins chères et peuvent être interrompues. Parfait pour apprendre, dangereux pour un entraînement long sans sauvegarde.
Le réseau et le transfert de données sont facturés séparément chez les hyperscalers, parfois lourdement.
Éteignez. L'erreur la plus coûteuse est une instance H100 oubliée un week-end : ~400 $.

Les plateformes serverless¶

Modal, Beam, Replicate : vous payez à la seconde d'exécution, sans gérer de machine.

import modal

app = modal.App("mon-noyau")
image = modal.Image.debian_slim().pip_install("torch", "triton")

@app.function(gpu="H100", image=image)
def tester():
    import torch
    print(torch.cuda.get_device_name())
    # ... votre code ...

@app.local_entrypoint()
def main():
    tester.remote()

Excellent pour tester un noyau sur du matériel récent sans monter une machine. Le démarrage à froid coûte quelques secondes, et vous ne payez que le temps d'exécution.

1.4 L'achat¶

Le tableau de décision¶

Budget	Carte	Ce que ça donne
300 – 600 €	RTX 3060 12 Go (occasion)	Ampere : `cp.async`, BF16, TF32. 12 Go.
600 – 900 €	RTX 4070 Ti Super 16 Go	Ada, 16 Go
1 500 – 2 000 €	RTX 4090 24 Go (occasion)	24 Go, très rapide
2 000 – 3 000 €	RTX 5090 32 Go	Blackwell : `tcgen05`, FP4, 32 Go

La recommandation

Si vous achetez pour apprendre la programmation GPU, la RTX 5090 est le meilleur choix : c'est la seule carte grand public avec l'architecture Blackwell, donc tcgen05, la Tensor Memory et le FP4.

À budget contraint, une RTX 3060 12 Go d'occasion couvre tout le contenu Ampere (copies asynchrones, BF16, TF32) pour quelques centaines d'euros.

Ce qu'aucune carte grand public ne donne

TMA, clusters, DSMEM, wgmma : Hopper seulement. La RTX 5090 est Blackwell mais consumer (sm_120), pas sm_100 — vérifiez le support instruction par instruction.
FP64 rapide : bridé au 1/64 sur toutes les cartes GeForce.
NVLink : supprimé du grand public depuis Ada.
La mémoire : 32 Go maximum contre 192 sur B200.

Le cas Apple Silicon¶

Un Mac avec puce M-series permet d'apprendre la programmation GPU via Metal ou Mojo. La plupart des Mojo GPU Puzzles fonctionnent sur Apple Silicon.

Les concepts fondamentaux — indexation, mémoire partagée (threadgroup memory), groupes SIMD de 32, réductions, pavage — sont identiques. C'est une plateforme d'apprentissage viable, et la mémoire unifiée permet de charger de très gros modèles.

Ce qui manque : CUDA, les tensor cores accessibles directement, et tout l'écosystème.

1.5 Ce qu'il faut pour chaque partie du document¶

Partie	Matériel minimal
1 · Fondations	aucun (lecture)
2 · Modèle de programmation	n'importe quel GPU CUDA
3 · Performance	idem, Nsight installé
4 · CUDA moderne	Ampere (`cp.async`), Hopper pour TMA/`wgmma`, Blackwell pour `tcgen05`
5 · Écosystème	n'importe quel GPU, AMD pour le chapitre 8
6 · Domaines	variable
7 · IA	n'importe quel GPU, Ampere+ recommandé
8 · Megakernels	Hopper ou Blackwell en pratique
9 · Pratique	n'importe quel GPU

Stratégie recommandée : une carte modeste (ou Colab) pour l'apprentissage quotidien, et quelques heures de location de H100 ou B200 quand vous abordez les parties 4 et 8. Le coût total est de quelques dizaines d'euros.

1.6 Vérifier ce qu'on a¶

nvidia-smi                    # carte, pilote, mémoire, processus
nvidia-smi -q | head -50      # détail complet

import torch
print(torch.cuda.get_device_name(0))
props = torch.cuda.get_device_properties(0)
print(f"Compute capability : {props.major}.{props.minor}")
print(f"SM                 : {props.multi_processor_count}")
print(f"Mémoire            : {props.total_memory / 1e9:.1f} Go")
print(f"Mém. partagée/bloc : {props.shared_memory_per_block / 1024:.0f} Ko")

Compute capability	Architecture	Ce qui est disponible
7.0, 7.5	Volta, Turing	tensor cores 1^re/2^e gén.
8.0, 8.6, 8.9	Ampere, Ada	`cp.async`, BF16, TF32, sparsité 2:4
9.0	Hopper	TMA, clusters, `wgmma`, FP8
10.0	Blackwell (DC)	`tcgen05`, TMEM, FP4
12.0	Blackwell (grand public)	variable — vérifier

Résumé du chapitre¶

À retenir

Colab gratuit (T4) couvre 70 % de ce document. Ne pas laisser l'absence de H100 vous arrêter.
Pour les parties 4 et 8, il faut Hopper ou Blackwell : louer quelques heures suffit (2 à 12 $/h).
Les plateformes serverless (Modal, Beam) sont idéales pour tester un noyau sur du matériel récent sans gérer de machine.
À l'achat : RTX 5090 pour Blackwell, RTX 3060 12 Go d'occasion pour un budget minimal couvrant Ampere.
Aucune carte grand public n'a TMA, clusters, NVLink ni FP64 rapide.
Apple Silicon est une plateforme d'apprentissage viable via Metal et les Mojo GPU Puzzles.
Éteignez vos instances louées.

Vérifiez que vous avez compris¶

Vous avez 200 € pour apprendre la programmation GPU. Comment les dépenser ?

Probablement pas en achetant du matériel.

Une répartition raisonnable :

0 € : Colab gratuit et Kaggle pour les parties 1 à 3, 5 à 7. C'est l'essentiel du volume.
~50 € : quelques dizaines d'heures de RTX 4090 ou A100 sur Vast.ai ou RunPod, pour travailler confortablement sans quotas.
~100 € : une vingtaine d'heures de H100 ou B200 pour les parties 4 et 8 — TMA, wgmma, tcgen05, megakernels.
~50 € : réserve.

200 € d'achat donneraient une carte ancienne (GTX 1660, sans tensor cores) qui ne couvrirait pas le contenu moderne. La location donne accès au matériel de pointe.

Votre RTX 4090 a 24 Go. Pouvez-vous travailler sur les megakernels ?

Partiellement, et avec des limites sérieuses.

Ce qui fonctionne : les concepts (noyau persistant, compteurs, allocateur de pages, dispatch d'instructions) s'implémentent sur n'importe quelle architecture. Vous pouvez écrire un megakernel fonctionnel.

Ce qui manque :

pas de TMA ni de wgmma (Ada, sm_89), donc pas la structure producteur/consommateur qui fait l'efficacité des megakernels Hopper ;
100 Ko de mémoire partagée par SM au lieu de 227, ce qui contraint fortement l'allocateur de pages ;
modèles limités à ~24 Go.

C'est précisément le problème traité par Ada-MK, qui cible « les GPU à ressources contraintes comme NVIDIA Ada » avec un découpage selon la dimension K et une réduction de 50 % du pic de mémoire partagée.

Vous pouvez donc apprendre et expérimenter, mais pas reproduire les résultats Hopper.

Une instance spot à 0,80 $/h contre une instance dédiée à 2,50 $/h. Laquelle ?

Spot pour apprendre, dédiée pour un travail long.

Une instance spot peut être interrompue avec un préavis court (souvent 2 minutes, parfois aucun). Pour de l'expérimentation interactive — écrire un noyau, le compiler, le profiler — l'interruption coûte quelques minutes de reconfiguration.

Pour un entraînement de plusieurs heures sans sauvegarde intermédiaire, une interruption détruit tout le travail.

La bonne pratique : spot + sauvegarde fréquente + reprise automatique. C'est un peu de travail d'infrastructure qui divise la facture par 3.

Chapitre suivant : 2 · Mettre en place l'environnement