Accelerate documentation
๐ค accelerate์ Context Parallel
๐ค accelerate์ Context Parallel
์ด ๊ฐ์ด๋์์๋ ๐คaccelerate์์ ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ์ ์ฌ์ฉํ๋ ๊ธฐ๋ณธ ์ฌํญ์ ๋ค๋ฃน๋๋ค. ๋ ์์ธํ ๋ด์ฉ์ ์๊ณ ์ถ์ ๋
์๋ฅผ ์ํด ํ๋ฐ๋ถ ์น์
์์๋ ์ผ๋ถ ๊ธฐ์ ์ ์ธ ์ฌํญ๋ ๋ค๋ฃน๋๋ค.
๋งค์ฐ ๊ด๋ จ์ด ์๋ Sequence Parallelism ๊ฐ์ด๋๋ ์ฐธ๊ณ ํ์ธ์.
์ ์ปจํ ์คํธ ๋ณ๋ ฌ์ฑ์ ์ฌ์ฉํด์ผ ํ๋์?
๋ํ ์ธ์ด ๋ชจ๋ธ, ๊ทธ๋ฆฌ๊ณ ์ต๊ทผ์๋ ์ถ๋ก ๋ชจ๋ธ์ ๋ฑ์ฅ์ผ๋ก ์ํ์ค ๊ธธ์ด๊ฐ ๋น ๋ฅด๊ฒ ์ฆ๊ฐํ๊ณ ์์ต๋๋ค. ์ฌ๊ธฐ์ attention์ 2์ฐจ ๋ฉ๋ชจ๋ฆฌ ๋ณต์ก๋๊ฐ ๋ํด์ง๋ฉด์, ๊ธด ์ํ์ค๋ก ๋ชจ๋ธ์ ํ์ตํ๋ ๋ ํจ์จ์ ์ธ ๋ฐฉ์์ ๋ํ ํ์์ฑ์ด ์ปค์ก์ต๋๋ค.
์ํ์ค ๊ธธ์ด๊ฐ 128k์ผ ๋, vanilla attention ๊ตฌํ์ ๊ฐ์ ํ๋ฉด bf16 ์ ๋ฐ๋์์ attention matrix์ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ๋์ 128k * 128k * 2 bytes * num_heads = ~32 GB * num_heads์
๋๋ค. ๋ฌผ๋ก , ์ด๋ฌํ attention ๊ฐ์ค์น๋ฅผ ๋ฌผ๋ฆฌ์ ์ผ๋ก ์์ฑํ์ง ์๋ flash attention๋ SDPA๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ํฌ๊ฒ ์ค์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ๋์ ์ฆ๊ฐ ํญ์ ์ฌ์ ํ ์๋นํฉ๋๋ค.
Context parallelism์ attention ๊ณ์ฐ์ ์ ๋ ฅ์ ์ํ์ค ์ฐจ์๋ณ๋ก ์ค๋ฉํ์ฌ ์ฌ๋ฌ GPU์์ attention์ ๋ณ๋ ฌ๋ก ๊ณ์ฐํ ์ ์๊ฒ ํฉ๋๋ค. ์ด๋ฅผ ํตํด ๊ธด ์ํ์ค๋ฅผ ๊ฐ์ง ๋ชจ๋ธ์ ํ์ตํ ์ ์์ผ๋ฉฐ, ์ ์ฌ์ ์ผ๋ก 1M ์ด์์ ์ํ์ค ๊ธธ์ด๊น์ง ํ์ฅํ ์ ์์ต๋๋ค.
์ปจํ ์คํธ ๋ณ๋ ฌ์ฑ(context parallelism)์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
from accelerate.utils import ParallelismConfig, TorchContextParallelConfig
+ cp_config = TorchContextParallelConfig(
+ cp_comm_strategy="alltoall", # no need to use cp_config at all, if you want to use the default "allgather"
+ )
+ parallelism_config = ParallelismConfig(
+ cp_size=8,
+ cp_handler=cp_config, # or just cp_size=8, if you want to use the default "allgather"
+ )
accelerator = Accelerator(
...,
parallelism_config=parallelism_config,
)๐คaccelerate์ ๋ค๋ฅธ ๋ชจ๋ ๊ธฐ๋ฅ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก, accelerate launch์ ํด๋น ํ๋๊ทธ๋ฅผ ์ ๋ฌํ์ฌ ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ๋ ํ์ฑํํ ์ ์์ต๋๋ค.
์ด ๊ฒฝ์ฐ์๋ ๋ค๋ฅด์ง ์์ต๋๋ค:
accelerate launch --parallelism-config-cp-size 8 --parallelism-config-cp-comm-strategy [allgather|alltoall] ...
accelerate config๋ช ๋ น์์cp_size์cp_comm_strategy๋ฅผ ์ค์ ํ ์๋ ์์ต๋๋ค. ์ด ๊ฐ๋ค์accelerate๊ตฌ์ฑ ํ์ผ์ ์ ์ฅ๋๋ฏ๋ก, ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ ๋๋ง๋ค ๋งค๋ฒ ์ ๋ฌํ ํ์๊ฐ ์์ต๋๋ค.
Context parallelism์ data parallelism, tensor parallelism, FSDP2์ ๊ฐ์ ๋ค๋ฅธ ๋ณ๋ ฌํ ์ ๋ต๊ณผ ํธํ๋ฉ๋๋ค.
--parallelism-config-dp-size 8 --parallelism-config-tp-size 2 --parallelism-config-cp-size 8์ฒ๋ผ ๋ณ๋ ฌํ ํฌ๊ธฐ๋ฅผ ์ํ๋ ๊ฐ์ผ๋ก ์ค์ ํ์ฌ ๊ฐ๋จํ ์กฐํฉํ ์ ์์ต๋๋ค. ๋๋ParallelismConfigํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก ์ค์ ํ ์๋ ์์ต๋๋ค.
Context parallelism์
FSDP2์ ๊ธด๋ฐํ๊ฒ ๊ฒฐํฉ๋์ด ์์ผ๋ฉฐ, FSDP2 ์๊ฐ์์ ์์ธํ ์์๋ณผ ์ ์์ต๋๋ค. ์ฆ, context parallelism์ ํ๋ก๊ทธ๋จ์FullyShardedDataParallelPlugin๋๋ ๋ฒ์ ์ด 2๋ก ์ค์ ๋--use-fsdp๋ฅผ ์ฌ์ฉํ ๋๋ง ์๋ํฉ๋๋ค.FSDP2๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
Context parallelism์ SDPA์์๋ง ์๋ํ๋ฉฐ, mask๋ causal mask๊ฐ ์๋ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ฅผ ์๋์ผ๋ก ์ ์ ํ๊ฒ ๊ฐ์งํ ์ ์์ผ๋ฏ๋ก, mask๋ causal mask ์์ด
SDPA๋ฅผ ์ฌ์ฉํ๊ณ ์๋์ง ํ์ธํ๋ ๊ฒ์ ์ฌ์ฉ์์ ์ฑ ์์ ๋๋ค. ๋ค๋ฅธ attention ๊ตฌํ์ ์ฌ์ฉํ๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
์์์ ์ธ๊ธํ ๋ฐฉ๋ฒ์ผ๋ก ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ์ ํ์ฑํํ ํ, ์ด๋ฅผ ํ์ต ๋ฃจํ์ ์ ์ฉํ ์ ์์ต๋๋ค. ํ์ต ๋ฃจํ์์ ์ฌ์ฉํ ์ ์๋ torch.distributed.tensor.experimental.context_parallel์ ์์ ๋ํผ๋ฅผ ์ ๊ณตํ๋ฉฐ, ์ด๋ ํด๋น ๊ธฐ๋ฅ ์ฌ์ฉ์ ์ผ๋ถ ๋ณต์ก์ฑ์ ์ถ์ํํฉ๋๋ค(์ดํ ์์ธํ ์ค๋ช
ํฉ๋๋ค). ํ์ต ๋ฃจํ์์ ์ํํด์ผ ํ๋ ๋ณ๊ฒฝ ์ฌํญ์ ์ต์ํํ๊ธฐ ์ํด, ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ์ด ๋นํ์ฑํ๋์ด ์์ผ๋ฉด noop์ผ๋ก ๋์ํ๊ณ ํ์ฑํ๋์ด ์์ผ๋ฉด ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ์ ์ ์ฉํ๋ ์ปจํ
์คํธ ๋งค๋์ ๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ด๋ฅผ ํตํด ๋ณ๋ ฌ ๊ตฌ์ฑ์ ๋ฐ๋ผ ์ฝ๋๋ฅผ ์์ ํ์ง ์๊ณ ๋ ํ์ต ๋ฃจํ์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์์ต๋๋ค:
for batch in dataloader:
with accelerator.maybe_context_parallel(
buffers=[batch["input_ids"], batch["attention_mask"]],
buffer_seq_dims=[1, 1],
no_restore_buffers={batch["input_ids"], batch["labels"]},
):
outputs = model(**batch)
...์ ์์์ ๊ฐ์ด ์ด ์ปจํ ์คํธ ๋งค๋์ ๋ ๊ฐ ํ์ต ๋จ๊ณ๋ง๋ค ๋ค์ ์์ฑ๋์ด์ผ ํฉ๋๋ค. ์ด๋ฅผ ์ํํ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํฉ๋๋ค.
์ด๋ฅผ ํตํด ์ปจํ ์คํธ ํฌ๊ธฐ๋ฅผ 1M+ ์ํ์ค ๊ธธ์ด๊น์ง ํ์ฅํ ์ ์์ต๋๋ค. ์๋์์๋ ์ต๋ 256k ์ปจํ ์คํธ ํฌ๊ธฐ์ ๋ํ ์ปจํ ์คํธ ๋ณ๋ ฌ์ฑ์ ์๋์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๋ณด์ฌ์ค๋๋ค. ์ปจํ ์คํธ ํฌ๊ธฐ์ GPU ์๋ฅผ 2๋ฐฐ๋ก ๋๋ฆฌ๋ฉด ์ผ๊ด๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ ์งํ ์ ์์ผ๋ฉฐ, ์ด๋ฅผ ํตํด ๋ฌดํํ ์ปจํ ์คํธ ๊ธธ์ด ํ์ฅ์ด ๊ฐ๋ฅํด์ง ์ ์์ต๋๋ค.
๊ทธ๋ฆผ 1: ์ต๋ 256k ์ปจํ
์คํธ ํฌ๊ธฐ์์์ ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋ฐ ์๋.
์ด ์์ ๋ค์ examples ํด๋์์ ์ฐพ์ ์ ์๋ ์คํฌ๋ฆฝํธ๋ก ์์ฑ๋์์ต๋๋ค. 8๊ฐ์ H100 GPU(128k ์ํ์ค ๊ธธ์ด)์์ ์์ ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์ ๋ช ๋ น์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
accelerate launch --use-fsdp --fsdp-activation-checkpointing=TRUE examples/torch_native_parallelism/nd_parallel.py --cp-size=8 --sequence-length=128000
Accelerate์ ์ธํฐํ์ด์ค
์ปจํ ์คํธ ๋งค๋์ ๋ ์ปจํ ์คํธ ๋ณ๋ ฌ์ฑ์ ๊ตฌ์ฑํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ช ๊ฐ์ง ์ธ์๋ฅผ ๋ฐ์ต๋๋ค.
buffers: ์ํ์ค ์ฐจ์์ ๊ฑธ์ณ ์ค๋ฉ๋ ํ ์ ๋ชฉ๋ก์ ๋๋ค. ์ด๋ฌํ ํ ์๋ ์ผ๋ฐ์ ์ผ๋ก input ids, labels, attention mask์ ๋๋ค.buffer_seq_dims:buffers๋ฆฌ์คํธ์ ์์๋๋ก ๊ฐ ๋ฒํผ์ ์ํ์ค ์ฐจ์์ ์ง์ ํ๋ ์ ์ ๋ฆฌ์คํธ์ ๋๋ค.buffers=[input_ids, shift_labels]๋ฅผ ์ ๋ฌํ๋, ๋ ํ ์์ shape๊ฐ ๋ชจ๋[batch_size, sequence_length]์ธ ๊ฒฝ์ฐ, ์ํ์ค ์ฐจ์์ด ํ ์์ ๋ ๋ฒ์งธ ์ฐจ์์ด๋ฏ๋กbuffer_seq_dims=[1, 1]์ ์ ๋ฌํด์ผ ํฉ๋๋ค. ์ด๋ ๋ชจ๋ธ ์ถ๋ ฅ์ ์ฌ๋ฐ๋ฅด๊ฒ ๊ณ์ฐํ๋ ๋ฐ ํ์ํฉ๋๋ค.no_restore_buffers: ์ปจํ ์คํธ ๋ณ๋ ฌ์ฑ ๊ตฌํ์ ๋ฒํผ๋ฅผ ์ธํ๋ ์ด์ค๋ก ์์ ํ์ฌtorch.distributed.tensor.Dtensor๋ก ๋ณํํฉ๋๋ค. ์ปจํ ์คํธ ๋งค๋์ ๋ฅผ ๋ฒ์ด๋๋ฉด ๋ฒํผ๋ฅผ ์๋ ์ํ๋ก ๋ณต์ํ๊ธฐ ์ํด ํต์ ์ปค๋(๋ณดํต all-gather)์ ์คํํด์ผ ํฉ๋๋ค. ์ด ๊ณผ์ ์ ์๊ฐ์ด ์์๋๋ฏ๋ก, ์ปจํ ์คํธ ๋งค๋์ ๋ฅผ ๋ฒ์ด๋ ํ ๋ฒํผ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ ํ์ ์ด ์๋ ํ ๋ถํ์ํ ํต์ ์ ํผํ๊ธฐ ์ํดbuffers์ธ์์ ๋์ผํ ํ ์๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ด ๊ถ์ฅ๋ฉ๋๋ค.
Context parallelism์ ๐ค transformers์ ๋ชจ๋ธ์ด ์์ฒด์ ์ผ๋ก ์ํํธํ์ฌ causal language modeling์ ํ์ฑํํ ์ ์๋
input_ids์ ๋ณต์ฌ๋ณธ์ธlabels์ ํธํ๋์ง ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด ๋ณด์ธ์: labels = [l1, l2, l3, l4, โฆ li] context parallelism์ ์ ์ฉํ๋ฉด ๊ฐ rank๊ฐ labels์ ์ผ๋ถ, ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ํํ๋ฅผ ๊ฐ๊ฒ ๋ฉ๋๋ค: labels_rank_0 = [l1, l2], labels_rank_1 = [l3, l4], โฆ transformers ๋ชจ๋ธ๋ง ์ฝ๋๊ฐ labels๋ฅผ ์ํํธํ ํ์๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋ฉ๋๋ค: labels_rank_0 = [l2, PAD], labels_rank_1 = [l3, PAD], โฆ ์ฌ๊ธฐ์PAD๋ padding token์ ๋๋ค. ์ด๋ก ์ธํด labels๊ฐ ๋ ์ด์ ์ ๋ ฅ๊ณผ ์ ๋ ฌ๋์ง ์์ ์๋ชป๋ loss ๊ณ์ฐ์ด ๋ฐ์ํฉ๋๋ค. ์ด ๋๋ฌธ์ ๋ชจ๋ธ์ ์ ๋ฌํ๊ธฐ ์ ์ labels๋ฅผ ์๋์ผ๋ก ์ํํธํด์ผ ํฉ๋๋ค.
๊ตฌ์ฑ ๊ฐ๋ฅํ ์ต์
Accelerate๋ cp_size๋ฅผ ์ ์ธํ๊ณ ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ์ ๊ตฌ์ฑํ๊ธฐ ์ํ ๋จ์ผ ์ต์
๋ง ์ ๊ณตํฉ๋๋ค
cp_comm_strategy: ์ค๋์์ ์ฌ์ฉํ ๋กํ ์ด์ ๋ฐฉ๋ฒ์ ๋๋ค. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ"alltoall"๋ณด๋ค"allgather"๊ฐ ๋ ๋์ ์ฑ๋ฅ์ ๋ผ ๊ฐ๋ฅ์ฑ์ด ๋งค์ฐ ๋์ผ๋ฏ๋ก, ์ด ๊ฐ์"allgather"๋ก ์ ์งํ๋ ๊ฒ์ ๊ฐ๋ ฅํ ๊ถ์ฅํฉ๋๋ค.
Context parallel size์ ์ด๋ฆ ๊ทธ๋๋ก, ์ ๋ ฅ์ด ์ค๋ฉ๋ rank์ ์๋ฅผ ์๋ฏธํฉ๋๋ค. Context parallel shard rotation์ ์ ๋ ฅ์ ์ค๋๊ฐ rank ๊ฐ์ ์ด๋ป๊ฒ ํ์ ๋๋์ง๋ฅผ ์ ์ํฉ๋๋ค. ๋ค์ ์น์ ์์ ๋ ๊ฐ์ง ์ต์ ์ ์์ธํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
ND parallel example ํ์ผ์์ 8xH100 ๋ ธ๋ 1๋์์ ์ต๋ 128k ์ปจํ ์คํธ ๊ธธ์ด๋ฅผ ๊ฐ์ง 8B ๋ชจ๋ธ์ ํ์ตํ๋ ๋์์ ๋(end-to-end) ์์๋ฅผ ํ์ธํ ์ ์์ต๋๋ค. ๋ฉํฐ ๋ ธ๋ ํ์ต์ ์ฌ์ฉํ๋ฉด ์ฌ๋ฌ GPU์์ ์ํ์ค ๊ธธ์ด๋ฅผ 1M ์ด์์ผ๋ก ํ์ฅํ ์ ์์ต๋๋ค. ๋ํ ํ์์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ณ๋ ฌํ ์ ๋ต๊ณผ๋ ์ํํ๊ฒ ๊ฒฐํฉํ ์ ์์ต๋๋ค.
๊ธฐ์ ์ ์ธ๋ถ ์ฌํญ
์ด ์น์ ์ ์๋นํ ๊ธฐ์ ์ ์ธ ๋ด์ฉ์ ๋๋ค. ์ปจํ ์คํธ ๋ณ๋ ฌ์ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ํ์ตํ ํ์๊ฐ ์๋ค๋ฉด ๊ฑด๋๋ฐ๊ณ ๋ฐ๋ก ๊ตฌ์ถ์ ์์ํ์ธ์ ๐
๋ค์ ์น์
์์ shard๋ผ๋ ์ฉ์ด๋ฅผ ๊ด๋ฒ์ํ๊ฒ ์ฌ์ฉํ ์์ ์ด๋ฏ๋ก, ๋จผ์ ์ ์ํ๊ฒ ์ต๋๋ค. ํ
์๋ฅผ Dth ์ฐจ์์ ๋ฐ๋ผ N๊ฐ์ rank์ ๊ฑธ์ณ sharded๋ผ๊ณ ๋ถ๋ฅผ ๋, ์ด๋ ํด๋น ํ
์๊ฐ N๊ฐ์ ๋ถ๋ถ์ผ๋ก ๋๋์ด ์์ผ๋ฉฐ ๊ฐ ๋ถ๋ถ์ shape์ด [..., D//N, ...]์์ ์๋ฏธํฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ์๋ํ๋์?
Context parallelism์ Q, K and V ํ๋ ฌ์ ์ํ์ค ์ฐจ์๋ณ๋ก ์ค๋ฉํ๋ ๋ฐฉ์์ผ๋ก ๋์ํฉ๋๋ค. ๊ฐ ๋ญํฌ์๋ ํ ๋น๋ Q์ ์ค๋๊ฐ ์์ผ๋ฉฐ, ์ด๋ฅผ Q_i๋ผ๊ณ ๋ถ๋ฅด๊ฒ ์ต๋๋ค. ์ด ํ๋ ฌ์ ์ ์ฒด ๊ณ์ฐ ๊ณผ์ ๋์ ํด๋น ๋ญํฌ์๋ง ์ ์ง๋ฉ๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก, ๊ฐ ๋ญํฌ์๋ K์ V์ ์์ฒด ์ค๋๊ฐ ์์ผ๋ฉฐ, ์ด๋ฅผ ๊ฐ๊ฐ K_i์ V_i๋ผ๊ณ ๋ถ๋ฅด๊ฒ ์ต๋๋ค. ๊ทธ๋ฐ ๋ค์, ๊ฐ ๋ญํฌ๋ ์์ ์ Q_i, K_i, V_i ์ค๋๋ฅผ ์ฌ์ฉํ์ฌ attention์ ๊ณ์ฐํ๋ฉฐ, ์ด๋ฅผ attn_i๋ผ๊ณ ๋ถ๋ฅด๊ฒ ์ต๋๋ค. ์ด ๊ณ์ฐ ์ค์ ๋ค๋ฅธ ๋ชจ๋ ๋ญํฌ์์ Ks์ Vs๋ฅผ ์์งํ๊ธฐ ์ํ ํต์ ์ปค๋์ด ์คํ๋ฉ๋๋ค. ์ฌ์ฉ๋๋ ํต์ ์์(primitive)๋ context_parallel_shard_rotation ์ต์
์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค.
์ด ๋ฐฉ์์ ํตํด ๊ฐ ๋ญํฌ๋ ๋จผ์ Q_i, K_i, V_i๋ฅผ ์ฌ์ฉํ์ฌ, ๊ทธ ๋ค์์๋ ๋ค๋ฅธ ๋ชจ๋ ๋ญํฌ์ K_j์ V_j๋ฅผ ์ฌ์ฉํ์ฌ ๋ก์ปฌ attention์ ๊ณ์ฐํ๊ฒ ๋ฉ๋๋ค. ๊ฐ ๋ญํฌ๊ฐ ์ํ์ค ์ฐจ์๋ณ๋ก ์ค๋ฉ๋ Q, K and V ํ๋ ฌ์ ๋ณด์ ํ๋ฏ๋ก, ๊ฒฐ๊ณผ ํ๋ ฌ์ ํฌ๊ธฐ๊ฐ ์์์ ธ ๋จ์ผ GPU์ ์ ์ฌํ ์ ์์ต๋๋ค.
๋ค์ ์์ฌ ์ฝ๋๋ก ์ด๋ฅผ ๊ณต์ํํ ์ ์์ต๋๋ค:
comm_kernel = {"allgather": allgather, "alltoall": alltoall}[context_parallel_shard_rotation]
Qi, Ki, Vi = shard(Q, K, V, seq_dim)
attn[i] = attn(Qi, Ki, Vi)
for j in range(context_parallel_size):
Kj, Vj = comm_kernel()
attn[j] = attn(Qi, Kj, Vj) # [batch, num_heads, seq_len // context_parallel_size, head_dim]
final_attn = combine(attn)all-to-all๊ณผ all-gather
all-gather
all-to-all๊ณผ all-gather์ ์ฐจ์ด๋ ๋ฌด์์ผ๊น์? all-gather์ ๊ฒฝ์ฐ ํต์ ์ด ๋งค์ฐ ๋จ์ํฉ๋๋ค. (๋ณดํต ๋ ์ค๋ ๊ฑธ๋ฆฌ๋ฏ๋ก) ์ค์ ๋ก๋ ๊ณ์ฐ ์ ์, ๋ก์ปฌ ์ดํ
์
attn_i์ ๊ณ์ฐํ ํ all-gather๋ฅผ ์์ํ์ฌ ๋ค๋ฅธ ๋ชจ๋ rank์ Ks์ Vs๋ฅผ ์์งํฉ๋๋ค. ์ด ํต์ ์ด ์๋ฃ๋๋ฉด ๊ฐ rank๋ ๋ค๋ฅธ ๋ชจ๋ rank์ Ks์ Vs๋ฅผ ๋ชจ๋ ๋ณด์ ํ๊ฒ ๋๋ฉฐ, ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์์ฐจ์ ์ผ๋ก ์ดํ
์
์ ๊ณ์ฐํ ์ ์์ต๋๋ค.
์ด์์ ์ธ ์๋๋ฆฌ์ค์์๋ attn_i์ ๊ณ์ฐ์ด ์๋ฃ๋๋ ์ ํํ ์๊ฐ์ all-gather๊ฐ ๋๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ์ค์ ๋ก๋ ์ด๋ฐ ์ผ์ด ์ผ์ด๋์ง ์์ผ๋ฏ๋ก, attn_i ์ ์ฒด๊ฐ ํต์ ์ ์ผ๋ถ์ ์ค๋ฒ๋ฉ๋๊ณ , K_j์ V_j๋ฅผ ์ฌ์ฉํ ๊ณ์ฐ์ ์์ํ๊ธฐ ์ํด all-gather๊ฐ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ๊ฒ์ด ์ด์์ ์ธ ์ค์ ์ค๋ฒ๋ฉ์
๋๋ค.
all-to-all
All-to-all, or sometimes called ring-rotation utilizes a ring-like communication pattern. After concluding attn_i computation, an all-to-all is launched to send K_i and V_i to the neighbouring ranks. We then repeat this context_parallel_size-1 times, so that each rank sees all the shards of K and V from all other ranks once. In ideal scenario, we prefetch shards K_i+1 and V_i+1 from the neighbouring rank and this communication is exactly overlapped with computation of our current attn_i. Again, realistically, this perfect overlap doesnโt ever happen. Given the nature of this approach, if we donโt achieve perfect overlap, the penalty is way larger than with all-gather.
์ด๋ค ํ์ ๋ฐฉ๋ฒ์ ์ ํํด์ผ ํ ๊น์?
In theory, all-to-all should be the better choice. Though in practice, it rarely is. Therefore, we default to all-gather, as itโs more likely to achieve better performance. Extensive benchmarks from the torchtitan team also show that all-to-all rarely outperforms all-gather. Though, we still provide both options, as you might find one to be better for your use case.
์๋ ์ด๋ฏธ์ง์ ํ๋กํ์ผ๋ฌ ์ถ๋ ฅ์์ ์ด ๋ฌธ์ ๋ฅผ ์ง์ ํ์ธํ ์ ์์ต๋๋ค:
Figure 1: In red you can see the idle time, while we wait for the all-to-all kernel to finish. Highlighted in the first blue bar, you can see that it takes ~250us to finish, which is repeated N-1 times for each attention call, where N is the context parallel size.
์ FSDP2๋ง ์ฌ์ฉํ ๊น์?
FSDP2์ ํจ๊ป ์ปจํ
์คํธ ๋ณ๋ ฌ์ฑ๋ง ์ง์ํฉ๋๋ค. context_parallel_size์ dp_shard_size์ ๊ฒฐํฉ๋ ๋ฉ์๋ฅผ ์์ฑํ์ฌ ๊ทธ ์ ์ฌ๋ ฅ์ ์ต๋ํ ํ์ฉํ๊ธฐ ๋๋ฌธ์
๋๋ค.
๋์ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. cp_size*dp_shard_size ํฌ๊ธฐ์ ๊ฒฐํฉ๋ ๋ฉ์์ ๊ฑธ์ณ ๋ชจ๋ธ์ ์ค๋ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ ํจ๊ณผ๋ฅผ ๊ทน๋ํํฉ๋๋ค.
์๋ ์ด๋ฏธ์ง์ ํ์๋ ๋ฐ์ ๊ฐ์ด FSDP ํต์ ์ด ์ดํ
์
๊ณ์ฐ๊ณผ ์์ ํ ์ค๋ฒ๋ฉ๋๋ฏ๋ก, ์ผ์ข
์ '๋ฌด์ ํํ'์ด๋ผ๊ณ ํ ์ ์์ต๋๋ค.
๊ทธ๋ฆผ 2: ํ๋์ ์ฌ๊ฐํ(Stream 23)์์ `FSDP ์ค๋์ ํ๋ฆฌํ์น๊ฐ ์ดํ
์
๊ณ์ฐ(Stream 7)๊ณผ ์์ ํ ๊ฒน์ณ ์๋ ๊ฒ์ ๋ณผ ์ ์์ผ๋ฉฐ, ๋นจ๊ฐ์ ์ฌ๊ฐํ(Stream 24)์์๋ ์ฌ๊ฐ๋ ์ปค๋๋ก ์ธํด ์ ํด ์๊ฐ ๋ฒ๋ธ์ด ๋ฐ์ํ์ฌ ๊ณ์ฐ ์คํธ๋ฆผ(7)์ด ์ ํด ์ํ๊ฐ ๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
In the figure above, you can also note the difference between all-to-all and all-gather. While in all-to-all (Figure 1), we launch a communication kernel N-1 times for each attention call, in all-gather (Figure 2), we launch a communication kernel only once. This results in a bigger bubble, but it only happens once per attention call, while in all-to-all, it happens N-1 times.
์กฐ์ธํธ ๋ฉ์์์์ ๋ฐ์ดํฐ ๋์คํจ์นญ
cp ์๋ธ๊ทธ๋ฃน ์ ์ฒด์ ๋์ผํ ๋ฐ์ดํฐ ๋ฐฐ์น๋ก ๋์คํจ์นํ์ฌ ๊ฒฐ๊ณผ๊ฐ ์ ํํ๋๋ก ๋ณด์ฅํฉ๋๋ค. (์ฆ, cp ์๋ธ๊ทธ๋ฃน์ ๊ฐ ๋ญํฌ๋ ๋์ผํ ๋ฐ์ดํฐ ๋ฐฐ์น๋ฅผ ๋ฐ์ต๋๋ค.) ํ์ง๋ง dp_shard ๊ทธ๋ฃน์ ๊ฐ ๋ญํฌ์๋ ์๋ก ๋ค๋ฅธ ๋ฐฐ์น๋ฅผ ๋์คํจ์นํฉ๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์๊ฐํ ์ ์์ต๋๋ค:
# 8 GPUS, --dp_shard_size 4, --cp_size 2
# mesh = [[0, 1], [2, 3], [4, 5], [6, 7]]
# model is sharded across the whole mesh (each GPU holds 1/8 of the model)
# GPUs 0,1 = batch 0
# GPUs 2,3 = batch 1
... and so on.