Entrenamiento DeepSpeed

Entrena modelos grandes de forma eficiente con DeepSpeed en GPUs de Clore.ai

Entrena modelos grandes de forma eficiente con Microsoft DeepSpeed.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es DeepSpeed?

DeepSpeed permite:

• Entrenar modelos que no caben en la memoria GPU

• Entrenamiento multi-GPU y multinodo

• Optimización ZeRO (eficiencia de memoria)

• Entrenamiento en precisión mixta

Etapas de ZeRO

Etapa	Ahorro de memoria	Velocidad
ZeRO-1	Estados del optimizador particionados	Rápido
ZeRO-2	+ Gradientes particionados	Equilibrado
ZeRO-3	+ Parámetros particionados	Ahorros máximos
ZeRO-Infinity	Descarga a CPU/NVMe	Modelos más grandes

Despliegue rápido

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp

Comando:

pip install deepspeed transformers datasets accelerate

Instalación

pip install deepspeed

# Verificar la instalación
ds_report

Entrenamiento básico

Configuración de 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 de entrenamiento

import torch
import deepspeed
from transformers import AutoModelForCausalLM, AutoTokenizer

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

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

# Bucle de entrenamiento
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()

Configuración de ZeRO Etapa 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
    }
}

Configuración de ZeRO Etapa 3

Para modelos grandes:

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

Con Hugging Face Transformers

Integración con 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()

Entrenamiento multi-GPU

Comando de lanzamiento

# Nodo único, 4 GPUs
deepspeed --num_gpus=4 train.py --deepspeed ds_config.json

# GPUs específicas
deepspeed --include="localhost:0,1,2,3" train.py --deepspeed ds_config.json

Con torchrun

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

Entrenamiento multinodo

Archivo de hosts

hostfile:

node1 slots=4
node2 slots=4

Lanzar

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

Configuración de SSH

# Asegurar SSH sin contraseña entre nodos
ssh-keygen -t rsa
ssh-copy-id user@node2

Configuraciones eficientes en memoria

Modelo de 7B en GPU de 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
}

Modelo de 13B en GPU de 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

Ahorra memoria recomputando activaciones:

from transformers import AutoModelForCausalLM

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

Guardar y cargar checkpoints

Guardar

# DeepSpeed gestiona los checkpoints
model_engine.save_checkpoint("./checkpoints", tag="step_1000")

Cargar

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

Guardar en formato HuggingFace

# Convertir checkpoint de DeepSpeed al formato 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")

Monitoreo

TensorBoard

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

Weights & Biases

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

Problemas comunes

Memoria insuficiente

// Intenta:
{
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"}
    },
    "train_micro_batch_size_per_gpu": 1
}

Entrenamiento lento

• Reducir la descarga a CPU

• Aumentar el tamaño del batch

• Usar ZeRO Etapa 2 en lugar de 3

Errores NCCL

# Establecer variables de entorno
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1

Consejos de rendimiento

Consejo	Efecto
Usar bf16 en lugar de fp16	Mejor estabilidad
Habilitar gradient checkpointing	Menos memoria
Ajustar el tamaño del batch	Mejor rendimiento
Usar descarga a NVMe	Modelos más grandes

Comparación de rendimiento

Modelo	GPUs	Etapa ZeRO	Velocidad de entrenamiento
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

Solución de problemas

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• Ajustar LLMs - Entrenamiento LoRA

• Inferencia vLLM - Desplegar modelo entrenado

• Guía de Hugging Face - Biblioteca Transformers