# Paralelisme

Strategi paralelisme membantu mempercepat diffusion transformers dengan mendistribusikan komputasi ke beberapa perangkat, sehingga memungkinkan waktu inferensi/pelatihan yang lebih cepat. Lihat panduan [Distributed inference](../training/distributed_inference) untuk mempelajari lebih lanjut.

## ParallelConfig[[diffusers.ParallelConfig]]

#### diffusers.ParallelConfig[[diffusers.ParallelConfig]]

```python
diffusers.ParallelConfig(context_parallel_config: diffusers.models._modeling_parallel.ContextParallelConfig | None = None, tensor_parallel_config: diffusers.models._modeling_parallel.TensorParallelConfig | None = None, _rank: int = None, _world_size: int = None, _device: device = None, _mesh: DeviceMesh = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/_modeling_parallel.py#L199)

**Parameter:**

context_parallel_config (`ContextParallelConfig`, *opsional*) : Konfigurasi untuk paralelisme konteks.

tensor_parallel_config (`TensorParallelConfig`, *opsional*) : Konfigurasi untuk paralelisme tensor.

Konfigurasi untuk menerapkan berbagai paralelisme.

## ContextParallelConfig[[diffusers.ContextParallelConfig]]

#### diffusers.ContextParallelConfig[[diffusers.ContextParallelConfig]]

```python
diffusers.ContextParallelConfig(ring_degree: int | None = None, ulysses_degree: int | None = None, convert_to_fp32: bool = True, rotate_method: typing.Literal['allgather', 'alltoall'] = 'allgather', mesh: typing.Optional[torch.distributed.device_mesh.DeviceMesh] = None, ulysses_anything: bool = False, ring_anything: bool = False, _rank: int = None, _world_size: int = None, _device: device = None, _mesh: DeviceMesh = None, _flattened_mesh: DeviceMesh = None, _ring_mesh: DeviceMesh = None, _ulysses_mesh: DeviceMesh = None, _ring_local_rank: int = None, _ulysses_local_rank: int = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/_modeling_parallel.py#L41)

**Parameter:**

ring_degree (`int`, *opsional*, default `1`) : Jumlah perangkat yang digunakan untuk Ring Attention. Urutan dipecah di antara perangkat. Setiap perangkat menghitung perhatian antara Q lokal dan potongan KV yang diteruskan secara berurutan di sekitar cincin. Memori lebih rendah (hanya menyimpan 1/N dari KV pada satu waktu), mengoverlap komputasi dengan komunikasi, tetapi memerlukan N iterasi untuk melihat semua token. Paling cocok untuk urutan panjang dengan memori/bandwidth terbatas. Jumlah perangkat yang digunakan untuk ring attention di dalam wilayah paralel konteks. Harus menjadi pembagi dari total jumlah perangkat di mesh paralel konteks.

ulysses_degree (`int`, *opsional*, default `1`) : Jumlah perangkat yang digunakan untuk Ulysses Attention. Pemecahan sekuens dilakukan di antara perangkat. Setiap perangkat menghitung QKV lokal, kemudian melakukan all-gather pada semua chunk KV untuk menghitung perhatian penuh dalam satu langkah. Memori lebih tinggi (menyimpan semua KV), memerlukan komunikasi all-to-all dengan pita lebar tinggi, tetapi latensi lebih rendah. Paling cocok untuk sekuens sedang dengan pita lebar interkoneksi yang baik.

convert_to_fp32 (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengonversi output dan LSE ke float32 untuk stabilitas numerik ring attention.

rotate_method (`str`, *opsional*, defaultnya `"allgather"`) : Metode yang digunakan untuk memutar status key/value antar perangkat dalam ring attention. Saat ini, hanya `"allgather"` yang didukung.

ulysses_anything (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengaktifkan mode "Ulysses Anything", yang mendukung panjang sekuens dan jumlah head yang tidak dapat dibagi rata oleh `ulysses_degree`. Saat diaktifkan, `ulysses_degree` harus lebih besar dari 1 dan `ring_degree` harus 1.

ring_anything (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengaktifkan mode "Ring Anything", yang mendukung panjang sekuens arbitrer. Saat diaktifkan, `ring_degree` harus lebih besar dari 1 dan `ulysses_degree` harus 1.

mesh (`torch.distributed.device_mesh.DeviceMesh`, *opsional*) : Device mesh kustom untuk digunakan pada context parallelism. Jika disediakan, mesh ini akan digunakan alih-alih membuat yang baru. Hal ini berguna saat menggabungkan context parallelism dengan strategi parallelism lainnya (misalnya, FSDP, tensor parallelism) yang berbagi device mesh yang sama. Mesh harus memiliki dimensi "ring" dan "ulysses". Gunakan ukuran 1 untuk dimensi yang tidak digunakan (misalnya, `mesh_shape=(2, 1, 4)` dengan `mesh_dim_names=("ring", "ulysses", "fsdp")` untuk ring attention saja dengan FSDP).

Konfigurasi untuk paralelisme konteks.

#### diffusers.hooks.apply_context_parallel[[diffusers.hooks.apply_context_parallel]]

```python
diffusers.hooks.apply_context_parallel(module: Module, parallel_config: ContextParallelConfig, plan: dict[str, dict[str, dict[str | int, diffusers.models._modeling_parallel.ContextParallelInput | list[diffusers.models._modeling_parallel.ContextParallelInput] | tuple[diffusers.models._modeling_parallel.ContextParallelInput, ...]] | diffusers.models._modeling_parallel.ContextParallelOutput | list[diffusers.models._modeling_parallel.ContextParallelOutput] | tuple[diffusers.models._modeling_parallel.ContextParallelOutput, ...]]])
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/context_parallel.py#L80)

Terapkan paralel konteks pada model.

## TensorParallelConfig[[diffusers.TensorParallelConfig]]

#### diffusers.TensorParallelConfig[[diffusers.TensorParallelConfig]]

```python
diffusers.TensorParallelConfig(tp_degree: int = 1, mesh: typing.Optional[torch.distributed.device_mesh.DeviceMesh] = None, _rank: int = None, _world_size: int = None, _device: device = None, _mesh: DeviceMesh = None, _tp_degree: int = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/_modeling_parallel.py#L157)

**Parameter:**

tp_degree (`int`, defaultnya `1`) : Jumlah perangkat untuk sharding. Harus menjadi pembagi dari jumlah kepala perhatian (dan dimensi tersembunyi FFN) dari model yang diparalelkan.

mesh (`torch.distributed.device_mesh.DeviceMesh`, *opsional*) : Device mesh kustom yang akan digunakan. Jika disediakan, `tp_degree` disimpulkan dari `mesh.size()` dan argumen diabaikan. Berguna saat menggabungkan TP dengan strategi paralelisme lain (mis. CP) yang berbagi mesh yang sama.

Konfigurasi untuk paralelisme tensor.

Tensor parallelism memecah matriks bobot (secara kolom dan baris) di antara perangkat. Setiap perangkat menghitung hasil parsial; AllReduce/AllGather di batas lapisan merekonstruksi output penuh. Menggunakan `torch.distributed.tensor.parallelize_module` dengan gaya sharding `ColwiseParallel` / `RowwiseParallel`. Jenis perangkat yang didukung adalah `"cuda"`, `"neuron"`, dan `"tpu"`.

#### diffusers.hooks.apply_tensor_parallel[[diffusers.hooks.apply_tensor_parallel]]

```python
diffusers.hooks.apply_tensor_parallel(model: Module, config: TensorParallelConfig, tp_plan: dict, weights_already_sharded: bool = False)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/tensor_parallel.py#L481)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan di-shard di tempat.

config (`TensorParallelConfig`) : Konfigurasi tensor-parallel. Device mesh-nya harus sudah diatur dengan `config.setup(...)`.

tp_plan (`dict`) : Pemetaan datar dari glob nama modul ke gaya `"colwise"`/`"rowwise"` (atau varian yang dikemas), biasanya `_tp_plan` model.

weights_already_sharded (`bool`, defaultnya `False`) : Apakah parameter yang direncanakan sudah berupa shard `DTensor`, seperti yang terjadi setelah pemuatan `from_pretrained` streaming. Jika `True`, hanya hook forward yang didaftarkan. Nilai ini diteruskan secara eksplisit alih-alih dideteksi, karena parameter yang direncanakan namun tidak ada di checkpoint tetap akan berupa meta tensor dan akan membuat deteksi menyatakan “tidak di-shard” untuk model yang sebenarnya setengah di-shard.

Terapkan paralel tensor pada model dari `_tp_plan` datarnya.