# 전문가 병렬

[Expert parallelism](https://huggingface.co/spaces/nanotron/ultrascale-playbook?section=expert_parallelism)은 [mixture-of-experts (MoE) 모델](https://huggingface.co/blog/moe)에 적용되는 병렬화 전략입니다. 각 expert의 feedforward 레이어는 서로 다른 하드웨어 가속기에 배치됩니다. 라우터가 토큰을 적절한 expert로 전달하고 결과를 수집합니다. 이 방식은 각 토큰이 소수의 expert만 활성화하기 때문에, 계산 비용 증가 없이 모델의 매개변수 수를 훨씬 더 크게 확장할 수 있습니다.

## DistributedConfig

[DistributedConfig](/docs/transformers/v5.23.0/ko/expert_parallelism#transformers.DistributedConfig) 클래스와 `ep_size` 인수를 사용하여 전문가 병렬화를 활성화합니다. MoE 모델은 `"ep_dispatch_experts"`로 전문가를 샤딩합니다. 해당 구현은 토큰이 전문가에 도달하는 방식을 결정합니다. [Token dispatch](#token-dispatch)는 `ep_size`가 `tp_size`와 다를 수 있도록 합니다. 일부 EP 구현은 `ep_size=tp_size`를 요구하며, 예를 들어 `"all_reduce"`와 `"deepgemm_megamoe"`가 해당됩니다. 이를 통해 전문가 그룹의 모든 랭크가 동일한 토큰을 보유합니다.

Llama 4에는 EP 계획이 없습니다. 그 전문가들은 라우터 점수로 이미 스케일링된 모든 토큰을 처리하므로 디스패치할 것이 없습니다. 대신 텐서 병렬(`tp_size`)로 샤딩하세요.
```py
import os

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.distributed.configuration_utils import DistributedConfig

distributed_config = DistributedConfig(
    tp_size=int(os.environ["WORLD_SIZE"]),
    ep_size=int(os.environ["WORLD_SIZE"]),
)

model = AutoModelForCausalLM.from_pretrained(
    "openai/gpt-oss-120b",
    distributed_config=distributed_config,
)
```

각 MoE 모델은 config에서 두 가지 플랜을 정의합니다: dense 모듈을 위한 `base_model_tp_plan`과 experts를 위한 `base_model_ep_plan`입니다. 이들은 로드된 모델에서 `model.tp_plan`과 `model.ep_plan`으로 노출됩니다. `tp_size > 1`이고 `ep_size > 1`인 경우, 두 플랜이 모두 적용됩니다: [tensor parallel](./perf_infer_gpu_multi) 플랜은 attention과 dense MLP를 샤딩하고, expert parallel 플랜은 experts를 샤딩합니다. 동일한 모듈에 대해 EP 규칙이 TP 규칙보다 우선하므로, expert 가중치는 EP 플랜에 의해 한 번만 샤딩됩니다. EP 플랜에서 `GroupedGemmParallel` 스타일은 expert 가중치를 expert 차원 방향으로 분할하여 각 rank가 자신의 로컬 experts만 로드하도록 하고, experts 모듈의 `"ep_dispatch_experts"` 규칙은 토큰이 experts에 도달하는 방식을 선택합니다.

`tp_plan`은 `tp_size > 1`인 경우에만 적용되며, `ep_plan`은 `ep_size > 1`인 경우에만 적용됩니다. TP가 활성화되고 EP가 비활성화된 상태에서는 전문가 규칙을 포함하여 전체 TP 플랜이 적용됩니다.

`"ep_dispatch_experts"`는 랭크별로 전체 expert를 샤딩합니다(`ep_size`는 `tp_size`의 배수이면서 `fsdp_size * tp_size`를 나누는 값). expert에 대한 접근은 `ep_implementation`이 지정한 구현을 통해 이루어지며, [구현 선택](#choosing-an-implementation)을 참고하세요.

### 구현 선택

`"ep_dispatch_experts"`는 전문가를 한 번만 샤딩하고, [DistributedConfig](/docs/transformers/v5.23.0/ko/expert_parallelism#transformers.DistributedConfig)의 `ep_implementation`로 선택된 `EPImplementationInterface`에 등록된 구현체에서 토큰이 전문가에 도달하는 방식을 결정합니다:

| `ep_implementation` | 장점 | 단점 |
| :--- | :--- | :--- |
| `"all_to_all"`, [토큰 디스패치](#token-dispatch)를 참조 | `ep_size > tp_size`를 포함한 모든 레이아웃에서 작동합니다. 라우팅된 토큰만 이동합니다. | 레이어당 all-to-all 집합 연산 2회와 호스트 동기화 1회가 발생하므로 CUDA graph로 캡처되지 않습니다. |
| `"all_reduce"` | 토큰 이동이 없고 호스트 동기화도 없으므로, 디코드는 CUDA 그래프에서 캡처됩니다. | `ep_size=tp_size`가 필요합니다. 모든 rank가 전체 배치에 대해 자신의 expert를 실행하므로, 비용이 배치 크기에 따라 증가합니다. |
| `"deepgemm_megamoe"` | DeepGEMM Mega MoE는 dispatch, experts, combine를 하나의 커널로 통합합니다. EP 그룹의 모든 레이어는 대칭 메모리 버퍼를 공유합니다. | `ep_size=tp_size`가 필요하며, SM100+에서 FP8 활성화와 FP4 전문가를 사용합니다. 추론 전용입니다. |
| 기본값인 `"auto"` | `"all_reduce"`는 expert group의 rank들이 하나의 batch를 공유할 때 추론 시에 실행되고, 그렇지 않은 경우에는 `"all_to_all"`이 실행됩니다. | 항상 가장 빠른 선택지는 아닙니다: 워크로드가 [구현 추가](#adding-an-implementation)를 통해 커스텀 구현의 이점을 얻을 수 있습니다. |

> [!NOTE]
> `ep_implementation`은 [DistributedConfig](/docs/transformers/v5.23.0/ko/expert_parallelism#transformers.DistributedConfig)에 설정된 병렬 크기 내에서만 선택합니다. 전문가 그룹의 랭크가 서로 다른 배치(예: `tp_size=1`이고 `fsdp_size=ep_size`인 경우)를 보유할 때, `"all_to_all"`가 적용되는 유일한 구현입니다.

### 구현 추가

구현은 `EPImplementation`을 서브클래스로 상속하고 `ep_implementation` 이름으로 등록하여 선택됩니다. 이는 experts 모듈마다 한 번만 생성되므로, 통신 버퍼와 같은 상태를 유지할 수 있습니다. 이 rank가 보유한 배치와 전역 expert id를 인수로 호출하면, 각 토큰에 대한 가중 expert 출력을 반환합니다. 이 rank의 experts를 `experts_forward`로 실행하며, 가져온 행, 로컬 expert id 및 가중치를 사용합니다.

```py
from transformers.distributed.expert_parallel import EPImplementation, EPImplementationInterface

class MyEP(EPImplementation):
    def __call__(self, hidden_states, top_k_index, top_k_weights):
        tokens, expert_ids, weights = ...  # bring this rank's experts the rows routed to them
        expert_output = self.experts_forward(tokens, expert_ids, weights)
        return ...  # the weighted expert output for each token of the batch this rank holds

EPImplementationInterface.register("my_ep", MyEP)
distributed_config = DistributedConfig(tp_size=1, fsdp_size=8, ep_size=8, ep_implementation="my_ep")
```

> [!NOTE]
> Gradient가 토큰을 보유하는 모든 rank에 도달해야 하며, 라우팅 가중치도 포함됩니다. 따라서 autograd가 미분하지 않는 collective을 `torch.autograd.Function`으로 감싸야 합니다.

> [!TIP]
> `ep_size` 없이 `enable_expert_parallel=True`를 사용하는 것은 비추천되며 `FutureWarning`를 출력합니다. `ep_size=tp_size, tp_plan={}`와 마찬가지로 전문가만 샤딩합니다.

[torchrun](https://pytorch.org/docs/stable/elastic/run.html)로 추론 스크립트를 실행합니다. 프로세스 수는 `tp_size * fsdp_size * pp_size`와 같아야 하며, `ep_size`는 전문가 수를 나누어 떨어뜨려야 합니다.

```zsh
torchrun --nproc-per-node 8 your_script.py
```

### 플랜 오버라이드

`tp_plan={...}` 또는 `ep_plan={...}`을 [DistributedConfig](/docs/transformers/v5.23.0/ko/expert_parallelism#transformers.DistributedConfig)에 전달하여 사전 정의된 플랜의 개별 규칙을 재정의할 수 있습니다. 지정되지 않은 규칙은 유지되며, 병합된 플랜은 모델에 저장됩니다. 각 키는 모듈, 매개변수 또는 기존 플랜 항목과 일치해야 하며, 그렇지 않으면 샤딩이 시작되기 전에 `ValueError`가 발생합니다. 로드된 모델에서 확인되는 전체 경로를 사용해야 하므로, causal LM의 경우 `model.layers.*`, 해당 base model의 경우 `layers.*`를 사용합니다.

```py
distributed_config = DistributedConfig(
    tp_size=4,
    ep_size=4,
    tp_plan={"model.layers.*.self_attn.q_proj": "colwise_rep"},
    ep_plan={"model.layers.*.mlp.experts.down_proj": "grouped_gemm"},
)
```

플랜을 제공해도 병렬 크기를 추론하지 않습니다: `tp_size`와 `ep_size`를 명시적으로 설정하세요.

`ep_size=tp_size`인 경우, 기본 `"auto"` 구현은 추론 시 `"all_reduce"`를 실행하고 학습 시 토큰을 분배합니다. 학습 시에도 마스크를 적용하고 all-reduce를 실행하려면 `ep_implementation="all_reduce"`를 설정하세요:

```py
distributed_config = DistributedConfig(tp_size=4, ep_size=4, ep_implementation="all_reduce")
```

## 토큰 디스패치

Token dispatch는 `"all_to_all"` 구현입니다. 각 rank는 배치의 자기 몫으로만 학습합니다. 모든 MoE 레이어에서, rank는 자신의 토큰을 라우팅하고, 각 (토큰, expert) 쌍을 해당 expert를 소유한 rank로 all-to-all을 통해 전송한 후, 수신한 데이터에 대해 로컬 expert를 실행합니다. 이후 두 번째 all-to-all로 결과를 받아와 라우팅 가중치와 결합합니다. 라우팅된 activations와 expert 출력만 전송되며, 어떤 rank도 자신이 소유하지 않은 토큰에 대해 expert를 계산하지 않습니다.

```py
from transformers import AutoModelForCausalLM
from transformers.distributed import DistributedConfig

distributed_config = DistributedConfig(
    tp_size=1,
    fsdp_size=8,
    ep_size=4,
)
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-30B-A3B", distributed_config=distributed_config)
```

`tp_size=1`인 경우, `ep_size`는 `fsdp_size`와 전문가 수를 나누어야 하며, 어텐션은 `num_key_value_heads`에 의해 제한되지 않습니다. 모델의 나머지 부분에 대해:

- experts 외부의 파라미터는 `fsdp`에 걸쳐 [FSDP2](./fsdp)로 샤딩되며, 이를 통해 그라디언트가 감소합니다.
- 전문가들은 `ep`에 걸쳐 샤드되며, `efsdp_size = fsdp_size * tp_size // ep_size`가 1보다 클 경우 `efsdp`에 걸쳐 추가로 FSDP 샤딩됩니다. 이들은 항상 FSDP로 래핑되므로 `fsdp_mixed_precision`와 `fsdp_cpu_offload`도 적용되며, [save_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.save_pretrained)는 다른 매개변수와 마찬가지로 이들을 수집합니다.
- Expert parallel 그룹은 `ep_size / tp_size`개의 배치로 구성되므로, 각 expert의 그래디언트는 해당 수만큼의 배치에 대한 합입니다. `efsdp` 리덕션은 그룹 크기 대신 `fsdp_size`로 나누며, 이는 FSDP2가 dense 모듈에 대해 사용하는 배치당 평균과 동일한 값을 제공합니다.
- 각 로컬 전문가(expert)는 레이어당 하나의 제로 패딩(zero pad) 행을 처리합니다. 토큰을 받지 못한 전문가를 가진 랭크(rank)도 reverse all-to-all 및 전문가(expert) 그래디언트 감소(reduction)에 참여합니다.

### 크기가 결합되는 방식

- `tp_size * fsdp_size`는 프로세스 수입니다. `ep_size`는 아무것도 추가하지 않습니다: 전문가 가중치에 대해서만 동일한 랭크를 다시 그룹화합니다.
- `ep_size`는 expert 목록을 `ep_size`개의 블록으로 나눕니다. 각 rank는 `num_experts / ep_size`개의 expert를 계산하며, `ep_size`개의 연속된 rank가 하나의 완전한 expert 세트를 보유합니다. 이 rank의 집합은 all-to-all이 실행되는 그룹입니다.
- `efsdp_size = fsdp_size * tp_size / ep_size`는 expert set의 완전한 사본이 몇 개 존재하는지를 나타냅니다. 서로 다른 사본에서 동일한 위치에 있는 rank들은 FSDP가 dense 모듈에 대해 수행하는 방식과 유사하게, 메모리를 위해 해당 expert를 샤딩하고 그라디언트를 평균화합니다.
- 랭크가 보유하는 배치의 구성은 `fsdp`에만 의존합니다. 연속된 랭크들은 TP 그룹을 형성하며 동일한 배치를 받습니다. `fsdp_size`개의 그룹은 서로 다른 배치를 받습니다.

8개의 프로세스, `tp_size=2, fsdp_size=4`, 8개의 전문가:

```text
rank         0      1       2      3       4      5       6      7
batch       [====B0====]   [====B1====]   [====B2====]   [====B3====]     one batch per TP pair
tp           0      1       0      1       0      1       0      1

ep_size=2   E0-3   E4-7    E0-3   E4-7    E0-3   E4-7    E0-3   E4-7     group = a TP pair,   efsdp_size=4
ep_size=4   E0E1   E2E3    E4E5   E6E7    E0E1   E2E3    E4E5   E6E7     group = two pairs,   efsdp_size=2
ep_size=8   E0     E1      E2     E3      E4     E5      E6     E7       group = all ranks,   efsdp_size=1
```

그림에서 두 가지 수치가 도출됩니다:

- EP 그룹 내에서 각 토큰은 해당 배치 보유 쌍의 각 랭크마다 한 번씩, 총 `tp_size`번 존재합니다. 이는 `ep_size`에 의존하지 않습니다.
- EP 그룹은 `ep_size / tp_size`개의 서로 다른 배치(batch)를 보유합니다. 이는 각 expert의 그래디언트가 합산되는 대상의 개수입니다.

### 텐서 병렬성

`tp_size > 1`을 설정하면 TP 플랜에 따라 dense 모듈을 샤딩하고, experts는 dispatch를 사용합니다. 8개 프로세스에서:

```py
distributed_config = DistributedConfig(
    tp_size=2,
    fsdp_size=4,
    ep_size=4,
)
```

TP rank의 각 쌍은 동일한 배치(bach)를 수신합니다. 이는 텐서 병렬성이 해당 쌍 내부에서 활성화(activation)를 복제하기 때문입니다. 두 rank가 모두 토큰을 전부 디스패치(dispatch)한 경우, 특정 expert를 소유한 rank는 모든 토큰을 두 번 수신하고 두 번 계산하게 되며, 그 가중치 그래디언트가 두 배가 됩니다. expert는 하나의 rank에 온전히 존재하므로 가중치로 중복을 분할할 수 없으며, 소유자는 보통 다른 rank이므로 masking처럼 소유권으로 해결할 수도 없습니다. 따라서 해당 쌍은 행(row)을 분할합니다. 각 TP rank는 토큰의 서로 겹치지 않는 `1 / tp_size`만 디스패치하고, 결과는 보낸 rank로 돌아오며, 제로 패딩된 절반에 대해 쌍을 아우르는 all-reduce를 수행하여 다음 레이어가 기대하는 복제된 출력을 복원합니다. 이 분할은 `tp_size`에 기반하며 `ep_size`에 기반하지 않습니다. 배치를 보유하여 보낼 수 있는 rank가 해당 rank이기 때문입니다. expert 그룹은 4개의 rank에 걸쳐 있으며, 각 expert는 `efsdp_size = 2`개의 rank에 걸쳐 FSDP 샤딩됩니다. 한편 트렁크(trunk)의 FSDP 그룹은 4개의 rank에 걸쳐 있습니다. 어텐션 헤드 가눗성(attention-head divisibility)과 같은 모델의 일반적인 TP 제약 조건은 여전히 dense 모듈에 적용됩니다. 토큰 슬라이스는 불균등하거나 비어 있을 수 있으며, 단일 토큰 디코딩 중에도 마찬가지입니다.

Token dispatch는 아직 pipeline parallelism과 함께 사용할 수 없으며, `pp_size=1`을 사용해야 합니다(아직 테스트되지 않음). 이러한 구성은 각각 8개의 GPU를 사용합니다:

| 구성 | 결과 |
| :--- | :--- |
| `DistributedConfig(tp_size=4, fsdp_size=2, ep_size=4)` | 네 개의 TP 그룹은 하나의 배치(batch)를 공유합니다. 학습 시 토큰이 분배되며 각 랭크는 배치의 4분의 1을 담당하고, 추론 시에는 `"all_reduce"`를 사용합니다. `ep_implementation="all_reduce"`를 설정하면 전체 과정에서 이를 사용합니다. |
| `DistributedConfig(tp_size=1, fsdp_size=8, ep_size=4)` | 각 rank에서 독립적인 배치로 Dispatch를 수행하고, 슬라이싱 없이 전문가를 rank 쌍에 걸쳐 FSDP로 샤딩합니다. |
| `DistributedConfig(tp_size=2, fsdp_size=4, ep_size=4)` | Dispatch는 배치당 TP 페어를 하나씩 사용하며, 각 페어는 자신의 배치를 둘로 슬라이스합니다. 전문가 그룹당 두 개의 배치입니다. |
| `DistributedConfig(tp_size=8, ep_size=8)` | 모든 rank가 하나의 batch를 공유합니다. 학습 시 토큰을 분배하여 각 rank가 batch의 1/8을 담당하며, 추론 시에는 `"all_reduce"`를 사용합니다. `ep_implementation="all_reduce"`를 설정하면 전체 과정에서 이를 사용합니다. |

> [!WARNING]
> [Trainer](/docs/transformers/v5.23.0/ko/main_classes/trainer#transformers.Trainer)는 아직 토큰 디스패치를 지원하지 않습니다. 배치 및 토큰 카운팅은 all-reduce 레이아웃을 가정하며, 이 레이아웃에서는 TP 그룹의 랭크들이 배치를 공유하고 `fsdp_size`개의 데이터 병렬 샤드가 존재합니다. Trainer의 디스패치 지원은 후속 업데이트에서 제공됩니다.

## FSDP2와 결합

Tensor parallelism과 expert parallelism은 각각 `tp`와 `ep` 메시에 걸쳐 가중치를 샤딩하지만, 옵티마이저 상태와 규칙이 없는 모듈은 여전히 그룹의 모든 랭크에 복제되므로 학습할 수 있는 모델 크기가 제한됩니다. `fsdp_size`를 사용하여 다른 메시 차원에 [FSDP2](./fsdp)를 추가하세요. 마스킹과 all-reduce를 사용하여 `ep_size=tp_size`를 유지하고 `ep_implementation="all_reduce"`를 전달하세요.

```py
from transformers import AutoModelForCausalLM
from transformers.distributed import DistributedConfig

distributed_config = DistributedConfig(
    tp_size=4,
    ep_size=4,  # expert parallel size, must match tp_size with masking and all-reduce
    fsdp_size=2,  # data parallel shards
    ep_implementation="all_reduce",  # "auto" would dispatch tokens in training, which the Trainer does not support yet
)
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-30B-A3B", distributed_config=distributed_config)
```

모델을 평소와 같이 로드한 후 [Trainer](/docs/transformers/v5.23.0/ko/main_classes/trainer#transformers.Trainer)로 학습합니다. 두 메시 전체에 걸린 그래디언트 노름을 계산하고 각 메시에 고유한 옵티마이저 파라미터 그룹을 할당합니다. [save_model()](/docs/transformers/v5.23.0/ko/main_classes/trainer#transformers.Trainer.save_model)은 샤드된 가중치를 일반 체크포인트로 수집합니다. 이를 위해 `accelerate>=1.12`가 필요하며, `Trainer`가 `tp_size`와 `fsdp_size`를 `~Accelerate.ParallelismConfig`에 반영할 수 있어야 합니다.

아래 표는 8xH100 GPU에서 EP 전용 학습과 2D EP+FSDP2를 비교합니다. 워크로드는 시퀀스 길이 2048에서 bf16로 Qwen3-30B-A3B를 완전 파인튜닝하는 것입니다. FSDP 샤드가 많을수록 피크 메모리가 줄고, FSDP2가 `fsdp`에 걸쳐 전문가를 올게더와 리듀스스캐터하기 때문에 토큰/초가 일부 감소합니다.

| 구성 | tokens/s/GPU | GPU당 피크 메모리 |
|---|---|---|
| `tp_size=8` | 3485 | 38.6 GB |
| `tp_size=4, fsdp_size=2` | 2900 | 34.2 GB |
| `tp_size=2, fsdp_size=4` | 2830 | 32.3 GB |

> [!WARNING]
> 로드 시 샤딩된 모델에 대해 체크포인트에서 재개하는 기능은 아직 지원되지 않으므로, [Trainer](/docs/transformers/v5.23.0/ko/main_classes/trainer#transformers.Trainer)는 해당 모델에 대해 `save_only_model=True` 또는 `save_strategy="no"`만 허용합니다.

## API 참조[[transformers.DistributedConfig]]

#### transformers.DistributedConfig[[transformers.DistributedConfig]]

```python
transformers.DistributedConfig(tp_size: int | None = None, tp_plan: typing.Union[dict[str, str], typing.Literal['auto'], NoneType] = None, enable_sequence_parallel: bool = False, enable_expert_parallel: bool = False, fsdp_size: int | None = None, dp_replicate_size: int | None = None, fsdp_plan: dict[str, str] | None = None, fsdp_cpu_offload: bool = False, fsdp_mixed_precision: bool = False, pp_size: int | None = None, ep_size: int | None = None, ep_plan: dict[str, str] | None = None, ep_implementation: str = 'auto')
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/distributed/configuration_utils.py#L26)

**매개변수:**

tp_size (`int`, *선택 사항*) : 텐서 병렬화를 위한 장치 수. `None`이고 `tp_plan`이 설정된 경우, 기본값은 `WORLD_SIZE // (other_parallel_size)`입니다. `None`이고 `tp_plan`이 설정되지 않은 경우, 기본값은 1입니다.

tp_plan (`dict[str, str]` 또는 `"auto"`, *선택 사항*) : Tensor parallel sharding plan입니다. `tp_size`가 설정된 상태에서 `"auto"`를 전달하거나 `None`으로 두면 모델의 사전 정의된 `base_model_tp_plan`을 사용합니다. 사전 정의된 plan의 개별 규칙을 오버라이드하려면 딕셔너리를 전달하세요. 명시되지 않은 규칙은 유지됩니다. 빈 딕셔너리를 전달하면 tensor parallel 규칙이 적용되지 않습니다.

enable_sequence_parallel (`bool`, *선택 사항*, 기본값 `False`) : 시퀀스 병렬화를 위해 예약되어 있습니다. 아직 연결되지 않았습니다.

enable_expert_parallel (`bool`, *선택 사항*, 기본값 `False`) : 비추천되며, v5.21에서 제거되었습니다. `ep_size`가 없으면 `ep_size=tp_size, tp_plan={}`와 동일합니다: `tp_size`개의 rank에 걸쳐 expert-parallel plan만 적용됩니다. 명시적으로 지정된 `ep_size`가 우선합니다. 이 플래그는 `tp_size`나 `fsdp_size`를 변경하지 않습니다.

fsdp_size (`int`, *선택 사항*) : FSDP(데이터 병렬)에 사용할 장치 수. `None`이고 `tp_size`가 설정된 경우 기본값은 1입니다.

dp_replicate_size (`int`, *선택 사항*) : FSDP 리플리카 수(HSDP). 매개변수는 `fsdp_size`개의 디바이스에 샤딩되고 `dp_replicate_size`번 복제됩니다. 그레디언트는 리플리카 내에서 reduce-scatter된 후, 리플리카 간에 all-reduce됩니다. 기본값은 1입니다. 멀티노드 학습에 사용을 권장합니다. 일반 FSDP는 모든 단계에서 모든 디바이스 간에 매개변수를 all-gather하고 그레디언트를 reduce-scatter하므로, 이러한 트래픽이 느린 노드 간 링크를 통해 전송됩니다. `dp_replicate_size`를 노드 수로, `fsdp_size * tp_size`를 노드당 디바이스 수로 설정하면 샤딩 트래픽은 빠른 노드 내 링크에 머물고, 그레디언트 all-reduce만 노드를 가로지릅니다. 매개변수가 노드 내에서 샤딩되므로 디바이스당 메모리 사용량이 증가하는 것이 비용입니다.

fsdp_plan (`dict[str, str]`, *선택 사항*) : FSDP2 샤딩 플랜입니다. `None`으로 두면 모델의 사전 정의된 `base_model_fsdp_plan`과 클래스 수준의 `_fsdp_plan`를 사용합니다. 개별 규칙을 오버라이드하려면 딕셔너리를 전달하세요. 지정되지 않은 규칙은 유지됩니다. `dp_replicate_size * fsdp_size > 1`인 경우에만 적용됩니다.

fsdp_cpu_offload (`bool`, *선택 사항*, 기본값 `False`) : FSDP2에 대한 CPU offloading을 활성화할지 여부입니다.

fsdp_mixed_precision (`bool`, *선택 사항*, 기본값 `False`) : FSDP2에서 혼합 정밀도를 활성화할지 여부입니다.

pp_size (`int`, *선택 사항*) : 파이프라인 병렬성에 사용할 장치의 수입니다. `None`이고 다른 병렬 모드가 설정된 경우 기본값은 1입니다.

ep_size (`int`, *선택 사항*) : 서로 다른 expert shard를 소유하는 장치의 수입니다. 기본값은 1입니다. EP를 활성화하려면 명시적으로 설정해야 합니다. `tp_size`의 배수여야 하며 `fsdp_size * tp_size`를 나누어야 합니다. `ep_size > tp_size`인 경우, `"all_to_all"`과 같이 토큰을 교환하는 `ep_implementation`을 가진 `"ep_dispatch_experts"` 규칙이 필요합니다.

ep_plan (`dict[str, str]`, *선택 사항*) : Expert parallel sharding plan. `None`으로 두면 모델의 사전 정의된 `base_model_ep_plan`을 사용합니다. 사전 정의된 플랜의 개별 규칙을 오버라이드하려면 딕셔너리를 전달하세요. 지정되지 않은 규칙은 유지됩니다. `ep_size > 1`인 경우에만 적용되며, 동일한 모듈에 대해서는 `tp_plan` 규칙보다 우선합니다. `"ep_dispatch_experts"` 규칙은 `ep_implementation`이 토큰이 expert에 도달하는 방식을 선택하도록 합니다.

ep_implementation (`str`, *선택 사항*, 기본값 `"auto"`) : `"ep_dispatch_experts"` 규칙이 토큰을 전문가에게 전달하는 방식을 지정합니다. `EPImplementationInterface`에 등록된 `EPImplementation`의 이름을 나타냅니다: - `"all_to_all"`은 라우팅된 토큰을 all-to-all 집합 연산을 통해 교환합니다. - `"all_reduce"`는 EP 그룹이 공유하는 배치에서 각 랭크의 전문가를 실행하고 출력을 합산합니다. `ep_size == tp_size`가 필요합니다. - `"deepgemm_megamoe"`는 해당 배치를 DeepGEMM Mega MoE에 전달하며, 이 커널이 토큰을 직접 교환합니다. `experts_implementation="deepgemm_megamoe"`로 로드하면 이 옵션이 선택됩니다. - `"auto"`는 추론 시 EP 그룹이 하나의 배치를 공유하면 `"all_reduce"`를, 그렇지 않으면 `"all_to_all"`을 실행합니다.

tensor, pipeline 또는 FSDP2 병렬화를 통한 네이티브 분산 추론 및 학습에 대한 구성입니다.

