# Uzman paralelliği

[Uzman paralelliği](https://huggingface.co/spaces/nanotron/ultrascale-playbook?section=expert_parallelism), [mixture-of-experts (MoE) modelleri](https://huggingface.co/blog/moe) için bir paralellik stratejisidir. Her bir uzmanın ileri besleme katmanı, farklı bir donanım hızlandırıcısında barınır. Bir yönlendirici, token'ları ilgili uzmanlara yönlendirir ve sonuçları toplar. Her token yalnızca birkaç uzmanı etkinleştirdiği için bu yaklaşım, hesaplama maliyetini artırmadan modelleri çok daha büyük parametre sayılarına ölçeklendirir.

## DistributedConfig

[DistributedConfig](/docs/transformers/v5.23.0/tr/expert_parallelism#transformers.DistributedConfig) sınıfını ve `ep_size` argümanını kullanarak uzman paralelliğini etkinleştirin. MoE modelleri uzmanlarını `"ep_dispatch_experts"` ile bölümler. Uygulamaları, tokenlerin uzmanlara nasıl ulaştığını belirler. [Token dağıtımı](#token-dispatch), `ep_size`'in `tp_size`'ten farklı olmasına olanak tanır. Bazı EP uygulamaları `ep_size=tp_size` gerektirir; örneğin `"all_reduce"` ve `"deepgemm_megamoe"`, böylece bir uzman grubundaki her rank aynı tokenlere sahip olur.

Llama 4'te EP planı yoktur: uzmanları, yönlendirici puanıyla zaten ölçeklenmiş her token'ı alır, bu nedenle dağıtılacak bir şey yoktur. Bunun yerine onları tensör paralelliği (`tp_size`) ile bölümlendirin.
```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,
)
```

Her MoE modeli, config dosyasında iki plan tanımlar: yoğun modüller için `base_model_tp_plan` ve uzmanlar için `base_model_ep_plan`. Bunlar yüklenen modelde `model.tp_plan` ve `model.ep_plan` olarak erişilebilir hale gelir. `tp_size > 1` ve `ep_size > 1` olduğunda her ikisi de uygulanır: [tensor parallel](./perf_infer_gpu_multi) planı dikkat (attention) ve yoğun MLP'leri parçalar (shard), uzman paralel planı ise uzmanları parçalar. Aynı modüller için EP kuralları TP kurallarına öncelik taşır, bu nedenle uzman ağırlıkları yalnızca EP planı tarafından bir kez parçalanır. EP planında, `GroupedGemmParallel` stili uzman ağırlıklarını uzman boyutu boyunca böler, böylece her rank yalnızca yerel uzmanlarını yükler; uzman modülündeki `"ep_dispatch_experts"` kuralı ise token'ların bu uzmanlara nasıl ulaştığını belirler.

`tp_plan` yalnızca `tp_size > 1` olduğunda, `ep_plan` ise yalnızca `ep_size > 1` olduğunda uygulanır. TP etkin ve EP devre dışı olduğunda, uzman kuralları dahil olmak üzere tam TP planı uygulanır.

`"ep_dispatch_experts"`, her rank için tüm uzmanları parçalar (`ep_size`, `tp_size`'nin bir katı olup `fsdp_size * tp_size`'i bölen bir değerdir) ve bunlara `ep_implementation` adını taşıyan uygulama üzerinden erişir, bkz. [Uygulama seçimi](#choosing-an-implementation).

### Bir uygulama seçimi

`"ep_dispatch_experts"`, uzmanları bir kez parçalar ve [DistributedConfig](/docs/transformers/v5.23.0/tr/expert_parallelism#transformers.DistributedConfig) içindeki `ep_implementation` ile seçilen, `EPImplementationInterface`’te kayıtlı uygulamalardan tokenlerin onlara nasıl ulaşacağını belirler:

| `ep_implementation` | avantajlar | dezavantajlar |
| :--- | :--- | :--- |
| `"all_to_all"`, bkz. [token dağıtımı](#token-dispatch) | Her yerleşim için çalışır, `ep_size > tp_size` dahil. Sadece yönlendirilen jetonlar taşınır. | Katman başına iki all-to-all kolektif ve bir host senkronizasyonu içerdiğinden, CUDA grafında yakalanamaz. |
| `"all_reduce"` | Hiç token taşınmaz ve host senkronizasyonu yapılmaz, bu nedenle decode CUDA grafiğinde yakalanır. | `ep_size=tp_size` gerektirir. Her rank, uzmanlarını tüm batch üzerinde çalıştırır; bu nedenle maliyeti batch ile birlikte artar. |
| `"deepgemm_megamoe"` | DeepGEMM Mega MoE, dağıtımı, uzmanları ve birleştirmeyi tek bir çekirdekte birleştirir. Bir EP grubundaki her katman, simetrik bellek tamponlarını paylaşır. | `ep_size=tp_size` gerektirir ve SM100+ üzerinde FP4 uzmanlarla FP8 aktivasyonlar kullanır. Yalnızca çıkarım için. |
| varsayılan olan `"auto"` | Bir uzman grubundaki sıralar (ranks) tek bir batch paylaşıyorsa çıkarım sırasında `"all_reduce"`, aksi halde `"all_to_all"` çalıştırır. | Her zaman en hızlı seçenek olmayabilir: bir iş yükü, özel bir uygulamadan faydalanabilir, bkz. [Uygulama ekleme](#adding-an-implementation). |

> [!NOTE]
> `ep_implementation`, yalnızca [DistributedConfig](/docs/transformers/v5.23.0/tr/expert_parallelism#transformers.DistributedConfig) içinde belirlenen paralel boyutlar arasından seçim yapar. Bir uzman grubundaki rank'lar farklı partileri tuttuğunda, örneğin `tp_size=1` ve `fsdp_size=ep_size` durumunda, uygulanabilir tek uygulama `"all_to_all"`'dır.

### Bir uygulama ekleme

Bir uygulama `EPImplementation` sınıfından türetilir ve `ep_implementation` adıyla seçilen kayıt altına alınır. Uzman modülü başına bir kez oluşturulduğundan, iletişim tamponları gibi durumları koruyabilir. Bu rank'ın tuttuğu batch ile, küresel uzman kimlikleriyle çağrıldığında, token'larının her biri için ağırlıklı uzman çıktısını döndürür. Bu rank'ın uzmanlarını, getirdiği satırlar, yerel uzman kimlikleri ve ağırlıklar üzerinde `experts_forward` ile çalıştırır.

```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]
> Gradyanlar, token tutan her ranga, yönlendirme ağırlıkları dahil olmak üzere, ulaşmalıdır; bu nedenle, autograd'ın türevini almadığı bir kolektif işlemi `torch.autograd.Function` içinde sarmalayın.

> [!TIP]
> `enable_expert_parallel=True`, `ep_size` olmadan kullanıldığında artık desteklenmemektedir ve bir `FutureWarning` üretir. Bu ayar, yalnızca uzmanları parçalar; tıpkı `ep_size=tp_size, tp_plan={}` yapılandırmasında olduğu gibi.

Çıkarım betiğinizi [torchrun](https://pytorch.org/docs/stable/elastic/run.html) ile başlatın. İşlem sayısı `tp_size * fsdp_size * pp_size` değerine eşit olmalı ve `ep_size`, uzman sayısını tam olarak bölmelidir.

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

### Planların üzerine yazılması

`tp_plan={...}` veya `ep_plan={...}` değerlerini [DistributedConfig](/docs/transformers/v5.23.0/tr/expert_parallelism#transformers.DistributedConfig) sınıfına geçirerek önceden tanımlanmış planların bireysel kurallarını geçersiz kılabilirsiniz. Belirtilmeyen kurallar korunur ve birleştirilen planlar modele kaydedilir. Her anahtar, bir modül, bir parametre veya mevcut bir plan girdisiyle eşleşmelidir; aksi takdirde herhangi bir şey bölümlenmeden önce yükleme işlemi `ValueError` hatası verir. Tam yolu, yüklü modelin gördüğü şekilde kullanın; bu nedenle bir nedensel LM için `model.layers.*`, temel modeli için ise `layers.*` kullanın.

```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"},
)
```

Bir plan sağlanmak, paralel boyutları çıkarım yapmaz: `tp_size` ve `ep_size` değerlerini açıkça belirleyin.

`ep_size=tp_size` durumunda, varsayılan `"auto"` uygulaması çıkarım sırasında `"all_reduce"` çalıştırır ve eğitim sırasında jetonları dağıtır. Eğitimde de maskeleme ve all-reduce yapmak için `ep_implementation="all_reduce"` ayarlayın:

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

## Token dağıtımı

Token dispatch, `"all_to_all"` uygulamasıdır: her rank, batch'in kendi payına düşen kısmında eğitim yapar. Her MoE katmanında, bir rank token'larını yönlendirir, her (token, uzman) çiftini, o uzmanın sahibi olduğu rank'a bir all-to-all ile gönderir, yerel uzmanlarını aldıkları üzerinde çalıştırır, sonuçları ikinci bir all-to-all ile geri alır ve bunları yönlendirme ağırlıklarıyla birleştirir. Yalnızca yönlendirilen aktivasyonlar ve uzman çıktıları taşınır ve hiçbir rank, sahip olmadığı token'lar için uzman hesaplama yapmaz.

```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` durumunda, `ep_size` hem `fsdp_size`'in hem de uzman sayısının tam bölünmesini sağlamalıdır ve dikkat mekanizması `num_key_value_heads` ile sınırlı değildir. Modelin geri kalanı için:

- Uzmanların dışındaki parametreler, `fsdp` üzerinde [FSDP2](./fsdp) ile parçalanır ve bu da onların gradyanlarını azaltır.
- Uzmanlar `ep` üzerinde parçalanır ve `efsdp_size = fsdp_size * tp_size // ep_size` birinden büyük olduğunda, ayrıca `efsdp` üzerinde FSDP ile parçalanır. Her zaman FSDP ile sarılı olduklarından, `fsdp_mixed_precision` ve `fsdp_cpu_offload` onlara da uygulanır ve [save_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) onları diğer herhangi bir parametre gibi toplar.
- Bir uzman paralel grubu `ep_size / tp_size` parti tutar, bu nedenle bir uzmanın gradyanı bu kadar partinin toplamıdır. `efsdp` indirgeme işlemi, grup boyutu yerine `fsdp_size` değerine böler; bu da FSDP2'nin yoğun modüller için kullandığı parti başına ortalama ile aynı sonucu verir.
- Her yerel uzman, katman başına bir sıfır dolgu satırını da işler. Uzmanları tarafından hiçbir token alınmayan bir sıralama, yine de reverse all-to-all ve uzman gradyan indirgeme işlemlerine katılır.

### Boyutların nasıl birleştiği

- `tp_size * fsdp_size`, işlem sayısıdır. `ep_size` hiçbir şey eklemez: yalnızca uzman ağırlıkları için aynı sıraları yeniden gruplar.
- `ep_size`, uzman listesini `ep_size` bloğa böler. Her rank `num_experts / ep_size` uzman hesaplar ve `ep_size` ardışık rank bir tam seti barındırır. Bu rank grubu, all-to-all'ın çalıştığı gruptur.
- `efsdp_size = fsdp_size * tp_size / ep_size`, uzman kümesinin kaç tam kopyasının var olduğunu belirtir. Farklı kopyalarda aynı konumdaki rank'lar, FSDP'nin yoğun modüller için yaptığı gibi, bu uzmanları bellek için parçalara ayırır ve gradyanlarını ortalama alır.
- Bir rank'ın tuttuğu batch yalnızca `fsdp`'ye bağlıdır. Ardışık rank'lar bir TP grubu oluşturur ve aynı batch'i alır; `fsdp_size` grupları farklı batch'ler alır.

Sekiz süreç, `tp_size=2, fsdp_size=4`, sekiz uzman:

```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
```

Şekilden iki sonuç çıkar:

- Bir EP grubunun içinde, her token, kendi batch'ini tutan çiftin rank'ı başına bir kez olmak üzere `tp_size` kez var olur. Bu, `ep_size`'dan bağımsızdır.
- Bir EP grubu `ep_size / tp_size` farklı parti tutar. Bu, bir uzmanın gradyanlarının toplandığı sayıdır.

### Tensor paralelliği ile

Yoğun modülleri TP planıyla parçalara ayırmak için `tp_size > 1` değerini ayarlayın; uzmanlar ise dispatch kullanır. Sekiz işlemde:

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

Her TP rank çifti aynı batch'i alır, çünkü tensor paralelliği çiftin içindeki aktivasyonları kopyalar. Her iki rank da tüm token'larını dağıttıysa, bir expert'ın sahibi olan rank her token'ı iki kez alır, iki kez hesaplar ve ağırlık gradyanı ikiye katlanır. Expert'lar tek bir rank üzerinde bütündür, bu yüzden kopya ağırlıklar üzerinden bölünemez; ayrıca sahip genellikle başka bir rank olduğu için, masking'de olduğu gibi sahiplik üzerinden de çözülemez. Bu nedenle çift satırları böler: her TP rank, token'ların ayrık `1 / tp_size` kadarını dağıtır, sonuçlar gönderen rank'a geri döner ve sıfır dolgulu yarıların çift üzerinden all-reduce'ı, bir sonraki katmanın beklediği kopyalanmış çıktıyı geri getirir. Bölme `tp_size`'e göre yapılır, `ep_size`'e göre değil, çünkü yalnızca bir batch'e sahip olan rank'lar onu gönderebilir. Expert grupları dört rank'ı kapsar ve her expert, `efsdp_size = 2` rank arasında FSDP ile paylaşımlıdır; gövdenin FSDP grubu ise dört rank'ı kapsar. Modelin olağan TP kısıtları, örneğin dikkat başı bölünebilirliği, yoğun modüllere hâlâ uygulanır. Token dilimleri eşitsiz veya boş olabilir, tek token çözümlendirme sırasında da dahil.

Token dispatch henüz pipeline parallelism ile birleştirilemez; `pp_size=1` kullanın (henüz test edilmedi) Bu yapılandırmaların her biri sekiz GPU kullanır:

| Yapılandırma | Sonuç |
| :--- | :--- |
| `DistributedConfig(tp_size=4, fsdp_size=2, ep_size=4)` | Dört üyeli her TP grubu bir batch paylaşır. Eğitim sırasında token'lar dağıtılır ve her rank batch'in dörtte birini alır; çıkarım `"all_reduce"` kullanır; `ep_implementation="all_reduce"` ayarlandığında bu yöntem her yerde kullanılır. |
| `DistributedConfig(tp_size=1, fsdp_size=8, ep_size=4)` | Her rank üzerinde bağımsız bir batch ile dispatch, dilimleme olmadan ve uzmanların rank çiftleri arasında FSDP ile paylaştırılması. |
| `DistributedConfig(tp_size=2, fsdp_size=4, ep_size=4)` | Her batch için bir TP çiftiyle dağıtın; her çift kendi batch'ini ikiye bölsün; her uzman grubu için iki batch. |
| `DistributedConfig(tp_size=8, ep_size=8)` | Her rank bir batch paylaşır. Eğitim, token'ları dağıtır; her rank batch'in sekizde birini alır; çıkarım `"all_reduce"` kullanır; `ep_implementation="all_reduce"` ayarlandığında bu yöntem her yerde kullanılır. |

> [!WARNING]
> [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) henüz token dağıtımını hesaba katmıyor: batch ve token sayımı, bir TP grubundaki rank'lerin bir batch'i paylaşması ve `fsdp_size` adet veri paralel diliminin var olduğu all-reduce yerleşimini varsayar. Trainer'ın dağıtıma desteği bir sonraki aşamada eklenecek.

## FSDP2 ile birleştirme

Tensor ve uzman paralelliği, ağırlıkları kendi mesh'leri olan `tp` ve `ep` üzerinde parçalara ayırır; ancak optimizör durumu ve bir kuralı olmayan modüller, grubun her rank'ında hâlâ replike edilir ve bu da eğitebileceğiniz modelin boyutunu sınırlar. `fsdp_size` ile başka bir mesh boyutunda [FSDP2](./fsdp) ekleyin. Masking ve all-reduce ile `ep_size=tp_size` değerini koruyun ve `ep_implementation="all_reduce"` parametresini iletin.

```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)
```

Modeli normal şekilde yükleyin, ardından [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) ile eğitim yapın. Gradyan normunu her iki mesh üzerinden alır ve her mesh'e kendi optimizer param grubunu verir. [save_model()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.save_model), parçalı ağırlıkları düzenli bir checkpoint'e toplar. Bunun için `Trainer`'ın `tp_size` ve `fsdp_size` değerlerini `~Accelerate.ParallelismConfig`'e yansıtabilmesi gerektirdiğinden `accelerate>=1.12` sürümü gereklidir.

Aşağıdaki tablo, 8xH100 GPU'larda yalnızca EP ile eğitimi, 2B EP+FSDP2 ile karşılaştırır. İş yükü, 2048 dizi uzunluğunda bf16'da Qwen3-30B-A3B'nin tam ince ayarıdır. Daha fazla FSDP parçası tepe belleği keser ve FSDP2 uzmanları `fsdp` üzerinden all-gather ve reduce-scatter yaptığı için token/s biraz düşer.

| yapılandırma | tokens/s/GPU | tepe bellek/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]
> Yükleme sırasında parçalanan modeller için kontrol noktasından devam etme henüz desteklenmediğinden, [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) bu modeller için yalnızca `save_only_model=True` veya `save_strategy="no"` değerlerini kabul eder.

## API referansı[[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')
```

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

**Parametreler:**

tp_size (`int`, *isteğe bağlı*) : Tensor paralelliği için cihaz sayısı. `None` ise ve `tp_plan` ayarlanmışsa, varsayılan olarak `WORLD_SIZE // (other_parallel_size)` olur. `None` ise ve `tp_plan` ayarlanmamışsa, varsayılan olarak 1 olur.

tp_plan (`dict[str, str]` veya `"auto"`, *isteğe bağlı*) : Tensor parallel sharding planı. `tp_size` ayarlandığında, modelin önceden tanımlı `base_model_tp_plan`'sini kullanmak için `"auto"` geçirin veya `None` olarak bırakın. Bu plandaki bireysel kuralları geçersiz kılmak için bir sözlük geçirin; belirtilmeyen kurallar korunur. Boş bir sözlük, hiçbir tensor parallel kuralı uygulamaz.

enable_sequence_parallel (`bool`, *isteğe bağlı*, varsayılan `False`) : Sıralı paralellik için ayrılmıştır. Henüz bağlanmamıştır.

enable_expert_parallel (`bool`, *isteğe bağlı*, varsayılan `False`) : Kullanımdan kaldırıldı, v5.21'de kaldırıldı. `ep_size` olmadan, `ep_size=tp_size, tp_plan={}` ile aynıdır: `tp_size` rank arasında yalnızca uzman paralel planı. Açıkça belirtilen `ep_size` önceliklidir. Bu bayrak `tp_size` veya `fsdp_size` değerlerini değiştirmez.

fsdp_size (`int`, *opsiyonel*) : FSDP (veri paralelliği) için cihaz sayısı. `None` ise ve `tp_size` ayarlanmışsa, varsayılan olarak 1'dir.

dp_replicate_size (`int`, *isteğe bağlı*) : FSDP replikası sayısı (HSDP). Parametreler `fsdp_size` cihaz arasında paylaştırılır ve `dp_replicate_size` kez replike edilir: gradyanlar bir replika içinde reduce-scatter edilir, ardından replikalar arasında all-reduce edilir. Varsayılan değer 1'dir. Çoklu düğüm eğitiminde öneririz: düz FSDP, her adımda parametreleri tüm cihazlar arasında all-gather eder ve gradyanları reduce-scatter eder, bu nedenle bu trafik daha yavaş olan düğümler arası bağlantılardan geçer. `dp_replicate_size` değerini düğüm sayısına ve `fsdp_size * tp_size` değerini düğüm başına cihaz sayısına ayarlayın: bu durumda paylaştırma trafiği hızlı düğüm içi bağlantılarda kalır ve yalnızca gradyan all-reduce işlemi düğümler arasında gerçekleşir. Maliyeti, parametrelerin düğüm içinde paylaştırıldığı için cihaz başına daha fazla bellek kullanımıdır.

fsdp_plan (`dict[str, str]`, *isteğe bağlı*) : FSDP2 bölme planı. Modelin önceden tanımlı `base_model_fsdp_plan` ve sınıf düzeyindeki `_fsdp_plan` değerlerini kullanmak için `None` olarak bırakın. Bireysel kuralları geçersiz kılmak için bir sözlük iletin; belirtilmeyen kurallar korunur. Yalnızca `dp_replicate_size * fsdp_size > 1` olduğunda uygulanır.

fsdp_cpu_offload (`bool`, *isteğe bağlı*, varsayılan `False`) : FSDP2 için CPU offloading'in etkinleştirilip etkinleştirilmeyeceğini belirtir.

fsdp_mixed_precision (`bool`, *isteğe bağlı*, varsayılan `False`) : FSDP2 için karma hassasiyetin etkinleştirilip etkinleştirilmeyeceğini belirtir.

pp_size (`int`, *opsiyonel*) : Pipeline paralelliği için cihaz sayısı. `None` ise ve başka bir paralel mod ayarlanmışsa, varsayılan olarak 1 olur.

ep_size (`int`, *isteğe bağlı*) : Farklı uzman dilimlerine sahip cihaz sayısı. Varsayılan değeri 1'dir. EP'yi etkinleştirmek için açıkça ayarlayın. `tp_size`'in katı olmalı ve `fsdp_size * tp_size`'i tam bölmelidir. `ep_size > tp_size` için, `"all_to_all"` gibi token değiştiren bir `ep_implementation` içeren bir `"ep_dispatch_experts"` kuralı gereklidir.

ep_plan (`dict[str, str]`, *isteğe bağlı*) : Uzman paralel parçalama planı. Modelin önceden tanımlı `base_model_ep_plan`'sini kullanmak için `None` olarak bırakın. Bu plandaki bireysel kuralları geçersiz kılmak için bir sözlük iletin; belirtilmeyen kurallar korunur. Yalnızca `ep_size > 1` olduğunda uygulanır ve aynı modüller için `tp_plan` kurallarına göre önceliklidir. `"ep_dispatch_experts"` kuralı, `ep_implementation`'in tokenlerin uzmanlara nasıl ulaştığını seçmesine olanak tanır.

ep_implementation (`str`, *isteğe bağlı*, varsayılan `"auto"`) : `"ep_dispatch_experts"` kuralının uzmanlara token'larını nasıl ilettiğini belirtir. `EPImplementationInterface` içinde kayıtlı bir `EPImplementation` adını verir: - `"all_to_all"`, yönlendirilen token'ları all-to-all kolektifleriyle değiştirir. - `"all_reduce"`, her rank'ın uzmanlarını EP grubunun paylaştığı batch üzerinde çalıştırır ve çıktıları toplar. `ep_size == tp_size` gerektirir. - `"deepgemm_megamoe"`, bu batch'i token'ları kendi kendine değiştiren çekirdeğe sahip DeepGEMM Mega MoE'ye iletir. `experts_implementation="deepgemm_megamoe"` ile yükleme bunu seçer. - `"auto"`, EP grubu tek bir batch paylaşıyorsa çıkarım sırasında `"all_reduce"`, aksi halde `"all_to_all"` çalıştırır.

Tensor, pipeline veya FSDP2 paralelliği ile yerel dağıtık çıkarım ve eğitim için yapılandırma.

