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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

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.

1. Visitez la place de marché CLORE.AI

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 :

pip install deepspeed transformers datasets accelerate

Installation

pip install deepspeed

# Vérifier l'installation
ds_report

Entraînement de base

Configuration DeepSpeed

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

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

{
    "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 :

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

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

# 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

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

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

Configuration SSH

# 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

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

{
    "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 :

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

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

Charger

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

Enregistrer au format Hugging Face

# 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

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

Weights & Biases

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

Problèmes courants

Mémoire insuffisante

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

# 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 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 - Entraînement LoRA

• Inférence vLLM - Déployer le modèle entraîné

• Guide Hugging Face - Bibliothèque Transformers