Entrenamiento con 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 Marketplace de CLORE.AI.

Alquilar en CLORE.AI

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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 con 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	Máximo ahorro
ZeRO-Infinity	Descarga a CPU/NVMe	Modelos más grandes

Despliegue rápido

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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 inicio

# Un solo nodo, 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

Iniciar

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

Configuración SSH

# Asegúrate de tener 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 24 GB

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

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

Punto de control de gradiente

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 puntos de control

Guardar

# DeepSpeed se encarga de los puntos de control
model_engine.save_checkpoint("./checkpoints", tag="step_1000")

Cargar

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

Guardar en formato Hugging Face

# Convertir el punto de control 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

Sin memoria

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

Entrenamiento lento

• Reduce la descarga a CPU

• Aumenta el tamaño del lote

• Usa ZeRO Etapa 2 en lugar de 3

Errores de NCCL

# Configura las variables de entorno
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1

Consejos de rendimiento

Consejo	Efecto
Usa bf16 en lugar de fp16	Mejor estabilidad
Activa el checkpointing de gradiente	Menos memoria
Ajusta el tamaño del lote	Mejor rendimiento
Usa descarga a NVMe	Modelos más grandes

Comparación de rendimiento

Modelo	GPUs	Etapa de 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 partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• Ajuste fino de LLMs - Entrenamiento LoRA

• Inferencia con vLLM - Desplegar el modelo entrenado

• Guía de Hugging Face - Biblioteca Transformers