entrenamiento distribuido de MoE en GPUs utilizando PyTorch + DeepSpeed

Simulación de entrenamiento distribuido de MoE en GPUs utilizando PyTorch + DeepSpeed.

Objetivo:

• Entrenar un modelo Transformer con MoE en múltiples GPUs.
• Distribuir expertos usando Paralelismo de Expertos (EP).
• Optimizar memoria con DeepSpeed ZeRO + FP16.

 Instalación de Dependencias

Si aún no tienes DeepSpeed instalado, instálalo con:

pip install deepspeed torch transformers

Código Completo: MoE Distribuido en GPUs

import torch
import torch.nn as nn
import deepspeed
from deepspeed.moe.layer import MoE

# Modelo Transformer con MoE
class MoETransformer(nn.Module):
    def __init__(self, model_dim=512, num_experts=8, top_k=2):
        super().__init__()
        self.moe_layer = MoE(
            hidden_size=model_dim,
            expert=self.expert_fn,  # Definimos los expertos
            num_experts=num_experts,
            ep_size=4,  # 4 GPUs distribuyendo expertos
            k=top_k  # Solo activamos 2 expertos por batch
        )
        self.fc_out = nn.Linear(model_dim, model_dim)  # Capa final
        
    def expert_fn(self):
        """Cada experto es una simple capa lineal"""
        return nn.Sequential(nn.Linear(512, 512), nn.ReLU())

    def forward(self, x):
        x = self.moe_layer(x)  # Paso por MoE
        return self.fc_out(x)

# Configuración de DeepSpeed para entrenamiento distribuido
ds_config = {
    "train_batch_size": 64,
    "gradient_accumulation_steps": 2,
    "fp16": {"enabled": True},  # Entrenamiento en 16 bits
    "zero_optimization": {
        "stage": 2,  # Optimización ZeRO Stage 2
        "offload_optimizer": {"device": "cpu"},  # Reduce uso de memoria en GPU
    },
    "moe": {
        "enabled": True,
        "num_experts": 8,
        "top_k": 2,  # Solo activamos 2 expertos por batch
        "expert_parallel_group_size": 4,  # Expertos distribuidos en 4 GPUs
    }
}

#  Inicializar modelo y DeepSpeed
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = MoETransformer().to(device)

# DeepSpeed maneja la paralelización en GPUs
model, optimizer, _, _ = deepspeed.initialize(
    model=model, config=ds_config
)

#  Simulación de entrenamiento en múltiples GPUs
def train_step(model, optimizer, batch):
    optimizer.zero_grad()
    outputs = model(batch)
    loss = outputs.mean()  # Simulación de pérdida
    model.backward(loss)  # Backpropagation distribuido con DeepSpeed
    optimizer.step()
    return loss.item()

#  Entrenar el modelo con datos ficticios
num_steps = 10
for step in range(num_steps):
    batch = torch.randn(64, 512).to(device)  # Batch aleatorio
    loss = train_step(model, optimizer, batch)
    print(f"Paso {step+1}/{num_steps}, Pérdida: {loss:.4f}")

print("✅ Entrenamiento distribuido con MoE completado 🚀")

Explicación del Código

🔹 1. Definir el Modelo MoE

• Usamos 8 expertos, pero solo 2 se activan por batch (top_k = 2).
• Cada experto es una red neuronal simple (Linear + ReLU).
• Los expertos se distribuyen en 4 GPUs.

🔹 2. Configuración de DeepSpeed

• FP16 activado → Usa menos memoria en GPU.
• Zero Optimization Stage 2 → Reduce la carga en GPUs dividiendo pesos y gradientes.
• Distribución de expertos en GPUs → Los expertos se asignan dinámicamente para balancear la carga.

🔹 3. Entrenamiento Distribuido

• DeepSpeed maneja automáticamente la sincronización de GPUs.
• Se usa backpropagation distribuido para optimizar la memoria.
• Se ejecutan 10 pasos de entrenamiento con datos simulados.

 ¿Cómo Escalar Esto a Clusters Más Grandes?

Si queremos entrenar en más GPUs, basta con modificar:

🔹 Aumentar «ep_size» en la configuración de DeepSpeed:

"moe": {
    "expert_parallel_group_size": 8  # Si tenemos 8 GPUs en el cluster
}

🔹 Ejecutar en múltiples nodos con deepspeed

deepspeed --num_nodes=2 --num_gpus=8 train_moe.py

Esto distribuirá los expertos y los datos entre 8 GPUs en 2 servidores diferentes.

 Conclusión: MoE Distribuido en Clusters de GPU

MoE es altamente escalable y permite entrenar modelos enormes sin un costo prohibitivo.
DeepSpeed facilita la paralelización, optimizando memoria y balanceando carga.
Ejecutar en clusters de GPUs es sencillo, gracias a deepspeed --num_nodes=X --num_gpus=Y.

Usado en:

• GPT-4 MoE
• DeepSeek (China)
• Google Gemini