Trening rozproszony w 2026: DDP, FSDP2, DeepSpeed, Megatron i pięć osi równoległości

Gdy w jednej maszynie znajduje się więcej niż jeden GPU, pojawia się wybór. Cztery stosy open source dominują dziś w trenowaniu rozproszonym — PyTorch DDP, PyTorch FSDP2, Microsoft DeepSpeed i NVIDIA Megatron-Core — a dołączył do nich TorchTitan jako nowy punkt odniesienia dla natywnego dla PyTorch treningu na dużą skalę. Każdy z nich rozwiązuje inny problem. Wybór niewłaściwego kosztuje tygodnie: albo model się nie mieści i okazuje się to dopiero na kroku 30 wraz z awarią braku pamięci, albo powstaje przeinżynierowane rozwiązanie dla obciążenia, które DDP obsłużyłby dziesięciokrotnie mniejszym nakładem pracy.

Ten artykuł przedstawia spojrzenie kupującego i architekta na trenowanie rozproszone. Omawia pięć osi równoległości, cztery (obecnie pięć) frameworki, które je łączą, oraz przepisy, które naprawdę działają na sprzęcie klasy Kentino — przede wszystkim 4× i 8× RTX 5090, 4090 oraz RTX Pro 6000 Blackwell na hostach AMD EPYC, z PCIe Gen5 i zwykłym Ethernetem lub InfiniBand między węzłami. Uczciwa puenta znajduje się na samym początku, aby reszta artykułu nie musiała jej stale udowadniać: większość klientów Kentino dostraja modele, a nie trenuje ich od zera, a FSDP2 na pojedynczym węźle z 8 GPU pokrywa 90% potrzeb związanych z dostrajaniem. Megatron-Core i równoległość 3D zarabiają na siebie dopiero przy trenowaniu od zera powyżej skali 30B, a to znacznie węższy klub, niż sugeruje marketing.

Pięć osi

Każdy nowoczesny framework do trenowania rozproszonego składa pewien podzbiór tych samych pięciu osi równoległości. Nie są one alternatywami — przepisy na duże modele łączą trzy lub cztery naraz. Warto czytać kolumnę komunikacji; to w niej rozgrywa się cała gra.

Oś Co dzieli Komunikacja na krok Wymaga dużej przepustowości? Uwagi
Równoległość danych (DP) Batch — każdy rank ma pełny model All-reduce gradientów raz na krok Umiarkowana Punkt odniesienia; DDP i FSDP to oba DP
Równoległość tensorowa (TP) Mnożenie macierzy każdej warstwy rozłożone na GPU All-reduce na warstwę × 2 (attn + FFN) Bardzo duża Uwielbia NVLink; cierpi na PCIe
Równoległość potokowa (PP) Warstwy podzielone na etapy Aktywacje na granicy etapu Lekka Dodaje opóźnienie bąbla, podnosi przepustowość
Równoległość sekwencji/kontekstu (SP/CP) Wymiar sekwencji rozłożony na GPU Pierścieniowy all-gather KV / aktywacji Umiarkowana–duża Umożliwia trening na milionie tokenów
Równoległość ekspertów (EP) Eksperci MoE rozłożeni na GPU All-to-all na warstwę MoE Duża, skokowa Tylko MoE

DP krzyczy raz na krok. TP krzyczy dwa razy na warstwę. PP szepcze raz na etap. SP/CP krzyczy raz na blok uwagi, ale wzdłuż innego wymiaru. EP wykonuje all-to-all tylko na warstwach aktywnych MoE. Ta jedna kolumna decyduje, gdzie mieszka każda oś — wewnątrz szybkiej maszyny czy w poprzek wolniejszej sieci.

„Równoległość 3D”, która pojawia się w każdym blogu NVIDIA, to DP × TP × PP. Po dodaniu SP i EP staje się 4D lub 5D, co jest bardziej grą w notację niż zmianą architektoniczną. Liczy się układ: TP wewnątrz węzła (gdzie przepustowość jest tania), PP między węzłami (gdzie przepustowość jest droga), DP na wierzchu, aby skalować przepustowość. SP wchodzi obok TP; EP dotyczy wyłącznie MoE.

Odsyłacze: przepustowość wewnątrzwęzłowa dla równoległości tensorowej została rozłożona na czynniki pierwsze w K07, narzut NVLink kontra PCIe w N03, a sieć międzywęzłowa w N08.

DDP — gdy model się mieści i potrzebna jest tylko większa przepustowość

PyTorch DDP (DistributedDataParallel) to najstarsza, najprostsza i wciąż poprawna odpowiedź, gdy model mieści się na jednym GPU. Każdy rank przechowuje pełną kopię modelu i stanu optymalizatora. W każdym kroku każdy rank wykonuje własny przebieg w przód, przebieg wsteczny i obliczenie gradientów na własnym mikrobatchu. Następnie pojedyncze all-reduce sumuje gradienty pomiędzy rankami i wszystkie stosują tę samą aktualizację.

DDP w PyTorch 2.x to ten sam DDP co zawsze, z dwoma usprawnieniami wartymi odnotowania: solidniejszą ścieżką static_graph=True dla grafów przyjaznych kompilatorowi oraz ściślejszą integracją z torch.compile. Wzorzec komunikacji pozostaje bez zmian — jedno all-reduce na krok, nakładane na przebieg wsteczny, skalujące się liniowo, dopóki all-reduce nie zacznie dominować.

Kiedy DDP jest właściwą odpowiedzią:

  • Pełny model + stany optymalizatora + aktywacje mieszczą się na jednym GPU. Dla optymalizatorów typu Adam z wagami nadrzędnymi FP32 reguła kciuka mówi o mniej więcej 16 bajtach na parametr pamięci na sam stan trenowalny (4 bajty wagi, 4 bajty gradienty, 8 bajtów optymalizator) plus aktywacje. Model 8B = 128 GB stanu, co mieści się na jednym RTX Pro 6000 Blackwell (96 GB) wyłącznie przy mieszanej precyzji i wagach nadrzędnych BF16. Poniżej 8B parametrów DDP czuje się swobodnie na pojedynczym 5090; powyżej tej granicy warto spojrzeć na FSDP2.
  • Celem jest maksymalna przepustowość, a nie maksymalny rozmiar modelu. DDP ma najniższy stosunek komunikacji do obliczeń ze wszystkich podejść opartych na równoległości danych, ponieważ gradienty redukowane są raz na krok, po całej lokalnej pracy wstecznej.
  • Prowadzone są rollouty uczenia ze wzmocnieniem, trening LoRA lub dowolna konfiguracja, w której każdy rank przechowuje mały trenowalny adapter na zamrożonych wagach bazowych.

Kiedy DDP jest złym wyborem: gdy model się nie mieści. Rozwiązaniem nie jest „mniejszy batch”. Rozwiązaniem jest FSDP2.

torchrun --standalone --nproc-per-node=8 train.py

To cały launcher. DDP to nudne ustawienie domyślne, o którym wszyscy zapominają, a przy odpowiednim obciążeniu jest najszybszą rzeczą, jaką można uruchomić.

FSDP2 — nowy domyślny wybór na wszystko, czego DDP nie udźwignie

FSDP (Fully Sharded Data Parallel) dzieli parametry modelu, gradienty i stany optymalizatora pomiędzy grupę równoległości danych. Każdy GPU przechowuje 1/N parametrów. Aby wykonać przebieg w przód, rank zbiera operacją all-gather warstwę, której aktualnie potrzebuje, wykonuje obliczenia i odrzuca zebrane wagi. Zużycie pamięci spada mniej więcej N-krotnie w porównaniu z DDP; komunikacja rośnie, bo każda warstwa jest zbierana i zbierana ponownie.

Historią roku 2025 jest FSDP2. Pierwotny FSDP (FSDP1) pakował grupy parametrów w pojedynczy FlatParameter, co czyniło rozumowanie o zachowaniu poszczególnych parametrów — częściowym zamrażaniu, mieszanych typach, ustawieniach optymalizatora per parametr — bolesnym lub niemożliwym. FSDP2 przepisał wnętrze na bazie DTensor: każdy tensor pozostaje prawdziwym torch.Tensor, który jest po prostu podzielony wzdłuż wymiaru 0 pomiędzy ranki. Publiczne API zmieniło się z FSDP(model, ...) na fully_shard(model, ...).

Co FSDP2 faktycznie wnosi w stosunku do FSDP1, na podstawie opublikowanych benchmarków i naszych własnych uruchomień:

  • ~7% niższe zużycie pamięci GPU na Llama 2 7B przy tej samej konfiguracji, ponieważ FSDP2 unika wzorca record_stream, który pesymistycznie blokował pamięć.
  • ~1.5% wzrostu przepustowości przy parytecie, a nawet do 50% przyspieszenia przepustowości w połączeniu z torch.compile i torchao przy treningu float8 na sprzęcie klasy Hopper.
  • Dzielone state dicts, które ładują się szybko i czysto dzielą się na nowo pomiędzy różnymi układami równoległości — format checkpointów FSDP1 był słynnie trudny do przekształcenia pomiędzy treningiem a inferencją.
  • Częściowe zamrażanie parametrów bez akrobacji, co ma znaczenie przy treningu LoRA i adapterów.

FSDP1 jest wycofywany od PyTorch 2.11. Nowe prace powinny korzystać z fully_shard. Stary wrapper FullyShardedDataParallel nadal istnieje dla zgodności wstecznej, ale jest na ścieżce do usunięcia.

FSDP2 udostępnia także dwie strategie dzielenia, które decydują o tym, gdzie mieszka model:

  • Pełne dzielenie (full shard). Parametry w pełni podzielone pomiędzy wszystkie ranki (ustawienie domyślne w FSDP1). Najniższe zużycie pamięci, najwyższa komunikacja.
  • Dzielenie hybrydowe (hybrid shard). Parametry dzielone wewnątrz węzła i replikowane pomiędzy węzłami. Wewnątrz węzła komunikacja idzie po PCIe/NVLink (szybko). Pomiędzy węzłami wolną sieć przekracza wyłącznie all-reduce gradientów. To optymalny wybór dla 2–4 węzłów na Ethernecie/IB 100/200 Gbps.

Kiedy FSDP2 jest właściwą odpowiedzią (typowy przypadek Kentino):

  • Dostrajanie modeli 8B–70B na jednym węźle z 8 GPU. Pełne dzielenie, BF16, włączony gradient checkpointing, torch.compile. Gotowe.
  • Dostrajanie modeli 70B–405B na 2–4 węzłach. Dzielenie hybrydowe z pełnym dzieleniem wewnątrz każdego węzła i replikacją pomiędzy nimi.
  • Wszystko, co dotyczy LoRA / QLoRA — obsługa częściowych parametrów w FSDP2 bije tu FSDP1 na głowę.
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)

Uruchamiane tak samo jak DDP, przez torchrun. Zmienia się wyłącznie wrapper.

DeepSpeed i poziomy ZeRO — wciąż obecne, już nie domyślne

DeepSpeed to stos Microsoftu do trenowania rozproszonego. Zasłynął dzięki ZeRO (Zero Redundancy Optimizer), które pojawiło się lata przed FSDP i zdefiniowało nowoczesne podejście „dzielmy wszystko”.

Poziom Co jest dzielone Oszczędność pamięci vs DDP Komunikacja vs DDP
ZeRO-1 Stany optymalizatora ~4× Taka sama
ZeRO-2 Stany optymalizatora + gradienty ~8× Nieco większa
ZeRO-3 Stany optymalizatora + gradienty + parametry Liniowa względem N ~1.5× DDP

ZeRO-3 jest architektonicznie równoważny pełnemu dzieleniu w FSDP. Rozwiązują ten sam problem tymi samymi prymitywami komunikacyjnymi.

Rzeczywistość lat 2025–2026: FSDP2 zjadł DeepSpeedowi śniadanie w zastosowaniach z gęstymi modelami LLM. Natywny dla PyTorch, bez dodatkowego pakietu, zintegrowany z torch.compile, a ten sam przepis przenosi się pomiędzy Hugging Face Transformers, Accelerate i TorchTitan. Wewnętrzne benchmarki Lightning i Hugging Face pokazują, że pełne dzielenie FSDP działa 2–5× szybciej na iterację niż ZeRO-3 w części konfiguracji, choć DeepSpeed odrabia dystans na bardzo dużych modelach (10B+), gdzie jego ścieżki offloadu na CPU i NVMe pozostają naprawdę użyteczne.

DeepSpeed wciąż warto znać z trzech powodów:

  1. Offload ZeRO-Infinity. Jeśli trzeba dostroić model, który w ogóle nie mieści się w łącznej pamięci GPU — powiedzmy bazę 405B na maszynie z 4× RTX Pro 6000 Blackwell — DeepSpeed potrafi przenieść parametry do pamięci RAM procesora (tanio, wolno) i na NVMe (taniej, znacznie wolniej). FSDP również ma offload na CPU, ale ścieżka NVMe w DeepSpeed jest dojrzalsza. Przydatne w sytuacji „mam jedną maszynę i uparty model”; nie jest to właściwa odpowiedź, jeśli można wynająć lub kupić drugi węzeł.
  2. Równoległość sekwencji DeepSpeed-Ulysses. Efektywny komunikacyjnie schemat równoległości sekwencji, który w mechanizmie uwagi używa all-to-all zamiast pierścieniowego all-gather. Zademonstrowano konteksty do 1M tokenów na 64 kartach A100 oraz trening Llama-8B przy 15M tokenów kontekstu na 32 kartach H100 w opublikowanych pracach z 2025 roku. Przy pogoni za treningiem na bardzo długim kontekście Ulysses wciąż wyprzedza implementację równoległości kontekstu w Megatronie dla części kształtów.
  3. DeepSpeed-MoE. Trening mixture-of-experts z równoległością ekspertów. Mniej istotny przy dostrajaniu, bardzo istotny przy trenowaniu MoE od zera.

Dla większości prac dostrajających u klientów Kentino właściwym wyborem jest FSDP2, chyba że istnieje konkretny powód, by sięgnąć po DeepSpeed (długi kontekst, offload na CPU/NVMe, trenowanie MoE od zera). Dynamika ekosystemu jednoznacznie sprzyja FSDP2.

Megatron-LM, Megatron-Core, NeMo — tam, gdzie mieszka ciężki sprzęt

Megatron zaczął się od pracy NVIDIA o równoległości tensorowej w Transformerach z 2019 roku. Dziś rodzina ma trzy warstwy:

  • Megatron-LM — pierwotna baza kodu badawczego. Wciąż używana, wciąż aktualizowana.
  • Megatron-Core — wersja w postaci modularnej biblioteki. Składalne klocki do TP/PP/DP/EP/CP, mieszana precyzja (FP16/BF16/FP8/FP4) i referencyjne architektury transformerów. To właśnie tę warstwę się integruje.
  • NVIDIA NeMo — kompletny framework zbudowany na Megatron-Core. Przepisy, potoki danych, alignment, wdrożenia.

Megatron-Core to framework, który wygrywa na samym szczycie, właśnie dlatego, że implementuje równoległość tensorową, potokową, sekwencji, kontekstu i ekspertów w jednej składalnej siatce. Przy treningu gęstego modelu 405B na 512+ GPU nie da się uniknąć połączenia co najmniej trzech z nich, a Megatron-Core to najszerzej wdrożona i najlepiej przetestowana kombinacja.

Wytyczne Megatronu dotyczące równoległości na 2026 rok, pochodzące z własnej dokumentacji NVIDIA, pokrywają się z realiami sprzętowymi:

Sprzęt Zalecane osie główne
Pojedynczy węzeł, NVLink TP do 8 wewnątrz węzła
Wiele węzłów, InfiniBand NDR TP wewnątrz węzła, PP pomiędzy węzłami
Ograniczona sieć (Ethernet) Minimalizować TP, preferować PP pomiędzy węzłami
Długie sekwencje Dodać CP; włączyć SP wszędzie tam, gdzie działa TP

Ta tabela tłumaczy, po co istnieje Megatron. To framework, którego autorzy żyją z matematyką przepustowości opisaną w N03 i K07, a jego przepisy są pod nią dostrojone.

Gdzie Megatron to przesada: każde dostrajanie na jednym węźle, każdy model mieszczący się w pamięci przyjaznej FSDP2, każde obciążenie, przy którym TP nie jest potrzebne. Maszyneria TP w Megatronie jest faktycznie szybsza niż samodzielnie napisane TP na PCIe, ale TP na PCIe wciąż jest wolne — patrz liczby w K07. Siła Megatronu leży na sprzęcie SXM, którego Kentino nie buduje.

Gdzie Megatron jest właściwą odpowiedzią: trenowanie od zera gęstych modeli 70B–405B+ na wynajętym lub własnym sprzęcie klasy NVLink albo budowa produkcyjnej infrastruktury treningowej dla laboratorium badawczego. Kto tak pracuje, prawdopodobnie jest już w ekosystemie NeMo.

TorchTitan — nowy punkt odniesienia

TorchTitan to natywna dla PyTorch referencja Meta dla treningu na dużą skalę, przyjęta na ICLR 2025, a dziś faktyczny przykład odpowiedzi na pytanie „jak powinien wyglądać przepis TP × PP × FSDP2 × CP w 2026 roku?”. Nie wymyśla nowej równoległości — składa klocki, które PyTorch już dostarcza (fully_shard, torch.distributed.tensor.parallel, pipelining, DTensor) w czysty, czterowymiarowy skrypt treningu równoległego z asynchronicznym dzielonym checkpointingiem, torch.compile i float8.

Dlaczego ma znaczenie nawet wtedy, gdy nie używa się go bezpośrednio:

  • To kanoniczny przykład tego, jak FSDP2 składa się z TP i PP bez frameworka firm trzecich.
  • Te same API są w standardowym PyTorch. Nie ma w tym nic magicznego.
  • AMD wydało zoptymalizowany fork TorchTitan dla ROCm pod koniec 2025 roku; partnerstwo z Lightning AI ogłoszone w październiku 2025 roku pozwala uruchamiać przepisy TorchTitan na Lightning Studios.

Dla klientów klasy Kentino TorchTitan jest bardziej referencją do przeczytania niż frameworkiem do wdrożenia. Przy dostrajaniu Accelerate lub Axolotl na FSDP2 są wygodniejsze. Przy trenowaniu od zera w umiarkowanej skali (8–64 GPU) na zwykłym sprzęcie TorchTitan jest konkurencyjny wobec NeMo i znacznie lżejszy operacyjnie.

Macierz frameworków

Framework Osie równoległości Utrzymywany? Najlepszy do
PyTorch DDP DP Tak, stabilny Model mieści się na jednym GPU; maks. przepustowość
PyTorch FSDP1 DP (dzielony) Wycofany w 2.11 Nie zaczynać tutaj
PyTorch FSDP2 DP (dzielony), składa się z TP/PP/CP Tak, aktywny Typowa odpowiedź na dostrajanie w 2026
DeepSpeed ZeRO DP (dzielony), offload na CPU/NVMe Tak, aktywny Ciężki offload, bardzo długi kontekst (Ulysses), MoE
Megatron-Core / NeMo TP, PP, SP, CP, EP, DP Tak, bardzo aktywny Trenowanie od zera 70B+, klastry SXM/NVLink
TorchTitan FSDP2 + TP + PP + CP + float8 Tak, referencyjny Nowoczesne trenowanie od zera na stosie natywnym dla PyTorch
HF Accelerate Wrapper na DDP/FSDP/DS Tak, aktywny Łatwy launcher, abstrahuje backend
Axolotl Wrapper na Accelerate/FSDP Tak, aktywny Dostrajanie, zbiory danych, przepisy dla LoRA/QLoRA

Accelerate i Axolotl nie są osobnymi strategiami równoległości — opakowują powyższe backendy. Większość klientów Kentino dostrajających modele skończy na Axolotl nad FSDP2, nawet o tym nie myśląc, i to jest właściwe.

Budżet komunikacyjny — dlaczego to sieć ogranicza model

Odsyłacz: N08 omawia matematykę RDMA i uplinków; tutaj mamy spojrzenie właściwe dla treningu.

Przy równoległości danych (DDP lub FSDP) komunikacja międzyrankowa na krok jest z grubsza proporcjonalna do liczby parametrów (gradienty do zredukowania). Przy równoległości tensorowej jest proporcjonalna do rozmiaru aktywacji × liczby warstw — o rzędy wielkości więcej na krok.

Orientacyjna objętość gradientów dla pojedynczego kroku przy BF16:

Rozmiar modelu Bajty gradientów na krok Czas all-reduce przy 25 GB/s (klasa NDR HDR) Przy 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

Samo all-reduce dla 70B zajmuje 5.6 sekundy w sieci 200 Gbps. Jeśli obliczenia w przód i wstecz w jednym kroku również trwają 5 sekund, ograniczenie komunikacją sięga już 50%; jeśli obliczenia trwają 2 sekundy, ponad 70% czasu GPU czekają na sieć. Właśnie dlatego 100 GbE dławi trening modeli 70B+ i potrzebne jest 400 GbE / NDR IB. Obliczenia są coraz szybsze; sieć musi dotrzymywać im kroku, inaczej GPU stoją bezczynnie.

FSDP2 ukrywa część tego kosztu dzięki nakładaniu operacji (zbieranie kolejnej warstwy w trakcie obliczania bieżącej). Dzielenie hybrydowe ukrywa więcej, utrzymując all-reduce gradientów wewnątrz szybkiej sieci w obrębie węzła i redukując pomiędzy węzłami tylko gradienty replikowane. Powyższe liczby to najgorszy przypadek dla pełnego dzielenia FSDP pomiędzy węzłami bez nakładania operacji.

Przy równoległości tensorowej komunikacja na token skaluje się z rozmiarem ukrytym i liczbą warstw. Liczby w K07 pokazują dlaczego: ~80 MB na wygenerowany token podczas dekodowania, ~300 GB na prefill dla 70B przy batchu 32. To reżim, w którym PCIe (realnie 50 GB/s) jest około 14× wolniejsze niż NVLink (realnie 700+ GB/s) i w którym trenowanie od zera gęstego modelu 70B+ na PCIe po prostu nie działa przy akceptowalnej wydajności.

Konkretne przepisy

Dostrajanie Llama 8B, jeden węzeł z 8 GPU — FSDP2

Sprzęt: 8× RTX 5090 lub 8× RTX Pro 6000 Blackwell, host EPYC, sieć międzywęzłowa niepotrzebna.

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

Oczekiwane: ~2000 tok/s łącznie przy BF16, mieści się swobodnie wraz z KV i aktywacjami, a pełne dzielenie FSDP2 po PCIe Gen5 obsługuje all-reduce gradientów wewnątrz maszyny. Tak właśnie wygląda 90% zadań dostrajania u klientów Kentino.

Dostrajanie Llama 70B, 2× węzeł z 8 GPU — FSDP2 z dzieleniem hybrydowym

Sprzęt: 2× 8× RTX Pro 6000 Blackwell, 200 Gbps IB lub 100 GbE RoCE pomiędzy węzłami.

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

Dzielenie hybrydowe utrzymuje pełne dzielenie wewnątrz każdego węzła z 8 GPU i replikuje je pomiędzy 2 węzłami. Sieć międzywęzłowa przenosi tylko reduce-scatter replikowanych gradientów — około 70 GB na krok przy BF16, ~3 s na IB 200 Gbps. Nakładanie operacji ukrywa większość tego czasu. Przy 100 GbE ten sam krok kosztuje ~5–6 s i GPU zaczynają wykazywać bezczynność; przepis nadal działa, tylko epoka trwa dłużej.

Trenowanie od zera 405B, 8× węzeł z 8 GPU — Megatron-Core 3D

Sprzęt: 8× węzeł z 8 GPU NVLink/SXM, 400 Gbps NDR IB. Nie budowane przez Kentino — dla kompletności.

# 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 ranków na replikę; 8 nodes × 8 GPUs = 64 GPUs łącznie, czyli dokładnie jedna replika. Aby skalować do wielu replik dla wyższej przepustowości, należy przemnożyć przez DP. To właśnie tutaj Megatron zarabia na siebie. Ten sam model na samym FSDP2 spędziłby większość czasu na komunikacji międzyrankowej; układ 3D umieszcza najcięższą komunikację (TP) wewnątrz domeny NVLink.

Uczciwe spojrzenie dla klientów Kentino

Większość klientów Kentino nie trenuje modeli od zera. Dostrajają bazowe modele o otwartych wagach — Llama, Qwen, Mistral, czasem Gemma — na swoich danych dziedzinowych, czasem z LoRA lub QLoRA, czasem pełnym dostrajaniem. Dla takiej pracy wybór frameworka wygląda tak:

  • Model mieści się na jednym GPU przy BF16, razem ze stanem optymalizatora. Należy użyć DDP. Kopie replikuje się dla przepustowości.
  • Model nie mieści się na jednym GPU, ale mieści się łącznie na jednym węźle z 8 GPU. Należy użyć pełnego dzielenia FSDP2. To pokrywa dostrajanie modeli 8B–70B.
  • Model mieści się łącznie na dwóch węzłach z 8 GPU. Należy użyć dzielenia hybrydowego FSDP2. Dostrajanie modeli 70B–200B.
  • Model większy niż powyższe albo trenowanie od zera. To rozmowa, w której swoje miejsce mają Megatron-Core, sprzęt SXM i NDR IB. Zbudujemy warstwę pamięci masowej i zarządzania, ale GPU na tę fazę zwykle się wynajmuje.

Te 10% klientów, którzy naprawdę potrzebują ściśle sprzężonego treningu wielowęzłowego, to głównie laboratoria badawcze z finansowanymi programami trenowania od zera i wiedzą, czego potrzebują, zanim zadzwonią. Pozostałym 90% nie należy sprzedawać klastra — należy im sprzedać jeden dobrze dobrany węzeł z 8 GPU z właściwym zaczątkiem sieci pod przyszły drugi węzeł, a sprzęt sieciowy zostawić jako pozycję P2.

Co zrobić dalej

Przy wymiarowaniu zadania treningowego, zanim framework zostanie wybrany, warto przejść te kroki po kolei:

  1. Obliczyć pamięć na rank przy docelowej precyzji. Parametry × 2 (BF16) + gradienty × 2 + optymalizator × 8 (stany Adam FP32) + aktywacje. Jeśli to mieści się w pamięci VRAM karty z zapasem, odpowiedzią jest DDP.
  2. Jeśli pamięć nie wystarcza, zadać pytanie: jeden węzeł czy wiele? Jeden węzeł → pełne dzielenie FSDP2, koniec rozmowy. Wiele węzłów → dzielenie hybrydowe FSDP2.
  3. Wykonać kontrolę poprawności na jednym kroku. Warto obserwować czas all-reduce w NCCL_DEBUG=INFO. Jeśli dominuje on w kroku, sieć jest zbyt słaba dla tego modelu. Dwie opcje to mniejszy model albo szybsza sieć; strojenie frameworka tu nie pomoże.
  4. Po Megatron-Core lub DeepSpeed sięgać dopiero wtedy, gdy FSDP2 nie wystarcza. „Nie wystarcza” oznacza: potrzebna jest równoległość tensorowa dla modelu większego niż łączna pamięć węzła, potrzebny jest offload na CPU/NVMe, potrzebna jest równoległość sekwencji większa niż daje --context-parallel-size w PyTorch, albo trwa trenowanie MoE od zera.
  5. Do uruchamiania używać Axolotl lub Accelerate. Ręczne owijanie FSDP2 to ćwiczenie edukacyjne; w produkcji potrzebny jest framework, który obsłuży zbiór danych, tokenizer, format checkpointów i całą obsługę LoRA. Oba opierają się pod spodem na FSDP2.
  6. Checkpointy zapisywać przez torch.distributed.checkpoint (DCP) albo asynchroniczny dzielony checkpoint z NeMo. Synchroniczne, niedzielone checkpointy zapisywane na NFS to wzorzec z 2022 roku; w 2026 to samodzielnie zafundowane zatrzymanie treningu. Obsługę awarii, która się z tym wiąże, opisuje K06.
  7. Uczciwie ocenić rozmiar klastra, który jest naprawdę potrzebny. Jeśli zadanie wykonuje się na jednym węźle z 8 GPU w rozsądnym czasie, nie warto płacić za klaster czterowęzłowy, by na papierze było 2.5× szybciej. Matematyka skalowania w K07 pokazuje, dlaczego „więcej węzłów” przestaje pomagać bardzo wcześnie na zwykłym sprzęcie.

Artykuły towarzyszące: pamięć masowa i checkpointing w treningu rozproszonym w K04, klastrowanie inferencji w K03, obsługa awarii w K06, sufit przepustowości PCIe w K07, oraz kompromis NVLink kontra PCIe w N03. Matematyka sieciowa znajduje się w N08.


To część Kentino Wiki, serii referencyjnej o obliczeniach AI, robotyce i systemach, które je łączą. Komentarze i poprawki mile widziane pod adresem info@kentino.com.