Skip to content

artubss/SKILLS-CLAUDE-CODE / skills/skills/ai-research/distributed-training-accelerate

huggingface-accelerate

Verified

API de treinamento distribuído mais simples. 4 linhas para adicionar suporte distribuído a qualquer script PyTorch. API unificada para DeepSpeed/FSDP/Megatron/DDP. Posicionamento automático de device, precisão mista (FP16/BF16/FP8). Config interativo, comando de launch único. Padrão do ecossistema HuggingFace.

HuggingFace Accelerate - Treinamento Distribuído Unificado

Início rápido

Accelerate simplifica o treinamento distribuído em 4 linhas de código.

Instalação:

pip install accelerate

Converter script PyTorch (4 linhas):

import torch
+ from accelerate import Accelerator

+ accelerator = Accelerator()

  model = torch.nn.Transformer()
  optimizer = torch.optim.Adam(model.parameters())
  dataloader = torch.utils.data.DataLoader(dataset)

+ model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

  for batch in dataloader:
      optimizer.zero_grad()
      loss = model(batch)
-     loss.backward()
+     accelerator.backward(loss)
      optimizer.step()

Executar (comando único):

accelerate launch train.py

Workflows comuns

Workflow 1: De uma GPU para multi-GPU

Script original:

# train.py
import torch

model = torch.nn.Linear(10, 2).to('cuda')
optimizer = torch.optim.Adam(model.parameters())
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

for epoch in range(10):
    for batch in dataloader:
        batch = batch.to('cuda')
        optimizer.zero_grad()
        loss = model(batch).mean()
        loss.backward()
        optimizer.step()

Com Accelerate (4 linhas adicionadas):

# train.py
import torch
from accelerate import Accelerator  # +1

accelerator = Accelerator()  # +2

model = torch.nn.Linear(10, 2)
optimizer = torch.optim.Adam(model.parameters())
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)  # +3

for epoch in range(10):
    for batch in dataloader:
        # Sem necessidade de .to('cuda') - automático!
        optimizer.zero_grad()
        loss = model(batch).mean()
        accelerator.backward(loss)  # +4
        optimizer.step()

Configurar (interativo):

accelerate config

Perguntas:

  • Qual máquina? (single/multi GPU/TPU/CPU)
  • Quantas máquinas? (1)
  • Precisão mista? (no/fp16/bf16/fp8)
  • DeepSpeed? (no/yes)

Launch (funciona em qualquer setup):

# Single GPU
accelerate launch train.py

# Multi-GPU (8 GPUs)
accelerate launch --multi_gpu --num_processes 8 train.py

# Multi-node
accelerate launch --multi_gpu --num_processes 16 \
  --num_machines 2 --machine_rank 0 \
  --main_process_ip $MASTER_ADDR \
  train.py

Workflow 2: Treinamento com precisão mista

Habilitar FP16/BF16:

from accelerate import Accelerator

# FP16 (com gradient scaling)
accelerator = Accelerator(mixed_precision='fp16')

# BF16 (sem scaling, mais estável)
accelerator = Accelerator(mixed_precision='bf16')

# FP8 (H100+)
accelerator = Accelerator(mixed_precision='fp8')

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

# Tudo mais é automático!
for batch in dataloader:
    with accelerator.autocast():  # Opcional, feito automaticamente
        loss = model(batch)
    accelerator.backward(loss)

Workflow 3: Integração DeepSpeed ZeRO

Habilitar DeepSpeed ZeRO-2:

from accelerate import Accelerator

accelerator = Accelerator(
    mixed_precision='bf16',
    deepspeed_plugin={
        "zero_stage": 2,  # ZeRO-2
        "offload_optimizer": False,
        "gradient_accumulation_steps": 4
    }
)

# Mesmo código de antes!
model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

Ou via config:

accelerate config
# Selecione: DeepSpeed → ZeRO-2

deepspeed_config.json:

{
    "fp16": {"enabled": false},
    "bf16": {"enabled": true},
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {"device": "cpu"},
        "allgather_bucket_size": 5e8,
        "reduce_bucket_size": 5e8
    }
}

Launch:

accelerate launch --config_file deepspeed_config.json train.py

Workflow 4: FSDP (Fully Sharded Data Parallel)

Habilitar FSDP:

from accelerate import Accelerator, FullyShardedDataParallelPlugin

fsdp_plugin = FullyShardedDataParallelPlugin(
    sharding_strategy="FULL_SHARD",  # Equivalente a ZeRO-3
    auto_wrap_policy="TRANSFORMER_AUTO_WRAP",
    cpu_offload=False
)

accelerator = Accelerator(
    mixed_precision='bf16',
    fsdp_plugin=fsdp_plugin
)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

Ou via config:

accelerate config
# Selecione: FSDP → Full Shard → No CPU Offload

Workflow 5: Acumulação de gradientes

Acumular gradientes:

from accelerate import Accelerator

accelerator = Accelerator(gradient_accumulation_steps=4)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

for batch in dataloader:
    with accelerator.accumulate(model):  # Lida com acumulação
        optimizer.zero_grad()
        loss = model(batch)
        accelerator.backward(loss)
        optimizer.step()

Tamanho efetivo de batch: batch_size * num_gpus * gradient_accumulation_steps

Quando usar vs alternativas

Use Accelerate quando:

  • Quer o treinamento distribuído mais simples
  • Precisa de um único script para qualquer hardware
  • Usa o ecossistema HuggingFace
  • Quer flexibilidade (DDP/DeepSpeed/FSDP/Megatron)
  • Precisa de prototipagem rápida

Principais vantagens:

  • 4 linhas: Mudanças mínimas de código
  • API unificada: Mesmo código para DDP, DeepSpeed, FSDP, Megatron
  • Automático: Posicionamento de device, precisão mista, sharding
  • Config interativo: Sem necessidade de setup manual de launcher
  • Launch único: Funciona em qualquer lugar

Use alternativas em vez disso:

  • PyTorch Lightning: Precisa de callbacks, abstrações de alto nível
  • Ray Train: Orquestração multi-node, tuning de hiperparâmetros
  • DeepSpeed: Controle direto de API, recursos avançados
  • DDP bruto: Controle máximo, abstração mínima

Problemas comuns

Problema: Posicionamento errado de device

Não mova manualmente para device:

# ERRADO
batch = batch.to('cuda')

# CORRETO
# Accelerate lida automaticamente após prepare()

Problema: Acumulação de gradientes não funciona

Use context manager:

# CORRETO
with accelerator.accumulate(model):
    optimizer.zero_grad()
    accelerator.backward(loss)
    optimizer.step()

Problema: Checkpoint em distribuído

Use métodos do accelerator:

# Salve apenas no processo principal
if accelerator.is_main_process:
    accelerator.save_state('checkpoint/')

# Carregue em todos os processos
accelerator.load_state('checkpoint/')

Problema: Resultados diferentes com FSDP

Garanta a mesma seed aleatória:

from accelerate.utils import set_seed
set_seed(42)

Tópicos avançados

Integração Megatron: Veja references/megatron-integration.md para tensor parallelism, pipeline parallelism e setup de sequence parallelism.

Plugins customizados: Veja references/custom-plugins.md para criar plugins distribuídos customizados e configuração avançada.

Tuning de performance: Veja references/performance.md para profiling, otimização de memória e melhores práticas.

Requisitos de hardware

  • CPU: Funciona (lento)
  • Single GPU: Funciona
  • Multi-GPU: DDP (padrão), DeepSpeed ou FSDP
  • Multi-node: DDP, DeepSpeed, FSDP, Megatron
  • TPU: Suportado
  • Apple MPS: Suportado

Requisitos de launcher:

  • DDP: torch.distributed.run (built-in)
  • DeepSpeed: deepspeed (pip install deepspeed)
  • FSDP: PyTorch 1.12+ (built-in)
  • Megatron: Setup customizado

Recursos

receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 319kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 319kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 319kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 319kUpdated Claude CodeCodexVerifiedInstall