## NVIDIA H100 GPUs: Treibende Kraft der nächsten KI-Innovationswelle

NVIDIA H100 GPUs: Treibende Kraft der nächsten KI-Innovationswelle

Die moderne KI-Landschaft ist geprägt von erstaunlichem Fortschritt. Jede Woche veröffentlichen große Forschungslabore und Cloud-Anbieter neue Durchbrüche – von großen Sprachmodellen, die Code schreiben, bis hin zu Diffusionsmodellen, die fotorealistische Bilder erzeugen. Die KI-Blogs von OpenAI, Google und Microsoft bieten einen ständigen Strom dieser Fortschritte, während Infrastrukturunternehmen wie Replicate praktische Anleitungen zur Bereitstellung und zum Betrieb modernster Modelle teilen. Im Herzen dieser Revolution sitzt die NVIDIA H100 GPU. Basierend auf der Hopper-Architektur ist die H100 speziell dafür entwickelt, die enormen Rechenanforderungen beim Training und Serving modernster Deep-Learning-Modelle zu bewältigen.

Die H100 ist nicht nur eine schnellere Version ihres Vorgängers; sie repräsentiert einen grundlegenden Wandel in der Art, wie wir KI-Systeme entwerfen. Mit ihrem dedizierten Transformer-Engine, beschleunigten Tensor-Operationen und enormer Speicherbandbreite ist die H100 zum De-facto-Arbeitspferd für Organisationen geworden, die Modelle an der Spitze der Entwicklung trainieren. Doch Hochleistungshardware ist nur so nützlich wie die Fähigkeit, sie einzusetzen. In diesem Artikel führe ich Sie durch eine vollständige, praxisnahe Anleitung, um eine H100 GPU auf einem Linux-Server betriebsbereit zu machen – von der Treiberinstallation bis zum Ausführen realer Trainings-Workloads.

Voraussetzungen

Bevor wir uns in Befehle und Konfigurationsdateien stürzen, klären wir, was Sie benötigen, um erfolgreich mitzumachen.

Hardware-Anforderungen

• **NVIDIA H100 GPU**: Die H100 ist in verschiedenen Formfaktoren erhältlich, darunter das SXM5-Modul (typischerweise in HGX-Boards oder NVIDIA-DGX-Systemen) sowie die PCIe-Variante für Standardserver. Beide funktionieren für die folgenden Schritte, aber SXM-Module erfordern eine kompatible Serverplattform.
• **Hostsystem**: Ein x86_64- oder ARM64-Server mit mindestens einem freien High-Bandwidth-PCIe-Steckplatz (für die PCIe-Version) oder ein vorgefertigtes NVIDIA-HGX-System.
• **Arbeitsspeicher**: Mindestens 32 GB RAM werden empfohlen. Für große Batch-Größen und Multi-GPU-Training sollten Sie 64 GB oder mehr einplanen.
• **Speicher**: Eine schnelle NVMe-SSD mit mindestens 100 GB freiem Speicher für Betriebssystem, Treiber, CUDA-Toolkit und Beispielmodelle. Trainingsdatensätze benötigen zusätzlichen Platz.
• **Netzteil**: H100-PCIe-Karten ziehen bis zu 350 W, SXM-Module bis zu 700 W. Stellen Sie sicher, dass Ihr Leistungsbudget und Ihre Kühlung für den Dauerbetrieb ausreichen.

Software-Anforderungen

• **Betriebssystem**: In dieser Anleitung wird Ubuntu 22.04 LTS verwendet, die Befehle sind jedoch weitgehend mit anderen modernen Linux-Distributionen kompatibel.
• **NVIDIA-Treiber**: Eine aktuelle Treiberversion (525.60.13 oder neuer) ist für H100-Unterstützung erforderlich.
• **CUDA-Toolkit**: CUDA 12.x wird für die volle Hopper-Architektur-Unterstützung empfohlen, einschließlich der Transformer-Engine.
• **Container-Laufzeit**: Docker mit dem NVIDIA Container Toolkit ist optional, aber für reproduzierbare KI-Umgebungen sehr empfehlenswert.

Zugriffsanforderungen

Sie benötigen Administrator-Zugriff (sudo) auf die Maschine. Wenn Sie eine H100-Cloud-Instanz mieten, bietet Ihr Anbieter wahrscheinlich ein Basis-Image mit vorinstallierten Treibern an. Dennoch ist es wertvoll, den Einrichtungsprozess von Grund auf zu verstehen, insbesondere wenn Sie Ihre eigene Hardware bereitstellen.

Schritt-für-Schritt-Installation

Jetzt kommen wir zum Kern der Sache. Die Pipeline sieht so aus: Hardware identifizieren, NVIDIA-Treiber installieren, CUDA installieren, cuDNN und das Container-Toolkit hinzufügen und schließlich alles mit `nvidia-smi` verifizieren.

Schritt 1: Prüfen, ob die GPU sichtbar ist

Bevor Sie etwas installieren, bestätigen Sie, dass das Betriebssystem die H100 sehen kann. Verwenden Sie zunächst `lspci`, um alle PCI-Geräte aufzulisten und nach NVIDIA zu filtern:

lspci | grep -i nvidia

Sie sollten eine Ausgabezeile sehen, die "NVIDIA" und einen Gerätenamen wie "H100" oder "H100 SXM" enthält. Wenn nichts angezeigt wird, überprüfen Sie den physischen Sitz der Karte, die Stromkabel und die BIOS-Einstellungen (stellen Sie sicher, dass PCIe-Steckplätze aktiviert sind).

Schritt 2: System aktualisieren und Build-Tools installieren

Der NVIDIA-Treiber wird als Kernel-Modul ausgeliefert, daher benötigen Sie die Linux-Kernel-Header und einen C-Compiler. Aktualisieren Sie die Paketliste und installieren Sie die Grundlagen:

sudo apt update && sudo apt upgrade -y

Dadurch wird sichergestellt, dass Ihr System vollständig gepatcht ist, bevor wir fortfahren. Installieren Sie als Nächstes die Werkzeuge, die zum Erstellen von Kernel-Modulen erforderlich sind:

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

Das Paket `linux-headers-$(uname -r)` liefert die exakten Header für Ihren aktuellen Kernel, von denen der NVIDIA-Treiber-Build-Prozess abhängt.

Schritt 3: NVIDIA-Treiber installieren

Es gibt zwei gängige Möglichkeiten, den Treiber zu installieren: über den Paketmanager der Distribution oder über die offizielle NVIDIA-Runfile. Für die meisten Benutzer ist der Paketmanager-Ansatz einfacher und wartbarer. Unter Ubuntu kann `ubuntu-drivers` automatisch die empfohlene Treiberversion auswählen und installieren:

sudo ubuntu-drivers install

Das Tool `ubuntu-drivers` liest die Hardware-Datenbank und wählt den am besten geeigneten proprietären Treiber für Ihre GPU aus. Nach Abschluss der Installation starten Sie das System neu, damit das Treiber-Kernel-Modul geladen werden kann:

sudo reboot

Sobald die Maschine wieder online ist, überprüfen Sie den Treiberstatus mit:

nvidia-smi

Wenn der Befehl erfolgreich ausgeführt wird, sehen Sie eine Tabelle mit Ihrer H100, der Treiberversion und der Menge an GPU-Speicher. Für Produktionsumgebungen möchten Sie möglicherweise stattdessen eine bestimmte Treiberversion installieren. Laden Sie in diesem Fall die gewünschte `.run`-Datei von der offiziellen NVIDIA-Website herunter und führen Sie sie mit folgendem Befehl aus:

sudo sh NVIDIA-Linux-*.run

Stellen Sie bei Verwendung der Runfile sicher, dass das NVIDIA-Kernel-Modul nicht bereits geladen ist, da der Installer Sie sonst warnt. Der Paketmanager-Ansatz ist für die meisten Szenarien sauberer.

Schritt 4: CUDA-Toolkit installieren

Mit installiertem Treiber ist die nächste Ebene das CUDA-Toolkit, das den `nvcc`-Compiler und CUDA-Bibliotheken bereitstellt. Unter Ubuntu können Sie das Toolkit direkt aus dem NVIDIA-Paketrepository installieren. Fügen Sie zunächst den Schlüsselbund für das NVIDIA-CUDA-Repository hinzu:

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

Beachten Sie, dass `apt-key` auf neueren Systemen veraltet ist; ein modernerer Ansatz besteht darin, das Schlüsselbundpaket herunterzuladen und zu installieren:

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

Installieren Sie dann das heruntergeladene Paket und aktualisieren Sie die Paketliste:

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

Jetzt installieren Sie das vollständige CUDA-Toolkit:

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

Dies installiert CUDA 12.4, das volle Unterstützung für die H100-Architektur bietet. Für die neueste Version ersetzen Sie `12-4` durch die aktuell verfügbare Versionsnummer. Sobald die Installation abgeschlossen ist, fügen Sie die CUDA-Binärdateien und -Bibliotheken zu Ihrem PATH und LD_LIBRARY_PATH hinzu:

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

Um diese Einstellungen über Sitzungen hinweg dauerhaft zu machen, fügen Sie sie Ihrem Shell-Profil hinzu:

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

Überprüfen Sie den Compiler mit:

nvcc --version

Sie sollten die Versionsausgabe sehen, die bestätigt, dass CUDA 12.4 aktiv ist. Beachten Sie, dass das Toolkit systemweit installiert wurde; wenn Sie es vorziehen, können Sie nur die CUDA-Laufzeit über `libcudart`-Pakete installieren und CUDA-Abhängigkeiten innerhalb eines Docker-Containers verwalten. Wir werden diese Option später erneut aufgreifen.

Schritt 5: cuDNN installieren

cuDNN (CUDA Deep Neural Network library) bietet hochoptimierte Implementierungen neuronaler Netzwerkoperationen wie Faltungen und rekurrente Schichten. Es ist eine Voraussetzung für die meisten Deep-Learning-Frameworks. Laden Sie das entsprechende cuDNN-Debian-Paket vom NVIDIA-Entwicklerportal herunter (eine Registrierung ist erforderlich) und installieren Sie es dann:

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

Alternativ können Sie, wenn Sie das CUDA-Toolkit über das Repository installiert haben, `apt` direkt verwenden:

sudo apt install -y libcudnn8 libcudnn8-dev

Das Paket `libcudnn8` enthält die Laufzeitbibliotheken, während `libcudnn8-dev` die Header enthält, die zum Kompilieren gegen cuDNN benötigt werden. Überprüfen Sie nach der Installation, ob cuDNN gefunden wird, indem Sie den Bibliothekspfad prüfen:

ldconfig -p | grep cudnn

Schritt 6: NVIDIA Container Toolkit (Docker) installieren

Wenn Sie Docker verwenden möchten – und ich empfehle dies dringend zur Isolierung Ihrer KI-Umgebungen – benötigen Sie das NVIDIA Container Toolkit, damit Container auf die GPU zugreifen können. Stellen Sie zunächst sicher, dass Docker installiert ist:

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

Installieren Sie als Nächstes das NVIDIA Container Toolkit. Fügen Sie zunächst das offizielle NVIDIA-Repository zu Ihren apt-Quellen hinzu:

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

Fügen Sie dann den Repository-Eintrag hinzu:

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

Aktualisieren und installieren Sie das Toolkit:

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

Starten Sie nun Docker neu, damit die Änderungen wirksam werden:

sudo systemctl restart docker

Schritt 7: Alles verifizieren

Überprüfen Sie abschließend, ob der gesamte Stack zusammen funktioniert. Führen Sie einen Container aus, der die GPU verwendet:

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

Wenn der Container die GPU-Tabelle ausgibt, sind Treiber, CUDA und Container-Laufzeit korrekt konfiguriert. Sie haben jetzt eine voll ausgestattete H100-Maschine, bereit für Deep Learning.

Anwendungsbeispiele

Bei einer funktionsfähigen Einrichtung schauen wir uns praktische Möglichkeiten zur Nutzung der H100 an. Wir werden die Überprüfung der GPU-Verfügbarkeit mit PyTorch, das Training eines kleinen Modells und das Starten eines Multi-GPU-Jobs behandeln.

Beispiel 1: PyTorch GPU-Sanity-Check

PyTorch ist das am weitesten verbreitete Framework für KI-Forschung und wird mit vorab kompilierter CUDA-Unterstützung ausgeliefert. Beginnen Sie mit der Installation von PyTorch in einer frischen virtuellen Umgebung:

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

Installieren Sie dann den neuesten PyTorch-Build mit CUDA-Unterstützung:

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

Das Flag `--index-url` stellt sicher, dass Sie den Build mit CUDA-12.4-Unterstützung erhalten. Erstellen Sie nun ein kurzes Python-Skript, um zu überprüfen, ob die H100 erkannt wird:

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

Sie sollten eine Ausgabe wie `CUDA available: True` und `GPU name: NVIDIA H100` sehen. Führen Sie als Nächstes eine einfache Tensoroperation auf der GPU aus, um zu bestätigen, dass Berechnungen tatsächlich auf dem Gerät ausgeführt werden:

import torch

# Create a large random tensor directly on the GPU
x = torch.randn(10000, 10000, device="cuda")
y = torch.randn(10000, 10000, device="cuda")

# Perform matrix multiplication on the H100
z = x @ y

# Synchronize and report the result shape
torch.cuda.synchronize()
print("Matrix multiplication complete. Result shape:", z.shape)

Die Kombination aus `device="cuda"` und `torch.cuda.synchronize()` stellt sicher, dass Operationen auf der H100 platziert werden und dass der Python-Code auf den Abschluss der Berechnung wartet.

Beispiel 2: Training eines kleinen neuronalen Netzes

Lassen Sie uns ein leichtes neuronales Netzwerk auf dem MNIST-Datensatz trainieren, um die H100 in Aktion zu sehen. Stellen Sie zunächst sicher, dass `torchvision` installiert ist (haben wir oben bereits erledigt). Speichern Sie dann das folgende Trainingsskript in einer Datei:

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

# Define a simple feed-forward network
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)

# Load the MNIST dataset
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)

# Create the model, loss, and optimizer, and move everything to the GPU
model = SimpleNet().cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# Train for a few epochs
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"Epoch {epoch + 1}, Loss: {total_loss / len(train_loader):.4f}")

Führen Sie das Skript mit folgendem Befehl aus:

python train_mnist.py

Auch wenn dieses Modell klein ist, werden Sie feststellen, dass das Training extrem schnell ist. Die H100 ist für MNIST eigentlich überdimensioniert, aber der Arbeitsablauf zeigt, wie Ihr Framework mit der GPU interagiert.

Beispiel 3: Multi-GPU-Training mit `torchrun`

Reale KI-Modelle erfordern mehrere GPUs. Die H100 wird oft in Clustern von acht oder mehr GPUs eingesetzt. Das `torchrun`-Dienstprogramm von PyTorch vereinfacht verteiltes Data-Parallel-Training. Angenommen, Sie haben einen Server mit acht H100-GPUs und möchten das Training auf allen GPUs starten. Schreiben Sie zunächst eine Trainingsfunktion, die `DistributedDataParallel` verwendet:

# 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()

Starten Sie dann den Job mit `torchrun`, wobei Sie angeben, dass ein Prozess pro GPU erzeugt werden soll:

torchrun --nproc_per_node=8 ddp_train.py

Das NCCL-Backend übernimmt die Hochgeschwindigkeitskommunikation zwischen den H100-GPUs, sei es über NVLink innerhalb desselben Knotens oder über InfiniBand über Knoten hinweg.

Beispiel 4: Ausführen eines vorgefertigten Containers

Für reproduzierbare Experimente ziehen Sie einen vorgefertigten Deep-Learning-Container, der PyTorch und CUDA enthält, und führen Sie Ihren Code darin aus. Der NGC-Katalog bietet offizielle Container:

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

Das Flag `--shm-size=8g` erhöht den gemeinsam genutzten Speicher, der DataLoader-Workern zur Verfügung steht, was eine häufige Ursache für Abstürze in Trainingscontainern ist. Sobald Sie sich im Container befinden, können Sie `python` ausführen und genau wie auf dem Host auf die GPU zugreifen. Dieser Ansatz ist besonders nützlich, um Umgebungen mit Mitarbeitern zu teilen.

Fazit

Die NVIDIA H100 GPU ist mehr als nur ein Stück Hardware; sie ist der Motor, der die aktuelle Welle der Innovation im Bereich der künstlichen Intelligenz antreibt. Der Fortschritt, der in den KI-Blogs von OpenAI, Google und Microsoft sichtbar ist – neue Modelle mit emergenten Denkfähigkeiten, Werkzeuge, die Code und Kunst erzeugen, und Systeme, die multimodale Eingaben verstehen – wäre ohne die Rechenkapazität von GPUs wie der H100 undenkbar. Gleichzeitig machen Plattformen wie Replicate, die darüber geschrieben haben, wie sie H100s in großem Maßstab bereitstellen, diese Technologie für Entwickler zugänglich, die keine eigenen Rechenzentren besitzen.

In diesem Artikel habe ich Sie von einem nackten Server zu einer vollständig konfigurierten Deep-Learning-Workstation geführt. Wir haben die GPU überprüft, den NVIDIA-Treiber installiert, CUDA und cuDNN eingerichtet, Docker konfiguriert und sowohl Single-GPU- als auch Multi-GPU-Workloads ausgeführt. Die Leistung der H100 ist erstaunlich, aber sie ist auch anspruchsvoll: Sie erfordert ein sorgfältiges Energiemanagement, einen modernen Software-Stack und einen disziplinierten Ansatz bei der Containerisierung, um effizient genutzt zu werden.

Während sich die KI-Forschung beschleunigt, wird die Kluft zwischen Modellen, die lediglich möglich sind, und Modellen, die praktisch sind, weiter schrumpfen. Mit einer H100 in Ihrem Werkzeugkasten sind Sie bestens positioniert, um an der Spitze dieser Entwicklung zu stehen. Die Befehle und Beispiele in diesem Artikel sind Ihr Ausgangspunkt. Jetzt gehen Sie los und bauen Sie etwas Bemerkenswertes.