> 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 Microsoft DeepSpeed.

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

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À 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@<adresse-proxy>`

## Qu'est-ce que DeepSpeed ?

DeepSpeed permet :

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

## Étages 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              | Plus grands modèles |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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

# Initialiser
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 ZeRO Stage 2

```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 ZeRO Stage 3

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

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

**hostfile :**

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

### Lancer

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

### Configuration SSH

```bash

# Assurer un SSH sans mot de passe entre les nœuds
ssh-keygen -t rsa
ssh-copy-id user@node2
```

## Configurations efficaces en mémoire

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

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

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

## Enregistrer et charger des points de contrôle

### Enregistrer

```python

# DeepSpeed gère les checkpoints
model_engine.save_checkpoint("./checkpoints", tag="step_1000")
```

### Charger

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

### Enregistrer au format HuggingFace

```python

# Convertir un 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 de batch
* Utiliser ZeRO Stage 2 au lieu du 3

### Erreurs NCCL

```bash

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

## Conseils de performance

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

## Comparaison des performances

| Modèle | GPUs    | É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 (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [Ajuster des LLMs](/guides/guides_v2-fr/entrainement/finetune-llm.md) - Entraînement LoRA
* vLLM Inference - 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/deepspeed-training.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.