> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/avance/multi-gpu-setup.md).

# Configuration multi-GPU

Exécutez de grands modèles d’IA sur plusieurs GPU sur Clore.ai

Exécutez de grands modèles d'IA sur plusieurs GPU sur CLORE.AI.

{% hint style="success" %}
Trouvez des serveurs multi-GPU sur [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Quand avez-vous besoin de plusieurs GPU ?

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| Taille du modèle | Option GPU unique | Option multi-GPU |
| ---------------- | ----------------- | ---------------- |
| ≤13B             | RTX 3090 (Q4)     | Non nécessaire   |
| 30B              | RTX 4090 (Q4)     | 2x RTX 3090      |
| 70B              | A100 40GB (Q4)    | 2x RTX 4090      |
| 70B FP16         | -                 | 2x A100 80GB     |
| 100B+            | -                 | 4x A100 80 Go    |
| 405B             | -                 | 8x A100 80GB     |

***

## Concepts multi-GPU

### Parallélisme tensoriel (TP)

Répartissez les couches du modèle sur plusieurs GPU. Idéal pour l'inférence.

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

**Avantages :** Latence plus faible, configuration simple **Inconvénients :** Nécessite une interconnexion à haut débit

### Parallélisme de pipeline (PP)

Traitez différents lots sur différents GPU.

```
GPU 0 : Lot 1 → GPU 1 : Lot 1
GPU 0 : Lot 2 → GPU 1 : Lot 2
```

**Avantages :** Débit plus élevé **Inconvénients :** Latence plus élevée, plus complexe

### Parallélisme des données (DP)

Même modèle sur plusieurs GPU, données différentes.

```
GPU 0 : Traiter le lot A
GPU 1 : Traiter le lot B
```

**Avantages :** Simple, mise à l'échelle linéaire **Inconvénients :** Chaque GPU doit disposer du modèle complet

***

## Configuration multi-GPU pour LLM

### vLLM (recommandé)

**2 GPU :**

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

```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 GPU (pour 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 utilise automatiquement plusieurs GPU lorsqu'ils sont disponibles :

```bash
# Vérifier les GPU disponibles
nvidia-smi

# Ollama détectera automatiquement et utilisera tous les GPU
ollama run llama3.1:70b
```

**Limiter à des GPU spécifiques :**

```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
# Spécifier les couches GPU par périphérique
./llama-server \
    -m llama-3.1-70b-q4.gguf \
    -ngl 999 \
    --split-mode layer \
    --tensor-split 0.5,0.5
```

***

## Génération d'images multi-GPU

### ComfyUI

ComfyUI peut décharger différents modèles sur différents GPU :

```python
# Dans le workflow ComfyUI
# Utilisez "Load Checkpoint" avec le paramètre device
# device : "cuda:0" pour le premier GPU
# device : "cuda:1" pour le deuxième GPU
```

**Exécuter le VAE sur un GPU séparé :**

```python
# Modèle principal sur GPU 0
# VAE sur GPU 1
# Réduit la pression sur la VRAM
```

### Interface web Stable Diffusion

**Activez le multi-GPU dans webui-user.sh :**

```bash
export COMMANDLINE_ARGS="--device-id 0"
# Ou pour des modèles spécifiques :
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
)

# Répartir sur plusieurs GPU
pipe.enable_model_cpu_offload()  # ou
pipe.to("cuda:0")  # Sélection explicite du GPU
```

***

## Entraînement multi-GPU

### PyTorch distribué

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

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

# Encapsuler le modèle
model = YourModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

# Boucle d'entraînement normale
```

**Lancer :**

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

**Lancer :**

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

### Accelerate (Hugging Face)

```python
from accelerate import Accelerator

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

**Configurer :**

```bash
accelerate config  # Configuration interactive
accelerate launch train.py
```

### Entraînement Kohya (LoRA)

```bash
# Entraînement LoRA multi-GPU
accelerate launch --num_processes=2 train_network.py \
    --pretrained_model_name_or_path="model.safetensors" \
    --train_data_dir="./images" \
    --output_dir="./output"
```

***

## Sélection des GPU

### Vérifier les GPU disponibles

```bash
# Lister tous les GPU
nvidia-smi

# Informations détaillées
nvidia-smi -L

# Utilisation de la mémoire
nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv
```

### Sélectionner des GPU spécifiques

**Variable d'environnement :**

```bash
# Utiliser uniquement les GPU 0 et 1
export CUDA_VISIBLE_DEVICES=0,1
python your_script.py

# Utiliser uniquement le GPU 2
export CUDA_VISIBLE_DEVICES=2
python your_script.py
```

**En Python :**

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

# Ou avec torch
import torch
device = torch.device("cuda:0")  # Premier GPU visible
device = torch.device("cuda:1")  # Deuxième GPU visible
```

***

## Optimisation des performances

### NVLink vs PCIe

| Connexion | Bande passante | Idéal pour               |
| --------- | -------------- | ------------------------ |
| NVLink    | 600 GB/s       | Parallélisme tensoriel   |
| PCIe 4.0  | 32 GB/s        | Parallélisme des données |
| PCIe 5.0  | 64 GB/s        | Charges mixtes           |

**Vérifier l'état de NVLink :**

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

### Configuration optimale

| GPU | Taille TP | Taille PP | Remarques                      |
| --- | --------- | --------- | ------------------------------ |
| 2   | 2         | 1         | Parallélisme tensoriel simple  |
| 4   | 4         | 1         | Nécessite NVLink               |
| 4   | 2         | 2         | Compatible PCIe                |
| 8   | 8         | 1         | Parallélisme tensoriel complet |
| 8   | 4         | 2         | Parallélisme mixte             |

### Équilibrage de la mémoire

**Répartition égale (par défaut) :**

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

**Répartition personnalisée (GPU inégaux) :**

```bash
# vLLM ne prend pas en charge les répartitions inégales, utilisez llama.cpp :
./llama-server --tensor-split 0.6,0.4
```

***

## Dépannage

### "Erreur NCCL"

```bash
# Activer le débogage NCCL
export NCCL_DEBUG=INFO

# Essayer différents algorithmes NCCL
export NCCL_ALGO=Ring
```

### "Mémoire insuffisante sur le GPU X"

```bash
# Vérifier la mémoire par GPU
nvidia-smi

# Réduire la taille du lot
--max-batch-size 1

# Activer le gradient checkpointing (entraînement)
--gradient-checkpointing
```

### "Performances multi-GPU lentes"

1. Vérifier la connectivité NVLink
2. Réduire la taille du parallélisme tensoriel
3. Utiliser plutôt le parallélisme de pipeline
4. Vérifier le goulot d'étranglement CPU

### "GPU non détectés"

```bash
# Vérifier CUDA
nvidia-smi

# Vérifier que PyTorch détecte les GPU
python -c "import torch; print(torch.cuda.device_count())"

# Réinstaller les pilotes CUDA si nécessaire
```

***

## Optimisation des coûts

### Quand le multi-GPU en vaut la peine

| Scénario                         | GPU unique                                             | Multi-GPU                                                | Gagnant              |
| -------------------------------- | ------------------------------------------------------ | -------------------------------------------------------- | -------------------- |
| Utilisation occasionnelle de 70B | A100 80GB ([bare metal](https://clore.ai/bare-metal))  | 2x RTX 4090 ($0.28–0.84/hr)                              | Multi                |
| 70B en production                | A100 40 Go ([bare metal](https://clore.ai/bare-metal)) | 2x A100 40GB ([bare metal](https://clore.ai/bare-metal)) | Simple (Q4)          |
| Entraînement de 7B               | RTX 4090 ($0.14–0.42/hr)                               | 2x RTX 4090 ($0.28–0.84/hr)                              | Cela dépend du temps |

### Configurations rentables

| Cas d’utilisation    | Configuration | \~Coût/h |
| -------------------- | ------------- | -------- |
| Inférence 70B        | 2x RTX 3090   | $0.12    |
| Inférence rapide 70B | 2x A100 40GB  | $0.34    |
| 70B FP16             | 2x A100 80GB  | $0.50    |
| Entraînement de 13B  | 2x RTX 4090   | $0.20    |

***

## Exemples de configurations

### Serveur de chat 70B

```bash
# Configuration 2x A100 40GB
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 requis
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \\
    --host 0.0.0.0
```

### Pipeline image + LLM

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

# GPU 1 : LLM pour les invites
CUDA_VISIBLE_DEVICES=1 python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct --port 8000
```

***

## Étapes suivantes

* [Guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Service LLM de production
* [Comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) - Choisissez vos GPU
* [Intégration API](/guides/guides_v2-fr/avance/api-integration.md) - Créer des applications
* [Calculateur de coût](/guides/guides_v2-fr/premiers-pas/cost-calculator.md) - Estimez les coûts


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/avance/multi-gpu-setup.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.