NVIDIA H100 GPU : Alimenter la prochaine vague d'innovation en IA

GPU NVIDIA H100 : au cœur de la prochaine vague d'innovation en IA

Le paysage moderne de l'IA se caractérise par des progrès stupéfiants. Chaque semaine, les grands laboratoires de recherche et les fournisseurs de cloud publient de nouvelles avancées — des grands modèles de langage qui écrivent du code aux modèles de diffusion qui génèrent des images photoréalistes. Les blogs IA d'OpenAI, Google et Microsoft offrent un flux constant de ces progrès, tandis que des entreprises d'infrastructure comme Replicate partagent des conseils pratiques pour déployer et exécuter des modèles de pointe. Au cœur de cette révolution se trouve le GPU NVIDIA H100. Conçu sur l'architecture Hopper, le H100 est spécifiquement conçu pour répondre aux énormes exigences de calcul de l'entraînement et du service des modèles d'apprentissage profond les plus avancés.

Le H100 n'est pas simplement une version plus rapide de son prédécesseur ; il représente un changement fondamental dans la façon dont nous concevons les systèmes d'IA. Avec son moteur Transformer dédié, ses opérations tensorielles accélérées et son énorme bande passante mémoire, le H100 est devenu le cheval de bataille de facto des organisations qui entraînent des modèles à l'échelle frontalière. Mais un matériel haut de gamme n'est aussi utile que votre capacité à le mettre en œuvre. Dans cet article, je vais vous présenter un guide complet et pratique pour rendre un GPU H100 opérationnel sur un serveur Linux, de l'installation du pilote à l'exécution de véritables charges de travail d'entraînement.

Prérequis

Avant de plonger dans les commandes et les fichiers de configuration, établissons ce dont vous avez besoin pour suivre ce guide avec succès.

Prérequis matériels

• **GPU NVIDIA H100** : Le H100 est disponible en plusieurs facteurs de forme, notamment le module SXM5 (généralement présent sur les cartes mères HGX ou les systèmes NVIDIA DGX) et la variante PCIe pour les serveurs standard. Les deux fonctionnent pour les étapes ci-dessous, mais les modules SXM nécessitent une plateforme serveur compatible.
• **Système hôte** : Un serveur x86_64 ou ARM64 avec au moins un emplacement PCIe haute bande passante libre (pour la version PCIe) ou un système NVIDIA HGX pré-construit.
• **Mémoire système** : Au moins 32 Go de RAM sont recommandés. Pour les grandes tailles de lots et l'entraînement multi-GPU, envisagez 64 Go ou plus.
• **Stockage** : Un SSD NVMe rapide avec au moins 100 Go libres pour le système d'exploitation, les pilotes, le toolkit CUDA et les modèles d'exemple. Les ensembles de données d'entraînement nécessiteront un espace supplémentaire.
• **Alimentation** : Les cartes H100 PCIe consomment jusqu'à 350 W, et les modules SXM peuvent consommer jusqu'à 700 W. Assurez-vous que votre budget d'alimentation et votre refroidissement sont suffisants pour un fonctionnement continu.

Prérequis logiciels

• **Système d'exploitation** : Ubuntu 22.04 LTS est utilisé dans ce guide, mais les commandes sont largement compatibles avec d'autres distributions Linux modernes.
• **Pilote NVIDIA** : Une version récente du pilote (525.60.13 ou ultérieure) est requise pour le support du H100.
• **Toolkit CUDA** : CUDA 12.x est recommandé pour un support complet de l'architecture Hopper, y compris le Transformer Engine.
• **Runtime de conteneurs** : Docker avec le NVIDIA Container Toolkit est facultatif mais fortement recommandé pour des environnements IA reproductibles.

Exigences d'accès

Vous aurez besoin d'un accès administrateur (sudo) à la machine. Si vous louez une instance cloud H100, votre fournisseur proposera probablement une image de base avec les pilotes pré-installés. Néanmoins, il est utile de comprendre le processus d'installation à partir de zéro, surtout si vous provisionnez votre propre matériel.

Installation étape par étape

Nous arrivons maintenant au cœur du sujet. Le processus est le suivant : identifier le matériel, installer le pilote NVIDIA, installer CUDA, ajouter cuDNN et le toolkit de conteneurs, puis vérifier le tout avec `nvidia-smi`.

Étape 1 : Vérifier que le GPU est visible

Avant d'installer quoi que ce soit, confirmez que le système d'exploitation peut voir le H100. Tout d'abord, utilisez `lspci` pour lister tous les périphériques PCI et filtrer pour NVIDIA :

lspci | grep -i nvidia

Vous devriez voir une ligne de sortie contenant « NVIDIA » et un nom de périphérique tel que « H100 » ou « H100 SXM ». Si rien n'apparaît, vérifiez le logement physique de la carte, les câbles d'alimentation et les paramètres du BIOS (assurez-vous que les emplacements PCIe sont activés).

Étape 2 : Mettre à jour le système et installer les outils de compilation

Le pilote NVIDIA est fourni sous forme de module noyau, vous aurez donc besoin des en-têtes du noyau Linux et d'un compilateur C. Mettez à jour la liste des paquets et installez les éléments essentiels :

sudo apt update && sudo apt upgrade -y

Cela garantit que votre système est entièrement corrigé avant de continuer. Ensuite, installez les outils nécessaires à la compilation des modules noyau :

sudo apt install -y build-essential dkms linux-headers-$(uname -r)

Le paquet `linux-headers-$(uname -r)` fournit les en-têtes exacts pour votre noyau actuel, dont dépend le processus de compilation du pilote NVIDIA.

Étape 3 : Installer le pilote NVIDIA

Il existe deux méthodes courantes pour installer le pilote : utiliser le gestionnaire de paquets de la distribution, ou utiliser le fichier .run officiel de NVIDIA. Pour la plupart des utilisateurs, l'approche par gestionnaire de paquets est plus simple et plus facile à maintenir. Sur Ubuntu, `ubuntu-drivers` peut automatiquement sélectionner et installer la version de pilote recommandée :

sudo ubuntu-drivers install

L'outil `ubuntu-drivers` lit la base de données matérielle et sélectionne le pilote propriétaire le plus approprié pour votre GPU. Une fois l'installation terminée, redémarrez le système pour que le module noyau du pilote puisse se charger :

sudo reboot

Une fois la machine de nouveau en ligne, vérifiez l'état du pilote avec :

nvidia-smi

Si la commande s'exécute correctement, vous verrez un tableau montrant votre H100, la version du pilote et la quantité de mémoire GPU. Pour les environnements de production, vous souhaiterez peut-être installer une version spécifique du pilote. Dans ce cas, téléchargez le fichier `.run` souhaité depuis le site officiel de NVIDIA et exécutez-le avec :

sudo sh NVIDIA-Linux-*.run

Lorsque vous utilisez le fichier .run, assurez-vous que le module noyau NVIDIA n'est pas déjà chargé, sinon l'installateur vous avertira. L'approche par gestionnaire de paquets est plus propre dans la plupart des scénarios.

Étape 4 : Installer le toolkit CUDA

Une fois le pilote installé, la couche suivante est le toolkit CUDA, qui fournit le compilateur `nvcc` et les bibliothèques CUDA. Sur Ubuntu, vous pouvez installer le toolkit directement depuis le dépôt de paquets NVIDIA. Tout d'abord, ajoutez la clé du dépôt CUDA NVIDIA :

sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb

Notez que `apt-key` est déprécié sur les systèmes plus récents ; une approche plus moderne consiste à télécharger et installer le paquet keyring :

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb

Installez ensuite le paquet téléchargé et mettez à jour la liste des paquets :

sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update

Installez maintenant le toolkit CUDA complet :

sudo apt install -y cuda-toolkit-12-4

Cela installe CUDA 12.4, qui prend entièrement en charge l'architecture H100. Pour la version la plus récente, remplacez `12-4` par le numéro de version le plus récent disponible. Une fois l'installation terminée, ajoutez les binaires et bibliothèques CUDA à votre PATH et LD_LIBRARY_PATH :

export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH

Pour rendre ces variables persistantes entre les sessions, ajoutez-les à votre profil shell :

echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

Vérifiez le compilateur avec :

nvcc --version

Vous devriez voir une sortie de version confirmant que CUDA 12.4 est actif. Notez que cela a installé le toolkit au niveau du système ; si vous préférez, vous pouvez installer uniquement le runtime CUDA via les paquets `libcudart` et gérer les dépendances CUDA dans un conteneur Docker. Nous reviendrons sur cette option plus tard.

Étape 5 : Installer cuDNN

cuDNN (bibliothèque de réseaux neuronaux profonds CUDA) fournit des implémentations hautement optimisées d'opérations de réseaux neuronaux telles que les convolutions et les couches récurrentes. C'est un prérequis pour la plupart des frameworks d'apprentissage profond. Téléchargez le paquet debian cuDNN approprié depuis le portail développeur NVIDIA (une inscription est requise), puis installez-le :

sudo dpkg -i cudnn-linux-x86_64-*.deb

Alternativement, si vous avez installé le toolkit CUDA via le dépôt, vous pouvez utiliser `apt` directement :

sudo apt install -y libcudnn8 libcudnn8-dev

Le paquet `libcudnn8` contient les bibliothèques d'exécution, tandis que `libcudnn8-dev` inclut les en-têtes nécessaires pour compiler avec cuDNN. Après l'installation, vérifiez que cuDNN est trouvé en vérifiant le chemin des bibliothèques :

ldconfig -p | grep cudnn

Étape 6 : Installer le NVIDIA Container Toolkit (Docker)

Si vous prévoyez d'utiliser Docker — et je le recommande vivement pour isoler vos environnements IA — vous aurez besoin du NVIDIA Container Toolkit afin que les conteneurs puissent accéder au GPU. Tout d'abord, assurez-vous que Docker est installé :

sudo apt install -y docker.io
sudo systemctl enable --now docker

Ensuite, installez le NVIDIA Container Toolkit. Commencez par ajouter le dépôt officiel de NVIDIA à vos sources apt :

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

Ajoutez ensuite l'entrée du dépôt :

echo "deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://nvidia.github.io/libnvidia-container/stable/deb/$(lsb_release -cs)/" | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Mettez à jour et installez le toolkit :

sudo apt update
sudo apt install -y nvidia-container-toolkit

Redémarrez maintenant Docker pour que les changements prennent effet :

sudo systemctl restart docker

Étape 7 : Tout vérifier

Enfin, vérifiez que toute la pile fonctionne ensemble. Exécutez un conteneur qui utilise le GPU :

docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi

Si le conteneur affiche le tableau GPU, votre pilote, CUDA et le runtime de conteneurs sont correctement configurés. Vous disposez maintenant d'une machine H100 entièrement équipée, prête pour l'apprentissage profond.

Exemples d'utilisation

Avec une configuration fonctionnelle, examinons des moyens pratiques d'utiliser le H100. Nous verrons comment vérifier la disponibilité du GPU avec PyTorch, entraîner un petit modèle et lancer un travail multi-GPU.

Exemple 1 : Vérification de la disponibilité du GPU avec PyTorch

PyTorch est le framework le plus utilisé pour la recherche en IA, et il est fourni pré-compilé avec le support CUDA. Commencez par installer PyTorch dans un nouvel environnement virtuel :

python3 -m venv h100-env
source h100-env/bin/activate

Installez ensuite la dernière version de PyTorch avec le support CUDA :

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

Le drapeau `--index-url` garantit que vous obtenez la version groupée avec le support CUDA 12.4. Créez maintenant un court script Python pour vérifier que le H100 est détecté :

python <<EOF
import torch
print("CUDA available:", torch.cuda.is_available())
print("GPU count:", torch.cuda.device_count())
print("GPU name:", torch.cuda.get_device_name(0))
EOF

Vous devriez voir une sortie comme `CUDA available: True` et `GPU name: NVIDIA H100`. Ensuite, exécutez une simple opération tensorielle sur le GPU pour confirmer que les calculs sont réellement exécutés sur le périphérique :

import torch

# Créer un grand tenseur aléatoire directement sur le GPU
x = torch.randn(10000, 10000, device="cuda")
y = torch.randn(10000, 10000, device="cuda")

# Effectuer une multiplication matricielle sur le H100
z = x @ y

# Synchroniser et rapporter la forme du résultat
torch.cuda.synchronize()
print("Multiplication matricielle terminée. Forme du résultat :", z.shape)

Le mélange de `device="cuda"` et de `torch.cuda.synchronize()` garantit que les opérations sont placées sur le H100 et que le code Python attend la fin du calcul.

Exemple 2 : Entraînement d'un petit réseau de neurones

Entraînons un réseau de neurones léger sur l'ensemble de données MNIST pour voir le H100 en action. Tout d'abord, assurez-vous d'avoir `torchvision` installé (nous l'avons déjà fait ci-dessus). Enregistrez ensuite le script d'entraînement suivant dans un fichier :

# train_mnist.py
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# Définir un simple réseau feed-forward
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28 * 28, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

    def forward(self, x):
        return self.fc(x)

# Charger l'ensemble de données MNIST
transform = transforms.ToTensor()
train_dataset = datasets.MNIST(root="./data", train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

# Créer le modèle, la fonction de perte et l'optimiseur, et tout déplacer sur le GPU
model = SimpleNet().cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# Entraîner pendant quelques époques
for epoch in range(3):
    total_loss = 0.0
    for images, labels in train_loader:
        images, labels = images.cuda(), labels.cuda()
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    print(f"Époque {epoch + 1}, Perte : {total_loss / len(train_loader):.4f}")

Exécutez le script avec :

python train_mnist.py

Même si ce modèle est petit, vous remarquerez que l'entraînement est extrêmement rapide. Le H100 est surdimensionné pour MNIST, mais le flux de travail démontre comment votre framework interagit avec le GPU.

Exemple 3 : Entraînement multi-GPU avec `torchrun`

Les modèles d'IA réels nécessitent plusieurs GPU. Le H100 est souvent déployé en grappes de huit ou plus. L'utilitaire `torchrun` de PyTorch simplifie l'entraînement distribué en parallèle de données. Supposons que vous ayez un serveur avec huit GPU H100 et que vous souhaitiez lancer l'entraînement sur tous. Tout d'abord, écrivez une fonction d'entraînement qui utilise `DistributedDataParallel` :

# ddp_train.py
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.nn.parallel import DistributedDataParallel as DDP

def main():
    dist.init_process_group("nccl")
    local_rank = int(os.environ["LOCAL_RANK"])

    model = nn.Linear(1024, 1024).cuda(local_rank)
    model = DDP(model, device_ids=[local_rank])

    optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

    for step in range(100):
        x = torch.randn(256, 1024).cuda(local_rank)
        y = model(x).sum()
        optimizer.zero_grad()
        y.backward()
        optimizer.step()

    dist.destroy_process_group()

if __name__ == "__main__":
    import os
    main()

Lancez ensuite le travail avec `torchrun`, en lui indiquant de générer un processus par GPU :

torchrun --nproc_per_node=8 ddp_train.py

Le backend NCCL gérera la communication à haute vitesse entre les GPU H100, que ce soit via NVLink à l'intérieur du même nœud ou via InfiniBand entre les nœuds.

Exemple 4 : Exécution d'un conteneur pré-construit

Pour des expériences reproductibles, tirez un conteneur d'apprentissage profond pré-construit qui inclut PyTorch et CUDA, puis exécutez votre code à l'intérieur. Le catalogue NGC fournit des conteneurs officiels :

docker run --gpus all -it --shm-size=8g nvcr.io/nvidia/pytorch:24.04-py3 bash

Le drapeau `--shm-size=8g` augmente la mémoire partagée disponible pour les travailleurs DataLoader, ce qui est une source courante de plantages dans les conteneurs d'entraînement. Une fois à l'intérieur du conteneur, vous pouvez exécuter `python` et accéder au GPU exactement comme sur l'hôte. Cette approche est particulièrement utile pour partager des environnements avec des collaborateurs.

Conclusion

Le GPU NVIDIA H100 est plus qu'un simple morceau de matériel ; c'est le moteur qui propulse la vague actuelle d'innovation en intelligence artificielle. Les progrès visibles sur les blogs IA d'OpenAI, Google et Microsoft — de nouveaux modèles avec un raisonnement émergent, des outils qui génèrent du code et de l'art, et des systèmes qui comprennent des entrées multimodales — seraient inimaginables sans la capacité de calcul que des GPU comme le H100 fournissent. Pendant ce temps, des plateformes comme Replicate, qui ont écrit sur la façon dont elles déploient des H100 à grande échelle, rendent cette technologie accessible aux développeurs qui ne possèdent pas leurs propres centres de données.

Dans cet article, je vous ai emmené d'un serveur nu à un poste de travail d'apprentissage profond entièrement configuré. Nous avons vérifié le GPU, installé le pilote NVIDIA, configuré CUDA et cuDNN, configuré Docker, et exécuté des charges de travail mono-GPU et multi-GPU. La puissance du H100 est étonnante, mais elle est aussi exigeante : elle nécessite une gestion minutieuse de l'alimentation, une pile logicielle moderne et une approche disciplinée de la conteneurisation pour être utilisée efficacement.

Alors que la recherche en IA s'accélère, l'écart entre les modèles simplement possibles et les modèles pratiques continuera de se réduire. Avec un H100 dans votre arsenal, vous êtes bien positionné pour être à la pointe de cette courbe. Les commandes et les exemples de cet article sont votre point de départ. Allez maintenant construire quelque chose de remarquable.