Treino Distribuído em 2026: DDP, FSDP2, DeepSpeed, Megatron e os Cinco Eixos do Paralelismo
A partir do momento em que tem mais do que uma GPU numa máquina, há uma escolha a fazer. Quatro stacks open-source dominam hoje o treino distribuído — PyTorch DDP, PyTorch FSDP2, Microsoft DeepSpeed e NVIDIA Megatron-Core — aos quais se junta o TorchTitan como nova referência para o treino em larga escala nativo de PyTorch. Cada um resolve um problema diferente. Escolher mal custa semanas: ou o modelo não cabe e o cliente só descobre no passo 30 com um erro de falta de memória, ou sobredimensionou a engenharia para uma carga de trabalho que o DDP teria resolvido com um décimo do esforço.
Este artigo apresenta a perspetiva de quem compra e de quem arquiteta o treino distribuído. Percorre os cinco eixos de paralelismo, as quatro (agora cinco) frameworks que os combinam e as receitas que realmente funcionam em hardware da classe Kentino — sobretudo 4× e 8× RTX 5090, 4090 e RTX Pro 6000 Blackwell em hosts AMD EPYC, com PCIe Gen5 e Ethernet convencional ou InfiniBand entre nós. A conclusão honesta vem logo no início, para que o resto do artigo não tenha de a andar a demonstrar: a maioria dos clientes Kentino faz fine-tuning, não pré-treino, e o FSDP2 num único nó de 8 GPU resolve 90% das necessidades de fine-tuning. O Megatron-Core e o paralelismo 3D só compensam quando se faz pré-treino de raiz acima da escala dos 30B, e esse clube é bastante mais restrito do que o marketing sugere.
Os cinco eixos
Todas as frameworks modernas de treino distribuído compõem algum subconjunto dos mesmos cinco eixos de paralelismo. Não são alternativas — as receitas para modelos grandes combinam três ou quatro ao mesmo tempo. Leia a coluna da comunicação de cima a baixo; é aí que está todo o jogo.
| Eixo | O que divide | Comunicação por passo | Exigente em largura de banda? | Notas |
|---|---|---|---|---|
| Paralelismo de dados (DP) | O lote — cada rank tem o modelo completo | All-reduce dos gradientes uma vez por passo | Moderada | A base; DDP e FSDP são ambos DP |
| Paralelismo de tensores (TP) | O matmul de cada camada entre GPUs | All-reduce por camada × 2 (attn + FFN) | Muito elevada | Adora NVLink; sofre em PCIe |
| Paralelismo de pipeline (PP) | Camadas divididas por andares | Ativações na fronteira de cada andar | Ligeira | Acrescenta latência de bolha, aumenta o débito |
| Paralelismo de sequência/contexto (SP/CP) | A dimensão de sequência entre GPUs | All-gather em anel de KV / ativações | Moderada–elevada | Permite treino com um milhão de tokens |
| Paralelismo de especialistas (EP) | Especialistas MoE entre GPUs | All-to-all por camada MoE | Elevada e intermitente | Apenas MoE |
O DP grita uma vez por passo. O TP grita duas vezes por camada. O PP sussurra uma vez por andar. O SP/CP grita uma vez por bloco de atenção, mas noutra dimensão. O EP faz all-to-all apenas nas camadas MoE ativas. É essa coluna que decide onde vive cada eixo — dentro de uma máquina rápida ou através de um fabric mais lento.
O "paralelismo 3D" que aparece em todos os blogues da NVIDIA é DP × TP × PP. Acrescente SP e EP e passa a 4D ou 5D, o que é mais um jogo de notação do que uma mudança arquitetural. O que importa é o layout: TP dentro do nó (onde a largura de banda é barata), PP entre nós (onde a largura de banda é cara) e DP por cima para escalar o débito. O SP encaixa ao lado do TP; o EP só se aplica a MoE.
Referências cruzadas: a largura de banda intra-nó do paralelismo de tensores é detalhada em K07, a penalização NVLink versus PCIe em N03 e o fabric entre nós em N08.
DDP — quando o modelo cabe e só quer mais débito
O PyTorch DDP (DistributedDataParallel) é a resposta mais antiga, mais simples e continua a ser correta quando o modelo cabe numa GPU. Cada rank guarda uma cópia completa do modelo e do estado do otimizador. A cada passo, cada rank faz o seu forward, o seu backward e o cálculo dos gradientes sobre o seu micro-lote. Depois, um único all-reduce soma os gradientes entre ranks e todos aplicam a mesma atualização.
O DDP no PyTorch 2.x é o mesmo DDP de sempre, com duas melhorias dignas de nota: um caminho static_graph=True mais robusto para grafos amigos do compilador e uma integração mais estreita com o torch.compile. O padrão de comunicação mantém-se — um all-reduce por passo, sobreposto ao backward, a escalar linearmente até o all-reduce passar a dominar.
Quando o DDP é a resposta certa:
- O modelo completo + estados do otimizador + ativações cabem numa GPU. Para otimizadores do tipo Adam com pesos master em FP32, a regra prática é de cerca de 16 bytes por parâmetro de memória só para o estado treinável (4 bytes de pesos, 4 bytes de gradientes, 8 bytes de otimizador), mais as ativações. Um modelo de 8B = 128 GB de estado, que só cabe numa RTX Pro 6000 Blackwell (96 GB) com precisão mista e pesos master em BF16. Abaixo dos 8B parâmetros, o DDP fica confortável numa única 5090; acima disso, olhe para o FSDP2.
- Quer débito máximo, não tamanho máximo de modelo. O DDP tem o menor rácio de comunicação para computação de todas as abordagens de paralelismo de dados, porque os gradientes são reduzidos uma vez por passo, depois de todo o trabalho local de backward.
- Está a fazer rollouts de aprendizagem por reforço, LoRA, ou qualquer configuração em que cada rank guarda um pequeno adaptador treinável sobre pesos base congelados.
Quando o DDP está errado: o modelo não cabe. A solução não é "um lote mais pequeno". A solução é o FSDP2.
torchrun --standalone --nproc-per-node=8 train.py
É este o launcher completo. O DDP é o predefinido aborrecido de que toda a gente se esquece e, para a carga de trabalho certa, é a coisa mais rápida que pode executar.
FSDP2 — o novo predefinido para tudo o que o DDP não aguenta
O FSDP (Fully Sharded Data Parallel) fragmenta os parâmetros do modelo, os gradientes e os estados do otimizador pelo grupo de paralelismo de dados. Cada GPU armazena 1/N dos parâmetros. Para fazer um forward, o rank faz all-gather da camada de que precisa naquele momento, executa a computação e descarta os pesos recolhidos. A memória cai cerca de N vezes face ao DDP; a comunicação sobe, porque cada camada é recolhida e voltada a recolher.
A história de 2025 é o FSDP2. O FSDP original (FSDP1) agrupava conjuntos de parâmetros num único FlatParameter, o que tornava penoso ou impossível raciocinar sobre o comportamento parâmetro a parâmetro — congelamento parcial, dtypes mistos, definições de otimizador por parâmetro. O FSDP2 reescreveu as entranhas sobre DTensor: cada tensor continua a ser um verdadeiro torch.Tensor que por acaso está fragmentado ao longo da dim-0 pelos ranks. A API visível para o utilizador passou de FSDP(model, ...) para fully_shard(model, ...).
O que o FSDP2 traz de facto face ao FSDP1, a partir dos benchmarks publicados e das nossas próprias execuções:
-
~7% menos memória de GPU no Llama 2 7B com a mesma configuração, porque o FSDP2 evita o padrão
record_streamque fixava memória de forma pessimista. -
~1.5% de ganho de débito em paridade e até 50% de aumento de débito quando combinado com
torch.compilee treino em float8 comtorchaoem hardware da classe Hopper. - State dicts fragmentados que carregam depressa e voltam a fragmentar-se de forma limpa entre diferentes layouts de paralelismo — o formato de checkpoint do FSDP1 era conhecido por ser difícil de remodelar entre treino e inferência.
- Congelamento parcial de parâmetros sem acrobacias, o que conta para LoRA e para o treino de adaptadores.
O FSDP1 está descontinuado a partir do PyTorch 2.11. Trabalho novo deve usar fully_shard. O antigo wrapper FullyShardedDataParallel ainda existe por compatibilidade, mas está em via de remoção.
O FSDP2 expõe ainda duas estratégias de fragmentação que decidem onde vive o modelo:
- Full shard. Parâmetros totalmente fragmentados por todos os ranks (o predefinido do FSDP1). Memória mínima, comunicação máxima.
- Hybrid shard. Parâmetros fragmentados dentro de um nó e replicados entre nós. Dentro do nó, a comunicação faz-se por PCIe/NVLink (rápido). Entre nós, só o all-reduce dos gradientes atravessa o fabric lento. É o ponto ideal para 2–4 nós em Ethernet/IB de 100/200 Gbps.
Quando o FSDP2 é a resposta certa (o caso típico Kentino):
- Fine-tuning de 8B–70B num único nó de 8 GPU. Full shard, BF16, gradient checkpointing ativado,
torch.compile. Feito. - Fine-tuning de 70B–405B em 2–4 nós. Hybrid shard, com full shard dentro de cada nó e replicação entre nós.
- Qualquer coisa em LoRA / QLoRA — o tratamento parcial de parâmetros do FSDP2 bate aqui o FSDP1 de forma clara.
from torch.distributed.fsdp import fully_shard, MixedPrecisionPolicy
mp = MixedPrecisionPolicy(param_dtype=torch.bfloat16, reduce_dtype=torch.float32)
for block in model.transformer_blocks:
fully_shard(block, mp_policy=mp)
fully_shard(model, mp_policy=mp)
Lançado da mesma forma que o DDP, via torchrun. O wrapper é a única coisa que muda.
DeepSpeed e os níveis ZeRO — ainda por aí, já não o predefinido
O DeepSpeed é a stack de treino distribuído da Microsoft. A sua fama veio do ZeRO (Zero Redundancy Optimizer), que chegou anos antes do FSDP e definiu a abordagem moderna de fragmentar tudo.
| Nível | O que é fragmentado | Poupança de memória vs DDP | Comunicação vs DDP |
|---|---|---|---|
| ZeRO-1 | Estados do otimizador | ~4× | Igual |
| ZeRO-2 | Estados do otimizador + gradientes | ~8× | Ligeiramente superior |
| ZeRO-3 | Estados do otimizador + gradientes + parâmetros | Linear em N | ~1.5× DDP |
O ZeRO-3 é arquiteturalmente equivalente ao full shard do FSDP. Resolvem o mesmo problema com as mesmas primitivas de comunicação.
A realidade em 2025–2026: o FSDP2 comeu o almoço ao DeepSpeed no caso de uso dos LLM densos. É nativo do PyTorch, não exige pacote adicional, está integrado com torch.compile e a mesma receita transita entre Hugging Face Transformers, Accelerate e TorchTitan. Benchmarks internos da Lightning e da Hugging Face mostram o full shard do FSDP a correr 2–5× mais depressa por iteração do que o ZeRO-3 em algumas configurações, embora o DeepSpeed recupere terreno em modelos muito grandes (10B+), onde os seus caminhos de offload para CPU e para NVMe continuam a ser genuinamente úteis.
Vale a pena continuar a conhecer o DeepSpeed por três razões:
- Offload ZeRO-Infinity. Se tiver mesmo de fazer fine-tuning de um modelo que não cabe de todo na memória agregada das GPU — digamos, uma base de 405B numa máquina com 4× RTX Pro 6000 Blackwell —, o DeepSpeed consegue descarregar parâmetros para a RAM do CPU (barato, lento) e para NVMe (mais barato, muito mais lento). O FSDP também tem offload para CPU, mas o caminho NVMe do DeepSpeed é mais maduro. Útil para "tenho uma máquina e um modelo teimoso"; não é a resposta certa se puder alugar ou comprar um segundo nó.
- Paralelismo de sequência DeepSpeed-Ulysses. Um esquema de paralelismo de sequência eficiente em comunicação que usa all-to-all em vez de all-gather em anel para a atenção. Demonstrado até contextos de 1M de tokens em 64 A100 e no treino do Llama-8B com 15M de tokens de contexto em 32 H100, em trabalho publicado em 2025. Se procura especificamente treino com contextos muito longos, o Ulysses continua à frente da implementação de paralelismo de contexto do Megatron para algumas formas.
- DeepSpeed-MoE. Treino de mixture-of-experts com paralelismo de especialistas. Pouco relevante para fine-tuning, muito relevante se estiver a fazer pré-treino de MoE.
Para a maior parte do fine-tuning dos clientes Kentino, a opção certa é o FSDP2, a menos que tenha uma razão específica para recorrer ao DeepSpeed (contexto longo, offload para CPU/NVMe, pré-treino de MoE). A inércia do ecossistema aponta inequivocamente para o FSDP2.
Megatron-LM, Megatron-Core, NeMo — onde vive a artilharia pesada
O Megatron começou como o artigo da NVIDIA sobre Transformers com paralelismo de tensores, em 2019. Hoje a família tem três camadas:
- Megatron-LM — a base de código de investigação original. Continua a ser usada e atualizada.
- Megatron-Core — a versão em biblioteca modular. Blocos de construção combináveis para TP/PP/DP/EP/CP, precisão mista (FP16/BF16/FP8/FP4) e arquiteturas transformer de referência. É esta que se integra na prática.
- NVIDIA NeMo — a framework ponta a ponta construída sobre o Megatron-Core. Receitas, pipelines de dados, alinhamento e implementação.
O Megatron-Core é a framework que vence no topo da gama, precisamente porque implementa paralelismo de tensores, de pipeline, de sequência, de contexto e de especialistas numa única malha combinável. Quando se treina um modelo denso de 405B em mais de 512 GPU, é impossível evitar a combinação de pelo menos três deles, e o Megatron-Core é a combinação mais implementada e mais testada.
As orientações de paralelismo do Megatron para 2026, retiradas da documentação da própria NVIDIA, encaixam na realidade do hardware:
| Hardware | Eixos principais recomendados |
|---|---|
| Nó único, NVLink | TP até 8 dentro do nó |
| Vários nós, InfiniBand NDR | TP dentro do nó, PP entre nós |
| Rede limitada (Ethernet) | Minimizar o TP, preferir PP entre nós |
| Sequências longas | Acrescentar CP; ativar SP sempre que o TP estiver ligado |
Essa tabela explica porque é que o Megatron existe. É a framework cujos autores convivem com as contas de largura de banda que descrevemos em N03 e K07, e as suas receitas estão afinadas para isso.
Onde o Megatron é exagero: em qualquer fine-tune de nó único, em qualquer modelo que caiba na memória ao jeito do FSDP2, em qualquer carga de trabalho em que não precise de TP. A maquinaria de TP do Megatron é genuinamente mais rápida do que um TP caseiro em PCIe, mas TP em PCIe continua a ser lento — veja os números do K07. A força do Megatron está em hardware SXM, que a Kentino não constrói.
Onde o Megatron é a resposta certa: pré-treino de modelos densos de 70B–405B+ em hardware da classe NVLink, alugado ou próprio, ou na construção de infraestrutura de treino em produção para um laboratório de investigação. Se for esse o seu caso, provavelmente já está no ecossistema NeMo.
TorchTitan — a nova referência
O TorchTitan é a referência da Meta para treino em larga escala nativo de PyTorch, aceite no ICLR 2025 e hoje o exemplo de facto para "qual deve ser o aspeto de uma receita TP × PP × FSDP2 × CP em 2026?". Não inventa paralelismo novo — compõe os blocos de construção que o PyTorch já inclui (fully_shard, torch.distributed.tensor.parallel, pipelining, DTensor) num script de treino paralelo limpo e quadridimensional, com checkpointing fragmentado assíncrono, torch.compile e float8.
Porque é que importa mesmo que não o use diretamente:
- É o exemplo canónico de como o FSDP2 se compõe com TP e PP sem recorrer a uma framework de terceiros.
- As mesmas APIs vêm no PyTorch de origem. Não há nada de mágico.
- A AMD lançou um fork otimizado do TorchTitan para ROCm no final de 2025; a parceria com a Lightning AI anunciada em outubro de 2025 permite correr receitas TorchTitan nos Lightning Studios.
Para clientes da classe Kentino, o TorchTitan é mais uma referência para ler do que uma framework para implementar. Se está a fazer fine-tuning, o Accelerate ou o Axolotl sobre FSDP2 são mais ergonómicos. Se está a fazer pré-treino a uma escala modesta (8–64 GPU) em hardware convencional, o TorchTitan é competitivo com o NeMo e bastante mais leve do ponto de vista operacional.
A matriz das frameworks
| Framework | Eixos de paralelismo | Mantida? | Melhor para |
|---|---|---|---|
| PyTorch DDP | DP | Sim, estável | Modelo cabe por GPU; débito máximo |
| PyTorch FSDP1 | DP (fragmentado) | Descontinuada na 2.11 | Não comece por aqui |
| PyTorch FSDP2 | DP (fragmentado), combina-se com TP/PP/CP | Sim, ativa | A resposta típica para fine-tuning em 2026 |
| DeepSpeed ZeRO | DP (fragmentado), offload CPU/NVMe | Sim, ativa | Muito offload, contexto muito longo (Ulysses), MoE |
| Megatron-Core / NeMo | TP, PP, SP, CP, EP, DP | Sim, muito ativa | Pré-treino de 70B+, clusters SXM/NVLink |
| TorchTitan | FSDP2 + TP + PP + CP + float8 | Sim, referência | Pré-treino moderno em stack nativa de PyTorch |
| HF Accelerate | Wrapper sobre DDP/FSDP/DS | Sim, ativa | Launcher simples, abstrai o backend |
| Axolotl | Wrapper sobre Accelerate/FSDP | Sim, ativa | Fine-tuning, datasets, receitas para LoRA/QLoRA |
O Accelerate e o Axolotl não são estratégias de paralelismo separadas — envolvem os backends acima. A maioria dos clientes Kentino que faz fine-tuning acabará por usar o Axolotl sobre FSDP2 sem sequer pensar nisso, e isso está correto.
O orçamento de comunicação — porque é que a rede limita o modelo
Referência cruzada: N08 percorre as contas de RDMA e de uplink; esta é a perspetiva específica do treino.
No paralelismo de dados (DDP ou FSDP), a comunicação entre ranks por passo é aproximadamente proporcional ao número de parâmetros (gradientes a reduzir). No paralelismo de tensores, é proporcional ao tamanho das ativações × número de camadas — ordens de grandeza superior por passo.
Volume de gradientes por regra prática, para um único passo em BF16:
| Tamanho do modelo | Bytes de gradientes/passo | Tempo de all-reduce a 25 GB/s (classe NDR HDR) | A 12.5 GB/s (100 GbE) |
|---|---|---|---|
| 8B | 16 GB | ~0.6 s | ~1.3 s |
| 70B | 140 GB | ~5.6 s | ~11 s |
| 405B | 810 GB | ~32 s | ~65 s |
Só o all-reduce de 70B leva 5.6 segundos num fabric de 200 Gbps. Se a computação de forward+backward de um passo também demorar 5 segundos, já está 50% limitado pela comunicação; se a computação demorar 2 segundos, está mais de 70% do tempo parado à espera da rede. É por isto que 100 GbE estrangula o treino acima de 70B e é preciso 400 GbE / NDR IB. A computação continua a ficar mais rápida; a rede tem de acompanhar, ou as GPU ficam paradas.
O FSDP2 esconde parte disto com sobreposição (começa a recolher a camada seguinte enquanto calcula a atual). O hybrid shard esconde mais, mantendo o all-reduce dos gradientes dentro do fabric intra-nó rápido e reduzindo apenas os gradientes replicados entre nós. Os números acima são o pior caso, para FSDP full shard entre nós e sem sobreposição.
No paralelismo de tensores, a comunicação por token escala com o tamanho do hidden e o número de camadas. Os números em K07 mostram porquê: ~80 MB por token gerado durante o decode, ~300 GB por prefill num 70B com lote 32. Este é o regime em que o PCIe (50 GB/s realistas) é cerca de 14× mais lento do que o NVLink (700+ GB/s realistas), e em que fazer pré-treino de um modelo denso de 70B+ em PCIe simplesmente não funciona com uma eficiência aceitável.
Receitas reais
Fine-tune de um Llama 8B, um nó de 8 GPU — FSDP2
Hardware: 8× RTX 5090 ou 8× RTX Pro 6000 Blackwell, host EPYC, sem necessidade de fabric entre nós.
torchrun --standalone --nproc-per-node=8 \
finetune.py \
--model meta-llama/Llama-3.1-8B \
--batch-size 1 --grad-accum 16 --seq-len 4096 \
--bf16 --fsdp full_shard --fsdp-reshard-after-forward \
--gradient-checkpointing --torch-compile
Esperado: ~2000 tok/s agregados em BF16, com folga para KV/ativações; o full shard do FSDP2 sobre PCIe Gen5 trata do all-reduce dos gradientes dentro da máquina. É também este o aspeto de 90% dos trabalhos de fine-tuning da Kentino.
Fine-tune de um Llama 70B, 2× nós de 8 GPU — hybrid shard do FSDP2
Hardware: 2× 8× RTX Pro 6000 Blackwell, 200 Gbps IB ou 100 GbE RoCE entre nós.
torchrun --nnodes=2 --nproc-per-node=8 \
--rdzv-backend=c10d --rdzv-endpoint=node0:29500 \
finetune.py \
--model meta-llama/Llama-3.3-70B \
--batch-size 1 --grad-accum 32 --seq-len 4096 \
--bf16 --fsdp hybrid_shard \
--gradient-checkpointing --torch-compile \
--activation-cpu-offload
O hybrid shard mantém o full shard dentro de cada nó de 8 GPU e replica entre os 2 nós. O fabric entre nós transporta apenas o reduce-scatter dos gradientes replicados — cerca de 70 GB/passo em BF16, ~3 s em IB de 200 Gbps. A sobreposição esconde a maior parte. Em 100 GbE o mesmo passo custa ~5–6 s e as GPU começam a mostrar tempo parado; a receita continua a funcionar, apenas mais devagar por época.
Pré-treino de 405B, 8× nós de 8 GPU — Megatron-Core 3D
Hardware: 8× nós NVLink/SXM de 8 GPU, 400 Gbps NDR IB. Não é construído pela Kentino — fica aqui para dar o quadro completo.
# Megatron-Core launcher (abbreviated)
torchrun --nnodes=8 --nproc-per-node=8 \
pretrain_gpt.py \
--tensor-model-parallel-size 8 \
--pipeline-model-parallel-size 8 \
--sequence-parallel \
--context-parallel-size 1 \
--num-layers 126 --hidden-size 16384 --num-attention-heads 128 \
--seq-length 8192 --micro-batch-size 1 --global-batch-size 2048 \
--bf16 --use-flash-attn --transformer-impl transformer_engine
TP=8 × PP=8 = 64 ranks por réplica; 8 nodes × 8 GPUs = 64 GPUs no total, exatamente uma réplica. Para escalar para várias réplicas e obter mais débito, multiplique por DP. É aqui que o Megatron compensa. O mesmo modelo só com FSDP2 passaria a maior parte do tempo em comunicação entre ranks; o layout 3D coloca a comunicação mais pesada (TP) dentro do domínio NVLink.
Opinião honesta para os clientes Kentino
A maioria dos clientes Kentino não faz pré-treino. Faz fine-tuning de modelos base de pesos abertos — Llama, Qwen, Mistral, por vezes Gemma — sobre os seus dados de domínio, ocasionalmente com LoRA ou QLoRA, ocasionalmente em fine-tunes completos. Para esse trabalho, a escolha da framework é:
- Um modelo que cabe numa GPU em BF16, com o estado do otimizador. Use DDP. Replique cópias para ganhar débito.
- Um modelo que não cabe numa GPU, mas cabe no agregado de um nó de 8 GPU. Use o full shard do FSDP2. Cobre fine-tunes de 8B–70B.
- Um modelo que cabe no agregado de dois nós de 8 GPU. Use o hybrid shard do FSDP2. Fine-tunes de 70B–200B.
- Um modelo maior do que isso, ou pré-treino de raiz. É esta a conversa onde entram o Megatron-Core, o hardware SXM e o NDR IB. Nós construímos o armazenamento e o plano de gestão, mas nessa fase as GPU são normalmente alugadas.
Os 10% de clientes que precisam genuinamente de treino multi-nó fortemente acoplado são sobretudo laboratórios de investigação com programas de pré-treino financiados, e sabem o que precisam antes de telefonar. Aos outros 90% não se deve vender um cluster — deve vender-se um nó de 8 GPU bem especificado, com o ponto de ligação de fabric certo para um futuro segundo nó, e deixar o equipamento de rede como uma rubrica P2.
O que fazer a seguir
Se está a dimensionar um trabalho de treino e ainda não escolheu a framework, percorra estes pontos por ordem:
- Calcule a memória por rank na precisão pretendida. Parâmetros × 2 (BF16) + gradientes × 2 + otimizador × 8 (estados Adam em FP32) + ativações. Se isso couber na VRAM da sua GPU com folga, o DDP é a sua resposta.
- Se a memória não chegar, pergunte: tenho um nó ou vários? Um nó → full shard do FSDP2, fim de conversa. Vários nós → hybrid shard do FSDP2.
-
Faça uma verificação de sanidade num único passo. Observe o tempo de all-reduce em
NCCL_DEBUG=INFO. Se dominar o passo, a rede está subdimensionada para o modelo. Passar a um modelo mais pequeno ou a um fabric maior são as suas duas opções; afinar a framework não o safa. -
Só recorra ao Megatron-Core ou ao DeepSpeed quando o FSDP2 não fizer o que precisa. "Não fizer" significa: precisar de paralelismo de tensores para um modelo maior do que a memória agregada do nó, precisar de offload para CPU/NVMe, precisar de paralelismo de sequência acima do que o
--context-parallel-sizedo PyTorch lhe dá, ou estar a fazer pré-treino de MoE. - Use o Axolotl ou o Accelerate como launcher. Montar o wrapping do FSDP2 à mão é um exercício de aprendizagem; em produção quer a framework que trata do dataset, do tokenizador, do formato de checkpoint e da canalização de LoRA. Ambos assentam em FSDP2 por baixo.
-
Faça checkpoint com
torch.distributed.checkpoint(DCP) ou com o checkpoint fragmentado assíncrono do NeMo. Checkpoints síncronos não fragmentados escritos para NFS são um padrão de 2022; em 2026 são uma paragem de treino autoinfligida. Veja em K06 o tratamento de falhas que daí decorre. - Seja honesto quanto ao tamanho do cluster de que realmente precisa. Se o seu trabalho corre num nó de 8 GPU num tempo de relógio razoável, não pague um cluster de quatro nós para o tornar 2.5× mais rápido no papel. As contas de escalabilidade em K07 mostram porque é que "mais nós" deixa cedo de ajudar em hardware convencional.
Artigos relacionados: armazenamento e checkpointing em treino distribuído em K04, clustering de inferência em K03, tratamento de falhas em K06, o teto de largura de banda do PCIe em K07 e o compromisso NVLink versus PCIe em N03. As contas de rede estão em N08.
Isto faz parte da Kentino Wiki, uma série de referência sobre computação de IA, robótica e os sistemas que as ligam. Comentários e correções são bem-vindos em info@kentino.com.