> 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/entrainement/deepspeed-training.md).

# Entraînement DeepSpeed

Entraînez efficacement de grands modèles avec DeepSpeed sur les GPU Clore.ai

Entraînez efficacement de grands modèles avec Microsoft DeepSpeed.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Louer sur CLORE.AI

{% 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 %}

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<proxy-address>`

## Qu'est-ce que DeepSpeed ?

DeepSpeed permet :

* Entraîner des modèles qui ne tiennent pas en mémoire GPU
* Entraînement multi-GPU et multi-nœud
* Optimisation ZeRO (efficacité mémoire)
* Entraînement en précision mixte

## Étapes ZeRO

| Étape         | Économie de mémoire                | Vitesse                 |
| ------------- | ---------------------------------- | ----------------------- |
| ZeRO-1        | États de l'optimiseur partitionnés | Rapide                  |
| ZeRO-2        | + Gradients partitionnés           | Équilibré               |
| ZeRO-3        | + Paramètres partitionnés          | Économies maximales     |
| ZeRO-Infinity | Déchargement CPU/NVMe              | Modèles les plus grands |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports :**

```
22/tcp
```

**Commande :**

```bash
pip install deepspeed transformers datasets accelerate
```

## Installation

```bash
pip install deepspeed

# Vérifier l'installation
ds_report
```

## Entraînement de base

### Configuration DeepSpeed

**ds\_config.json:**

```json
{
    "train_batch_size": 32,
    "gradient_accumulation_steps": 4,
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 1e-4,
            "betas": [0.9, 0.999],
            "eps": 1e-8,
            "weight_decay": 0.01
        }
    },
    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": 0,
            "warmup_max_lr": 1e-4,
            "warmup_num_steps": 100
        }
    },
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "initial_scale_power": 16
    },
    "zero_optimization": {
        "stage": 2,
        "contiguous_gradients": true,
        "overlap_comm": true
    }
}
```

### Script d'entraînement

```python
import torch
import deepspeed
from transformers import AutoModelForCausalLM, AutoTokenizer

# Initialisation
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")

# Initialisation de DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    model_parameters=model.parameters(),
    config="ds_config.json"
)

# Boucle d'entraînement
for epoch in range(num_epochs):
    for batch in dataloader:
        inputs = tokenizer(batch["text"], return_tensors="pt", padding=True, truncation=True)
        inputs = {k: v.to(model_engine.device) for k, v in inputs.items()}

        outputs = model_engine(**inputs, labels=inputs["input_ids"])
        loss = outputs.loss

        model_engine.backward(loss)
        model_engine.step()
```

## Configuration de l'étape 2 de ZeRO

```json
{
    "train_batch_size": "auto",
    "gradient_accumulation_steps": "auto",
    "gradient_clipping": 1.0,
    "fp16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 2,
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "reduce_scatter": true,
        "reduce_bucket_size": 2e8,
        "overlap_comm": true
    }
}
```

## Configuration de l'étape 3 de ZeRO

Pour les grands modèles :

```json
{
    "train_batch_size": "auto",
    "gradient_accumulation_steps": "auto",
    "fp16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "sub_group_size": 1e9,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": true
    }
}
```

## Avec Hugging Face Transformers

### Intégration du Trainer

```python
from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    num_train_epochs=3,
    fp16=True,
    deepspeed="ds_config.json",
    logging_steps=10,
    save_steps=500,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    tokenizer=tokenizer,
)

trainer.train()
```

## Entraînement multi-GPU

### Commande de lancement

```bash

# Nœud unique, 4 GPU
deepspeed --num_gpus=4 train.py --deepspeed ds_config.json

# GPU spécifiques
deepspeed --include="localhost:0,1,2,3" train.py --deepspeed ds_config.json
```

### Avec torchrun

```bash
torchrun --nproc_per_node=4 train.py --deepspeed ds_config.json
```

## Entraînement multi-nœud

### Fichier d'hôtes

**fichier d'hôtes :**

```
node1 slots=4
node2 slots=4
```

### Lancement

```bash
deepspeed --hostfile=hostfile train.py --deepspeed ds_config.json
```

### Configuration SSH

```bash

# Assurez-vous d'avoir un SSH sans mot de passe entre les nœuds
ssh-keygen -t rsa
ssh-copy-id user@node2
```

## Configurations économes en mémoire

### Modèle 7B sur GPU 24 Go

```json
{
    "bf16": {"enabled": true},
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"}
    },
    "gradient_checkpointing": true,
    "train_micro_batch_size_per_gpu": 1,
    "gradient_accumulation_steps": 16
}
```

### Modèle 13B sur GPU 24 Go

```json
{
    "bf16": {"enabled": true},
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"},
        "stage3_param_persistence_threshold": 0
    },
    "gradient_checkpointing": true,
    "train_micro_batch_size_per_gpu": 1,
    "gradient_accumulation_steps": 32
}
```

## Gradient checkpointing

Économisez de la mémoire en recalculant les activations :

```python
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model.gradient_checkpointing_enable()
```

## Sauvegarder et charger les points de contrôle

### Sauvegarder

```python

# DeepSpeed gère la sauvegarde des points de contrôle
model_engine.save_checkpoint("./checkpoints", tag="step_1000")
```

### Charger

```python
model_engine.load_checkpoint("./checkpoints", tag="step_1000")
```

### Enregistrer au format Hugging Face

```python

# Convertir le checkpoint DeepSpeed au format HF
from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint

state_dict = get_fp32_state_dict_from_zero_checkpoint("./checkpoints/step_1000")
model.load_state_dict(state_dict)
model.save_pretrained("./hf_model")
```

## Surveillance

### TensorBoard

```json
{
    "tensorboard": {
        "enabled": true,
        "output_path": "./logs",
        "job_name": "training_run"
    }
}
```

### Weights & Biases

```json
{
    "wandb": {
        "enabled": true,
        "project": "my_project"
    }
}
```

## Problèmes courants

### Mémoire insuffisante

```json
// Essayez :
{
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"}
    },
    "train_micro_batch_size_per_gpu": 1
}
```

### Entraînement lent

* Réduire le déchargement CPU
* Augmenter la taille du lot
* Utiliser ZeRO étape 2 au lieu de 3

### Erreurs NCCL

```bash

# Définir les variables d'environnement
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1
```

## Conseils de performance

| Astuce                            | Effet               |
| --------------------------------- | ------------------- |
| Utilisez bf16 plutôt que fp16     | Meilleure stabilité |
| Activer le gradient checkpointing | Moins de mémoire    |
| Ajuster la taille du lot          | Meilleur débit      |
| Utiliser le déchargement NVMe     | Modèles plus grands |

## Comparaison des performances

| Modèle | GPU     | Étape ZeRO | Vitesse d'entraînement |
| ------ | ------- | ---------- | ---------------------- |
| 7B     | 1x A100 | ZeRO-3     | \~1000 tokens/s        |
| 7B     | 4x A100 | ZeRO-2     | \~4000 tokens/s        |
| 13B    | 4x A100 | ZeRO-3     | \~2000 tokens/s        |
| 70B    | 8x A100 | ZeRO-3     | \~800 tokens/s         |

## Dépannage

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

| GPU        | Tarif horaire | Tarif journalier | Session de 4 heures |
| ---------- | ------------- | ---------------- | ------------------- |
| RTX 3060   | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090   | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090   | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* [Affiner les LLM](/guides/guides_v2-fr/entrainement/finetune-llm.md) - Entraînement LoRA
* Inférence vLLM - Déployer le modèle entraîné
* [Guide Hugging Face](/guides/guides_v2-fr/entrainement/huggingface-transformers.md) - Bibliothèque Transformers


---

# 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/entrainement/deepspeed-training.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.