Entraînement DeepSpeed

Entraînez de grands modèles efficacement 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 CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez 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 :

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

# 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

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

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

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

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

hostfile :

node1 slots=4
node2 slots=4

Lancer

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

Configuration SSH

# 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

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

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

Enregistrer et charger des points de contrôle

Enregistrer

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

Charger

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

Enregistrer au format HuggingFace

# 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

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

• Utiliser ZeRO Stage 2 au lieu du 3

Erreurs NCCL

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

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

• Guide Hugging Face - Bibliothèque Transformers