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.

Trouvez des serveurs multi-GPU sur la place de marché CLORE.AI.

Quand avez-vous besoin de plusieurs GPU ?

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 sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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 :

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 :

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) :

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 :

# 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 :

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

# 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 :

# 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é :

# 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 :

export COMMANDLINE_ARGS="--device-id 0"
# Ou pour des modèles spécifiques :
export COMMANDLINE_ARGS="--lowvram --device-id 0,1"

FLUX multi-GPU

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é

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 :

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

Lancer :

deepspeed --num_gpus=2 train.py

Accelerate (Hugging Face)

from accelerate import Accelerator

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

Configurer :

accelerate config  # Configuration interactive
accelerate launch train.py

Entraînement Kohya (LoRA)

# 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

# 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 :

# 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 :

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 :

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) :

--tensor-parallel-size 2

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

# 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"

# 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"

# 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"

# 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)	2x RTX 4090 ($0.28–0.84/hr)	Multi
70B en production	A100 40 Go (bare metal)	2x A100 40GB (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

# 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)

# 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

# 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 - Service LLM de production

• Comparaison des GPU - Choisissez vos GPU

• Intégration API - Créer des applications

• Calculateur de coût - Estimez les coûts