GPU (Graphics Processing Unit)

Eine Grafikprozessoreinheit (GPU) ist ein Prozessor mit Tausenden einfacher Kerne, die dieselbe Operation gleichzeitig auf vielen Datenelementen ausführen. GPUs wurden für die Darstellung von 3D-Grafiken entwickelt, wofür Millionen Pixel und Scheitelpunkte parallel berechnet werden müssen. Sie wurden zur wichtigsten Hardware für Deep Learning, weil das Training und die Inferenz neuronaler Netze hauptsächlich aus Matrixmultiplikationen bestehen, die sich auf dieselbe Weise parallelisieren lassen. Die 2007 veröffentlichte Plattform CUDA von NVIDIA machte deren GPUs für allgemeine Berechnungen programmierbar. 2012 gewann das AlexNet-Netzwerk, das fünf bis sechs Tage lang auf zwei NVIDIA-GTX-580-GPUs trainiert worden war, die ImageNet Challenge mit einer Top-5-Fehlerrate von 15,3 % gegenüber 26,2 % beim Zweitplatzierten. Heute laufen PyTorch, TensorFlow und JAX auf NVIDIA-GPUs über CUDA, auf AMD-GPUs über ROCm und auf Apple-Chips über Metal. Cluster mit Tausenden GPUs trainieren die größten Basismodelle.

So beschleunigen GPUs Deep Learning#

Eine CPU verwendet den größten Teil ihrer Chipfläche für Caches und Steuerlogik, damit einige wenige Kerne verzweigten Code schnell ausführen können. Eine GPU nutzt diese Fläche für Berechnungen: Eine NVIDIA-GPU ist in Streaming Multiprocessors unterteilt. Jeder führt Gruppen von 32 Threads aus, sogenannte Warps, die dieselbe Anweisung auf unterschiedlichen Daten ausführen. Während einige Warps auf den Speicher warten, rechnen andere. Dadurch bleibt der Chip ausgelastet, solange genügend parallel ausführbare Arbeit vorhanden ist. Seit der Volta-Generation im Jahr 2017 enthalten NVIDIA-GPUs außerdem Tensor Cores. Diese Einheiten multiplizieren kleine Matrizen in einem Schritt mit verringerter Genauigkeit, mittlerweile auch mit FP8 und seit Blackwell mit FP4. Eine NVIDIA A100 erreicht maximal 19,5 TFLOPS bei standardmäßiger FP32-Arithmetik und 312 TFLOPS in BF16 auf ihren Tensor Cores. Deshalb wird beim GPU-Training meist gemischte Genauigkeit verwendet. Dieser Code misst die Zeit derselben Matrixmultiplikation auf CPU und GPU:

import time

import torch

gpu = torch.accelerator.current_accelerator()  # cuda, mps, or xpu device on this machine
a = torch.randn(4096, 4096)
b = torch.randn(4096, 4096)

for device in (torch.device("cpu"), gpu):
    x, y = a.to(device), b.to(device)
    x @ y  # warm-up run
    torch.accelerator.synchronize()
    start = time.perf_counter()
    for _ in range(10):
        x @ y
    torch.accelerator.synchronize()  # GPU calls return immediately, so wait for them to finish
    seconds = (time.perf_counter() - start) / 10
    print(f"{device.type}: {seconds * 1000:.1f} ms per multiply, {2 * 4096**3 / seconds / 1e12:.1f} TFLOPS")

Auf einem Laptop mit Apple M5 Pro gibt der Code cpu: 80.0 ms per multiply, 1.7 TFLOPS und mps: 18.3 ms per multiply, 7.5 TFLOPS aus. Damit ist die integrierte GPU des Laptops bei FP32 etwa 4,4-mal schneller. Rechenzentrum-GPUs vergrößern den Unterschied durch mehr Kerne und durch Speicher mit hoher Bandbreite (HBM), der mehrere Terabyte pro Sekunde überträgt. So werden die Kerne ausreichend mit Gewichten und Aktivierungen versorgt. Der GPU-Speicher, oft VRAM genannt, bestimmt außerdem, wie groß ein Modell und die Batchgröße auf einem Gerät sein können. Techniken wie Gradient Checkpointing und verteiltes Training helfen, diese Grenze zu umgehen.

Modelle auf GPUs trainieren und bereitstellen#

Ein Trainingslauf hält die GPU nur dann ausgelastet, wenn die restliche Pipeline Schritt hält: CPU-Worker müssen Bilder schnell genug decodieren und erweitern, Batches müssen groß genug sein, um die Kerne auszulasten, und die Berechnungen sollten auf den Tensor Cores mit verringerter Genauigkeit laufen. Eine geringe GPU-Auslastung weist meist auf eines dieser Probleme hin:

Ultralytics YOLO trainiert standardmäßig auf der ersten CUDA-GPU, sofern eine verfügbar ist, und akzeptiert device=[0, 1] für das Training mit mehreren GPUs. Mit batch=-1 wird AutoBatch ausgeführt, das den freien GPU-Speicher misst und eine Batchgröße auswählt, die etwa 60 % davon nutzt. Teams ohne lokale Hardware können für jeden Trainingslauf auf Ultralytics Platform eine Cloud-GPU auswählen. Bei der Inferenz verarbeitet ein auf TensorRT exportiertes YOLO26n-Modell ein Bild mit 640 Pixeln in 1,7 ms auf einer NVIDIA-T4-GPU, gegenüber 38,9 ms mit ONNX auf einer CPU. Dieser Code trainiert YOLO26 mit AutoBatch auf der ersten GPU:

from ultralytics import YOLO

# Das kleinste YOLO26-Modell zur Objekterkennung laden
model = YOLO("yolo26n.pt")

# Auf GPU 0 trainieren und AutoBatch die Batchgröße anhand des GPU-Speichers bestimmen lassen
results = model.train(data="coco8.yaml", epochs=3, imgsz=640, device=0, batch=-1)

GPU im Vergleich zu CPU, TPU und NPU#

• CPU: Einige leistungsstarke Kerne für allgemeine Berechnungen und verzweigten Code. CPUs übernehmen in den meisten Trainingspipelines das Laden und die Vorverarbeitung von Daten. Sie führen auch Inferenz aus, wenn kein Beschleuniger verfügbar ist.
• GPU: Tausende programmierbare Kerne sowie Tensor Cores. GPUs können fast jedes Modell und Framework ausführen, sind von mehreren Herstellern erhältlich und bei allen großen Cloud-Anbietern verfügbar.
• TPU: Googles anwendungsspezifischer Chip mit großen Matrixmultiplikationseinheiten. TPUs verzichten auf die Flexibilität einer GPU und sind dafür bei großen dichten Matrixoperationen effizienter. Sie sind über Google Cloud verfügbar.
• NPU: Ein energiesparender Beschleuniger für neuronale Netze in Smartphones, Laptops und Edge-Geräten, der für die Inferenz statt für das Training verwendet wird.

Anwendungen in der Praxis#

• Große Modelle trainieren: Sprach- und Bildverarbeitungsmodelle mit Milliarden Parametern werden auf Clustern aus Tausenden Rechenzentrum-GPUs trainiert, die über schnelle Verbindungen wie NVLink und InfiniBand miteinander verbunden sind.
• Videoanalyse in Echtzeit: Eine einzelne GPU kann gleichzeitig Objekterkennung und -verfolgung auf vielen Kamerastreams ausführen, etwa für die Verkehrsüberwachung, die Analyse des Einzelhandels oder die Inspektion von Fabriken.
• Robotik und autonome Fahrzeuge: Eingebettete GPU-Module wie NVIDIA Jetson führen Wahrnehmungsmodelle direkt an Bord aus. Würden die Kameradaten an einen Server gesendet, entstünde eine zu große Verzögerung.
• Medizinische Bildgebung: GPUs verarbeiten große 3D-CT- und MRT-Aufnahmen und segmentieren Organe und Tumore in Sekunden statt Minuten.