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_stream que 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.compile e treino em float8 com torchao em 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:

  1. 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ó.
  2. 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.
  3. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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-size do PyTorch lhe dá, ou estar a fazer pré-treino de MoE.
  5. 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.
  6. 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.
  7. 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.