# Multi-GPU-Setup

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

{% hint style="success" %}
Finden Sie Multi-GPU-Server unter [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Wann benötigen Sie Multi-GPU?

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

***

## Multi-GPU-Konzepte

### Tensor-Parallellität (TP)

Teilen Sie Modellschichten über GPUs auf. Am besten für Inferenz.

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

**Vorteile:** Geringere Latenz, einfache Einrichtung **Nachteile:** Erfordert Hochgeschwindigkeits-Interconnect

### Pipeline-Parallellität (PP)

Verarbeiten Sie verschiedene Batches auf verschiedenen GPUs.

```
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

### Daten-Parallellität (DP)

Dasselbe Modell auf mehreren GPUs, unterschiedliche Daten.

```
GPU 0: Verarbeitet Batch A
GPU 1: Verarbeitet Batch B
```

**Vorteile:** Einfach, lineare Skalierung **Nachteile:** Jede GPU benötigt das vollständige Modell

***

## LLM Multi-GPU-Setup

### vLLM (Empfohlen)

**2 GPUs:**

```bash
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:**

```bash
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):**

```bash
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 Multi-GPU

Ollama verwendet automatisch mehrere GPUs, wenn verfügbar:

```bash
# Verfügbare GPUs prüfen
nvidia-smi

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

**Auf bestimmte GPUs beschränken:**

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

### Text Generation Inference (TGI)

```bash
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

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

***

## Bildgenerierung Multi-GPU

### ComfyUI

ComfyUI kann verschiedene Modelle auf verschiedene GPUs auslagern:

```python
# Im ComfyUI-Workflow
# Verwenden Sie "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:**

```python
# Hauptmodell auf GPU 0
# VAE auf GPU 1
# Verringert VRAM-Belastung
```

### Stable Diffusion WebUI

**Multi-GPU in webui-user.sh aktivieren:**

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

### FLUX Multi-GPU

```python
from diffusers import FluxPipeline
import torch

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

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

***

## Training Multi-GPU

### PyTorch Distributed

```python
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 einkapseln
model = YourModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

# Trainingsschleife wie gewohnt
```

**Start:**

```bash
torchrun --nproc_per_node=2 train.py
```

### DeepSpeed

```python
import deepspeed

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

**Start:**

```bash
deepspeed --num_gpus=2 train.py
```

### Accelerate (HuggingFace)

```python
from accelerate import Accelerator

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

**Konfigurieren:**

```bash
accelerate config  # Interaktive Einrichtung
accelerate launch train.py
```

### Kohya Training (LoRA)

```bash
# 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

```bash
# Alle GPUs auflisten
nvidia-smi

# Detaillierte Infos
nvidia-smi -L

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

### Bestimmte GPUs auswählen

**Umgebungsvariable:**

```bash
# Nur GPU 0 und 1 verwenden
export CUDA_VISIBLE_DEVICES=0,1
python your_script.py

# Nur GPU 2 verwenden
export CUDA_VISIBLE_DEVICES=2
python your_script.py
```

**In Python:**

```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-Parallele Verarbeitung |
| PCIe 4.0   | 32 GB/s    | Datenparallellität            |
| PCIe 5.0   | 64 GB/s    | Gemischte Workloads           |

**NVLink-Status prüfen:**

```bash
nvidia-smi nvlink --status
```

### Optimale Konfiguration

| GPUs | TP-Größe | PP-Größe | Hinweise                  |
| ---- | -------- | -------- | ------------------------- |
| 2    | 2        | 1        | Einfache Tensor-Parallele |
| 4    | 4        | 1        | Erfordert NVLink          |
| 4    | 2        | 2        | PCIe-freundlich           |
| 8    | 8        | 1        | Volle Tensor-Parallele    |
| 8    | 4        | 2        | Gemischte Parallellität   |

### Speicherausgleich

**Gleichmäßige Aufteilung (Standard):**

```bash
--tensor-parallel-size 2
```

**Benutzerdefinierte Aufteilung (ungleiche GPUs):**

```bash
# vLLM unterstützt keine Ungleichheit, verwenden Sie llama.cpp:
./llama-server --tensor-split 0.6,0.4
```

***

## Fehlerbehebung

### "NCCL-Fehler"

```bash
# NCCL-Debug setzen
export NCCL_DEBUG=INFO

# Versuchen Sie verschiedene NCCL-Algorithmen
export NCCL_ALGO=Ring
```

### "Nicht genügend Speicher auf GPU X"

```bash
# 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-Parallellgröße reduzieren
3. Stattdessen Pipeline-Parallellität verwenden
4. CPU-Engpass prüfen

### "GPUs nicht erkannt"

```bash
# CUDA überprüfen
nvidia-smi

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

# Gegebenenfalls CUDA-Treiber neu installieren
```

***

## Kostenoptimierung

### Wann sich Multi-GPU lohnt

| Szenario                  | Einzel-GPU              | Multi-GPU                  | Gewinner              |
| ------------------------- | ----------------------- | -------------------------- | --------------------- |
| 70B gelegentliche Nutzung | A100 80GB (0,25 $/Std.) | 2x RTX 4090 (0,20 $/Std.)  | Multi                 |
| 70B Produktion            | A100 40GB (0,17 $/Std.) | 2x A100 40GB (0,34 $/Std.) | Einzeln (Q4)          |
| Training 7B               | RTX 4090 (0,10 $/Std.)  | 2x RTX 4090 (0,20 $/Std.)  | Hängt von der Zeit ab |

### Kosten-effektive Konfigurationen

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

***

## Beispielkonfigurationen

### 70B Chat-Server

```bash
# 2x A100 40GB-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)

```bash
# 8x A100 80GB 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

```bash
# 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-Leitfaden](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) - LLM-Serving in Produktion
* [GPU-Vergleich](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) - Wählen Sie Ihre GPUs
* [API-Integration](https://docs.clore.ai/guides/guides_v2-de/fortgeschritten/api-integration) - Anwendungen erstellen
* [Kostenrechner](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/cost-calculator) - Kosten schätzen