NVIDIA H100 GPUs sind da: Sie treiben die nächste KI-Revolution an.

NVIDIA H100 GPUs sind da: Sie treiben die nächste KI-Revolution an

Die Landschaft der künstlichen Intelligenz wandelt sich unter unseren Füßen. Von großen Sprachmodellen, die wie Menschen konversieren, bis hin zu Diffusionsmodellen, die fotorealistische Bilder erzeugen – die Anforderungen an die Rechenhardware waren noch nie so hoch. Der NVIDIA H100 GPU betritt die Bühne – der neueste Kraftprotz, der speziell dafür entwickelt wurde, KI-Training und Inferenz in beispiellosem Maßstab zu beschleunigen. Basierend auf der Hopper-Architektur liefert der H100 bis zu neunmal schnellere Trainingsdurchsätze als sein Vorgänger A100 und führt transformative Technologien wie den Transformer Engine, die vierte Generation von NVLink und vertrauliches Rechnen ein.

Große Organisationen wie OpenAI, Google AI und Microsoft AI integrieren bereits H100-Cluster in ihre Workflows, und der Replicate-Blog hat berichtet, wie Early Adopter hochmoderne Modelle auf dieser Hardware ausführen. In diesem praktischen Artikel gehen wir auf alles ein, was Sie wissen müssen, um mit NVIDIA H100 GPUs zu starten: Hardwareanforderungen, eine Schritt-für-Schritt-Installationsanleitung und praxisnahe Beispiele, die Sie selbst ausführen können.

---

Anforderungen

Bevor Sie die Leistung einer H100 GPU nutzen können, brauchen Sie die richtige Umgebung. Im Folgenden finden Sie die Mindest- und die empfohlenen Anforderungen.

Hardwareanforderungen

| Komponente | Minimum | Empfohlen | |------------|---------|-----------| | **GPU** | 1 × NVIDIA H100 (80 GB PCIe oder SXM) | 4–8 × H100 in einer NVLink-Domain | | **CPU** | AMD EPYC oder Intel Xeon (48+ Kerne) | AMD EPYC 9654 oder Intel Xeon Platinum 8490H | | **RAM** | 256 GB DDR5 | 512 GB DDR5 ECC | | **Speicher** | 1 TB NVMe SSD | 4 TB NVMe RAID 0 | | **Netzwerk** | 100 GbE | NVIDIA ConnectX‑7 InfiniBand (400 Gb/s) | | **Netzteil** | 1600 W (pro GPU) | Redundantes 3 kW+ Netzteil für Multi‑GPU |

**Hinweis:** Das H100 SXM-Modul erfordert einen NVIDIA-zertifizierten Server wie den DGX H100 oder das HGX H100-Baseboard. Für PCIe-Versionen stellen Sie sicher, dass Ihr Mainboard PCIe 5.0 x16 unterstützt und eine ausreichende Kühlung vorhanden ist.

Softwareanforderungen

• **Betriebssystem:** Ubuntu 22.04 LTS (oder neuer)
• **GPU-Treiber:** NVIDIA-Treiber 525.85.12 oder neuer
• **CUDA Toolkit:** Version 12.2 (in der H100-Unterstützung enthalten)
• **Container-Laufzeit:** Docker 24.0+ mit `nvidia-docker2`
• **Python:** 3.10 oder 3.11 (für Deep-Learning-Frameworks)
• **Deep-Learning-Frameworks:** PyTorch 2.2+, TensorFlow 2.15+

Sie benötigen außerdem Root- oder sudo-Zugriff, um Treiber zu installieren und das System zu konfigurieren.

---

Schritt-für-Schritt-Installation

Wir installieren nun den NVIDIA-Treiber, das CUDA Toolkit und die Container-Laufzeit auf einem frischen Ubuntu 22.04-System mit installierter H100 GPU.

1. NVIDIA-Treiber für H100 installieren

Aktualisieren Sie zuerst Ihr Paket-Repository und installieren Sie den proprietären NVIDIA-Treiber. Der H100 benötigt Version 525.85.12 oder neuer.

sudo apt update
sudo apt upgrade -y

Fügen Sie das NVIDIA-Paket-Repository für Ubuntu hinzu:

sudo add-apt-repository ppa:graphics-drivers/ppa -y
sudo apt update

Installieren Sie den empfohlenen Treiber:

sudo apt install nvidia-driver-545 -y

Starten Sie nach der Installation neu:

sudo reboot

Überprüfen Sie, ob der Treiber korrekt geladen wurde:

nvidia-smi

Sie sollten eine Ausgabe ähnlich dieser sehen:

+-----------------------------------------------------------------------+
| NVIDIA-SMI 545.23.08   Driver Version: 545.23.08   CUDA Version: 12.3 |
+-----------------------------------------------------------------------+
| GPU  Name          Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf    Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
+=======================================================================+
|   0  NVIDIA H100            Off  | 00000000:17:00.0 Off |                    0 |
|  0%   42C    P0    95W / 700W  |      0MiB / 81559MiB  |      0%      Default |
+-----------------------------------------------------------------------+

2. CUDA Toolkit 12.2 installieren

Der H100 nutzt CUDA-12.x-Funktionen wie den Transformer Engine. Laden Sie CUDA 12.2 vom offiziellen NVIDIA-Repo herunter und installieren Sie es.

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install cuda-toolkit-12-2 -y

Fügen Sie CUDA zu Ihrem PATH hinzu:

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

Überprüfen Sie die Installation:

nvcc --version

Ausgabe:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2023 NVIDIA Corporation
Built on Tue_Jul_11_04:45:20_PDT_2023
Cuda compilation tools, release 12.2, V12.2.140
Build cuda_12.2.r12.2/compiler.33567101_0

3. Docker und NVIDIA Container Toolkit installieren

Um Modelle in isolierten Umgebungen ohne Abhängigkeitskonflikte auszuführen, verwenden wir Docker mit GPU-Durchreichung.

# Docker CE installieren
sudo apt install docker.io -y
sudo systemctl enable --now docker

# Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER

# Aus- und wieder einloggen oder ausführen: newgrp docker

Jetzt das NVIDIA Container Toolkit installieren:

# NVIDIA-Repository hinzufügen
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

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

# Docker neu starten
sudo systemctl restart docker

Testen, ob Docker die H100 sieht:

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

Bei Erfolg wird die H100 GPU aufgelistet.

4. PyTorch mit CUDA-12-Unterstützung installieren

Für die tägliche Deep-Learning-Arbeit installieren Sie PyTorch mit CUDA 12.2 von der offiziellen Website.

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

Überprüfen Sie, ob PyTorch die H100 erkennt:

import torch
print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

Ausgabe:

True
NVIDIA H100 80GB HBM3

---

Anwendungsbeispiele

Nachdem die H100 GPU voll funktionsfähig ist, führen wir drei praktische Beispiele aus, die ihre Fähigkeiten demonstrieren.

Beispiel 1: Training eines Transformer-Modells mit FP8 (Transformer Engine)

Der H100-Transformer Engine wählt automatisch zwischen FP8 und FP16, um den Durchsatz zu maximieren und gleichzeitig die Genauigkeit zu erhalten. Das folgende Skript trainiert ein einfaches GPT-ähnliches Modell mit Zufallsdaten.

Erstellen Sie eine Datei `train_fp8.py`:

import torch
import torch.nn as nn
from transformers import GPT2Config, GPT2Model

# FP8 auf H100 aktivieren
torch.backends.cuda.matmul.allow_fp8_accumulation = True

config = GPT2Config(
    vocab_size=50257,
    n_positions=1024,
    n_ctx=1024,
    n_embd=768,
    n_layer=12,
    n_head=12,
)
model = GPT2Model(config).cuda()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

# Synthetische Daten (batch=32, seq_len=1024)
input_ids = torch.randint(0, 50257, (32, 1024)).cuda()
labels = torch.randint(0, 50257, (32, 1024)).cuda()

for step in range(50):
    optimizer.zero_grad()
    outputs = model(input_ids, labels=labels)
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    if step % 10 == 0:
        print(f"Step {step}, Loss: {loss.item():.4f}")

Ausführen mit:

python train_fp8.py

Beobachten Sie, dass die H100 automatisch FP8-Matrixmultiplikationen verwendet, was zu schnellerem Training im Vergleich zu FP16 führt.

Beispiel 2: Großskalige Inferenz mit Llama‑2 (70B) mittels Hugging Face

Die 80 GB Speicher der H100 ermöglichen das Laden eines Modells mit 70 Milliarden Parametern in voller Genauigkeit ohne Auslagerung. Besorgen Sie sich zunächst Zugang zu Llama‑2 von Meta (über Hugging Face).

Erstellen Sie `infer_llama2.py`:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "meta-llama/Llama-2-70b-chat-hf"  # Erfordert Zugriffstoken

tokenizer = AutoTokenizer.from_pretrained(model_name, use_auth_token=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.bfloat16,
    use_auth_token=True,
)

prompt = "Explain the significance of the H100 GPU in AI."
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

output = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(output[0]))

Ausführen mit:

python infer_llama2.py

Auf einer H100 ist diese Inferenz in Sekunden mit hohem Durchsatz abgeschlossen.

Beispiel 3: Multi‑GPU Data‑Parallel Training mit NVLink

Bei Verwendung mehrerer H100s ermöglicht NVLink eine schnelle GPU‑zu‑GPU‑Kommunikation. Das folgende Beispiel verwendet PyTorchs `DistributedDataParallel` für Datenparalleltraining.

Erstellen Sie zunächst ein Launcher-Skript `train_ddp.py`:

import torch
import torch.nn as nn
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
import os

def setup(rank, world_size):
    dist.init_process_group("nccl", rank=rank, world_size=world_size)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Linear(4096, 4096),
        )
    def forward(self, x):
        return self.net(x)

def train(rank, world_size):
    setup(rank, world_size)
    torch.cuda.set_device(rank)
    model = SimpleModel().cuda(rank)
    ddp_model = DDP(model, device_ids=[rank])

    optimizer = torch.optim.SGD(ddp_model.parameters(), lr=0.001)
    data = torch.randn(64, 4096).cuda(rank)

    for epoch in range(10):
        optimizer.zero_grad()
        output = ddp_model(data)
        loss = output.mean()
        loss.backward()
        optimizer.step()
        if rank == 0:
            print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
    dist.destroy_process_group()

if __name__ == "__main__":
    world_size = torch.cuda.device_count()
    # In der Praxis torchrun verwenden
    for rank in range(world_size):
        train(rank, world_size)

Starten mit:

torchrun --nproc_per_node=8 train_ddp.py

Mit 8 über NVLink verbundenen H100 GPUs skaliert die Trainingsgeschwindigkeit nahezu linear.

---

Fazit

Die NVIDIA H100 GPU ist nicht nur ein inkrementelles Upgrade – sie ist ein fundamentaler Wegbereiter für die nächste Welle von KI-Durchbrüchen. Mit dem Transformer Engine, der FP8-Beschleunigung und dem massiven 80‑GB‑HBM3‑Speicher können Forscher und Ingenieure größere Modelle schneller trainieren und Inferenz auf bisher unmöglichen Workloads durchführen.

Wie die obigen praktischen Beispiele zeigen, erfordert der Einstieg einen richtig konfigurierten Server, die neuesten Treiber und ein modernes Deep-Learning-Framework. Ob Sie ein 70B-Sprachmodell feinabstimmen, ein Diffusionsmodell mit Milliarden von Bildern trainieren oder mit NVLink auf Multi‑GPU‑Cluster skalieren – die H100 liefert die rohe Rechenleistung und die architektonischen Innovationen, um es möglich zu machen.

Die Artikel von Replicate, OpenAI News, Google AI Blog und Microsoft AI Blog weisen alle in die gleiche Richtung: Die Zukunft der KI ruht auf Hardware, die mit dem Wachstum von Daten und Modellkomplexität Schritt halten kann. Die NVIDIA H100 ist da und bereit, die nächste KI-Revolution anzutreiben.