Multi-GPU-Einrichtung

Führe große KI-Modelle über mehrere GPUs auf Clore.ai aus

Führe große KI-Modelle über mehrere GPUs auf CLORE.AI aus.

Finde Multi-GPU-Server bei CLORE.AI-Marktplatz.

Wann benötigst du Multi-GPU?

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Modellgröße	Option mit einer GPU	Option mit mehreren GPUs
≤13B	RTX 3090 (Q4)	Nicht erforderlich
30B	RTX 4090 (Q4)	2x RTX 3090
70B	A100 40 GB (Q4)	2x RTX 4090
70B FP16	-	2x A100 80 GB
100B+	-	4x A100 80 GB
405B	-	8x A100 80 GB

---

Multi-GPU-Konzepte

Tensor-Parallelismus (TP)

Modellschichten über GPUs aufteilen. Am besten für die Inferenz.

GPU 0: Schichten 1-20
GPU 1: Schichten 21-40

Vorteile: Geringere Latenz, einfache Einrichtung Nachteile: Erfordert eine Hochgeschwindigkeitsverbindung

Pipeline-Parallelismus (PP)

Unterschiedliche Batches auf verschiedenen GPUs verarbeiten.

GPU 0: Batch 1 → GPU 1: Batch 1
GPU 0: Batch 2 → GPU 1: Batch 2

Vorteile: Höherer Durchsatz Nachteile: Höhere Latenz, komplexer

Datenparallelismus (DP)

Dasselbe Modell auf mehreren GPUs, unterschiedliche Daten.

GPU 0: Batch A verarbeiten
GPU 1: Batch B verarbeiten

Vorteile: Einfaches, lineares Skalieren Nachteile: Jede GPU benötigt das vollständige Modell

---

LLM-Multi-GPU-Setup

vLLM (empfohlen)

2 GPUs:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2 \
    --host 0.0.0.0

4 GPUs:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4 \
    --host 0.0.0.0

8 GPUs (für 405B):

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-405B-Instruct \
    --tensor-parallel-size 8 \
    --host 0.0.0.0

Ollama mit mehreren GPUs

Ollama verwendet automatisch mehrere GPUs, wenn verfügbar:

# Verfügbare GPUs prüfen
nvidia-smi

# Ollama erkennt automatisch alle GPUs und nutzt sie
ollama run llama3.1:70b

Auf bestimmte GPUs beschränken:

CUDA_VISIBLE_DEVICES=0,1 ollama run llama3.1:70b

Text Generation Inference (TGI)

docker run --gpus all -p 8080:80 \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-70B-Instruct \
    --num-shard 2

llama.cpp

# GPU-Layer pro Gerät angeben
./llama-server \
    -m llama-3.1-70b-q4.gguf \
    -ngl 999 \
    --split-mode layer \
    --tensor-split 0.5,0.5

---

Multi-GPU für Bildgenerierung

ComfyUI

ComfyUI kann verschiedene Modelle auf verschiedene GPUs auslagern:

# Im ComfyUI-Workflow
# Verwende "Load Checkpoint" mit device-Parameter
# device: "cuda:0" für die erste GPU
# device: "cuda:1" für die zweite GPU

VAE auf separater GPU ausführen:

# Hauptmodell auf GPU 0
# VAE auf GPU 1
# Reduziert den VRAM-Druck

Stable Diffusion WebUI

Multi-GPU in webui-user.sh aktivieren:

export COMMANDLINE_ARGS="--device-id 0"
# Oder für bestimmte Modelle:
export COMMANDLINE_ARGS="--lowvram --device-id 0,1"

FLUX mit mehreren GPUs

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)

# Über GPUs verteilen
pipe.enable_model_cpu_offload()  # oder
pipe.to("cuda:0")  # Explizite GPU-Auswahl

---

Multi-GPU-Training

Verteiltes PyTorch

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

# Initialisieren
dist.init_process_group("nccl")
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)

# Modell einpacken
model = YourModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

# Trainingsschleife wie gewohnt

Starten:

torchrun --nproc_per_node=2 train.py

DeepSpeed

import deepspeed

model, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config={
        "train_batch_size": 32,
        "fp16": {"enabled": True},
        "zero_optimization": {"stage": 2}
    }
)

Starten:

deepspeed --num_gpus=2 train.py

Accelerate (HuggingFace)

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, dataloader = accelerator.prepare(
    model, optimizer, dataloader
)

Konfigurieren:

accelerate config  # Interaktive Einrichtung
accelerate launch train.py

Kohya-Training (LoRA)

# Multi-GPU-LoRA-Training
accelerate launch --num_processes=2 train_network.py \
    --pretrained_model_name_or_path="model.safetensors" \
    --train_data_dir="./images" \
    --output_dir="./output"

---

GPU-Auswahl

Verfügbare GPUs prüfen

# Alle GPUs auflisten
nvidia-smi

# Detaillierte Informationen
nvidia-smi -L

# Speichernutzung
nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv

Bestimmte GPUs auswählen

Umgebungsvariable:

# Verwende nur GPU 0 und 1
export CUDA_VISIBLE_DEVICES=0,1
python your_script.py

# Verwende nur GPU 2
export CUDA_VISIBLE_DEVICES=2
python your_script.py

In Python:

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"

# Oder mit torch
import torch
device = torch.device("cuda:0")  # Erste sichtbare GPU
device = torch.device("cuda:1")  # Zweite sichtbare GPU

---

Leistungsoptimierung

NVLink vs PCIe

Verbindung	Bandbreite	Am besten geeignet für
NVLink	600 GB/s	Tensor-Parallelismus
PCIe 4.0	32 GB/s	Datenparallelismus
PCIe 5.0	64 GB/s	Gemischte Workloads

NVLink-Status prüfen:

nvidia-smi nvlink --status

Optimale Konfiguration

GPUs	TP-Größe	PP-Größe	Hinweise
2	2	1	Einfacher Tensor-Parallelismus
4	4	1	Erfordert NVLink
4	2	2	PCIe-freundlich
8	8	1	Vollständiger Tensor-Parallelismus
8	4	2	Gemischter Parallelismus

Speicherausgleich

Gleichmäßige Aufteilung (Standard):

--tensor-parallel-size 2

Benutzerdefinierte Aufteilung (ungleiche GPUs):

# vLLM unterstützt keine ungleiche Aufteilung, verwende llama.cpp:
./llama-server --tensor-split 0.6,0.4

---

Fehlerbehebung

"NCCL-Fehler"

# NCCL-Debug setzen
export NCCL_DEBUG=INFO

# Verschiedene NCCL-Algorithmen ausprobieren
export NCCL_ALGO=Ring

"Kein Speicher mehr auf GPU X"

# Speicher pro GPU prüfen
nvidia-smi

# Batch-Größe reduzieren
--max-batch-size 1

# Gradient Checkpointing aktivieren (Training)
--gradient-checkpointing

"Langsame Multi-GPU-Leistung"

1. NVLink-Konnektivität prüfen

2. Tensor-Parallel-Größe reduzieren

3. Verwende stattdessen Pipeline-Parallelismus

4. CPU-Engpass prüfen

"GPUs nicht erkannt"

# CUDA überprüfen
nvidia-smi

# Prüfen, ob PyTorch GPUs sieht
python -c "import torch; print(torch.cuda.device_count())"

# Falls nötig, CUDA-Treiber neu installieren

---

Kostenoptimierung

Wann sich Multi-GPU lohnt

Szenario	Einzelne GPU	Multi-GPU	Gewinner
70B gelegentliche Nutzung	A100 80 GB (Bare Metal)	2x RTX 4090 ($0.28–0.84/Std.)	Mehrere GPUs
70B-Produktion	A100 40 GB (Bare Metal)	2x A100 40 GB (Bare Metal)	Einzeln (Q4)
Training 7B	RTX 4090 ($0.14–0.42/Std.)	2x RTX 4090 ($0.28–0.84/Std.)	Hängt von der Zeit ab

Kosteneffiziente Konfigurationen

Anwendungsfall	Konfiguration	~Kosten/Std.
70B-Inferenz	2x RTX 3090	$0.12
70B-Schnellinferenz	2x A100 40 GB	$0.34
70B FP16	2x A100 80 GB	$0.50
Training 13B	2x RTX 4090	$0.20

---

Beispielkonfigurationen

70B-Chat-Server

# 2x A100 40 GB-Setup
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 8192 \
    --host 0.0.0.0 \
    --port 8000

DeepSeek-V3 (671B)

# 8x A100 80 GB erforderlich
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0

Bild + LLM-Pipeline

# GPU 0: Stable Diffusion
CUDA_VISIBLE_DEVICES=0 python comfyui/main.py --port 8188 &

# GPU 1: LLM für Prompts
CUDA_VISIBLE_DEVICES=1 python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct --port 8000

---

Nächste Schritte

• vLLM-Anleitung - Produktions-LLM-Serving

• GPU-Vergleich - Wähle deine GPUs

• API-Integration - Anwendungen erstellen

• Kostenrechner - Kosten schätzen