Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /v0.43.0 /fr /api /parallel.md

mishig

2 days ago

preview code

download

raw

8.93 kB

# Parallélisme

Les stratégies de parallélisme aident à accélérer les transformeurs de diffusion en répartissant les calculs sur plusieurs appareils, ce qui permet de réduire les temps d'inférence/entraînement. Consultez le guide [Inférence distribuée](../training/distributed_inference) pour en savoir plus.

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L199)

**Paramètres :**

context_parallel_config (`ContextParallelConfig`, *facultatif*) : Configuration pour le parallélisme de contexte.

tensor_parallel_config (`TensorParallelConfig`, *facultatif*) : Configuration pour le parallélisme de tenseurs.

Configuration pour l'application de différents parallélismes.

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L41)

**Paramètres :**

ring_degree (`int`, *facultatif*, valeur par défaut `1`) : Nombre d’appareils à utiliser pour Ring Attention. La séquence est répartie entre les appareils. Chaque appareil calcule l’attention entre ses blocs Q et KV locaux, transmis séquentiellement autour de l’anneau. Moins de mémoire (ne conserve que 1/N des KV à la fois), superpose le calcul et la communication, mais nécessite N itérations pour voir tous les jetons. Idéal pour les longues séquences avec une mémoire ou une bande passante limitée. Nombre d’appareils à utiliser pour l’attention en anneau au sein d’une région de parallélisme de contexte. Doit être un diviseur du nombre total d’appareils dans le maillage de parallélisme de contexte.
ulysses_degree (`int`, *facultatif*, valeur par défaut `1`) : Nombre d’appareils à utiliser pour l’Ulysses Attention. La séquence est répartie entre les appareils. Chaque appareil calcule les QKV locaux, puis effectue un all-gather de tous les fragments KV pour calculer l’attention complète en une seule passe. Mémoire plus élevée (stocke tous les KV), nécessite une communication all-to-all à haut débit, mais offre une latence plus faible. Idéal pour des séquences de taille modérée avec une bande passante d’interconnexion élevée.

convert_to_fp32 (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut convertir la sortie et LSE en float32 pour la stabilité numérique de ring attention.

rotate_method (`str`, *facultatif*, par défaut `"allgather"`) : Méthode à utiliser pour faire tourner les états clé/valeur entre les appareils dans l'attention en anneau. Actuellement, seul `"allgather"` est pris en charge.
ulysses_anything (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut activer le mode « Ulysses Anything », qui prend en charge des longueurs de séquence et des nombres de têtes arbitraires, non divisibles uniformément par `ulysses_degree`. Lorsqu'il est activé, `ulysses_degree` doit être supérieur à 1 et `ring_degree` doit être égal à 1.

ring_anything (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut activer le mode « Ring Anything », qui prend en charge des longueurs de séquence arbitraires. Lorsqu'il est activé, `ring_degree` doit être supérieur à 1 et `ulysses_degree` doit être égal à 1.
mesh (`torch.distributed.device_mesh.DeviceMesh`, *facultatif*) : Un maillage d’appareils personnalisé à utiliser pour le parallélisme de contexte. S’il est fourni, ce maillage sera utilisé au lieu d’en créer un nouveau. Cela est utile lors de la combinaison du parallélisme de contexte avec d’autres stratégies de parallélisme (par exemple, FSDP, parallélisme de tenseurs) qui partagent le même maillage d’appareils. Le maillage doit posséder les dimensions « ring » et « ulysses ». Utilisez la taille 1 pour les dimensions non utilisées (par exemple, `mesh_shape=(2, 1, 4)` avec `mesh_dim_names=("ring", "ulysses", "fsdp")` pour l’attention en anneau uniquement avec FSDP).
Configuration pour le parallélisme de contexte.
#### 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, ...]]])
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/context_parallel.py#L80)
Appliquer le parallélisme de contexte à un modèle.
## 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)
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L157)
**Paramètres :**
tp_degree (`int`, par défaut `1`) : Nombre d'appareils sur lesquels effectuer le sharding. Doit être un diviseur du nombre de têtes d'attention (et des dimensions cachées du FFN) du modèle parallélisé.

mesh (`torch.distributed.device_mesh.DeviceMesh`, *facultatif*) : Un maillage d’appareils personnalisé à utiliser. S’il est fourni, `tp_degree` est déduit de `mesh.size()` et l’argument est ignoré. Utile lors de la combinaison du TP avec d’autres stratégies de parallélisme (par ex. CP) qui partagent le même maillage.

Configuration pour le parallélisme de tenseurs.

Le parallélisme tensoriel répartit les matrices de poids (par colonnes et par lignes) sur plusieurs appareils. Chaque appareil calcule un résultat partiel ; un AllReduce/AllGather aux frontières des couches reconstruit la sortie complète. Utilise `torch.distributed.tensor.parallelize_module` avec les styles de répartition `ColwiseParallel` / `RowwiseParallel`. Les types d’appareils pris en charge sont `"cuda"`, `"neuron"` et `"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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/tensor_parallel.py#L481)

**Paramètres :**

model (`torch.nn.Module`) : Le modèle à fractionner sur place.

config (`TensorParallelConfig`) : la configuration du parallélisme de tenseurs. Son maillage d'appareils doit déjà être configuré avec `config.setup(...)`.

tp_plan (`dict`) : Un mappage plat des glob de noms de modules vers un style `"colwise"`/`"rowwise"` (ou une variante packée), généralement le `_tp_plan` du modèle.
weights_already_sharded (`bool`, par défaut `False`) : Indique si les paramètres planifiés sont déjà des fragments `DTensor`, comme c’est le cas après un chargement en streaming via `from_pretrained`. Si `True`, seuls les hooks de propagation avant sont enregistrés. Cette valeur est transmise explicitement plutôt que détectée, car un paramètre planifié manquant dans le point de contrôle resterait un tenseur méta et ferait dire à la détection « non fragmenté » pour un modèle qui est en réalité partiellement fragmenté.

Appliquer le parallélisme de tenseurs sur un modèle à partir de son `_tp_plan` aplati.

Xet Storage Details

Size:: 8.93 kB
Xet hash:: 54a8a28a56437b6dddf3c1afc24f549c9bd5972aeeae2bea99986818af5fe2d3

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# Parallélisme

	Les stratégies de parallélisme aident à accélérer les transformeurs de diffusion en répartissant les calculs sur plusieurs appareils, ce qui permet de réduire les temps d'inférence/entraînement. Consultez le guide [Inférence distribuée](../training/distributed_inference) pour en savoir plus.

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

	[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L199)

	Paramètres :

	context_parallel_config (`ContextParallelConfig`, facultatif) : Configuration pour le parallélisme de contexte.

	tensor_parallel_config (`TensorParallelConfig`, facultatif) : Configuration pour le parallélisme de tenseurs.

	Configuration pour l'application de différents parallélismes.

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

	[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L41)

	Paramètres :

	ring_degree (`int`, facultatif, valeur par défaut `1`) : Nombre d’appareils à utiliser pour Ring Attention. La séquence est répartie entre les appareils. Chaque appareil calcule l’attention entre ses blocs Q et KV locaux, transmis séquentiellement autour de l’anneau. Moins de mémoire (ne conserve que 1/N des KV à la fois), superpose le calcul et la communication, mais nécessite N itérations pour voir tous les jetons. Idéal pour les longues séquences avec une mémoire ou une bande passante limitée. Nombre d’appareils à utiliser pour l’attention en anneau au sein d’une région de parallélisme de contexte. Doit être un diviseur du nombre total d’appareils dans le maillage de parallélisme de contexte.

	ulysses_degree (`int`, facultatif, valeur par défaut `1`) : Nombre d’appareils à utiliser pour l’Ulysses Attention. La séquence est répartie entre les appareils. Chaque appareil calcule les QKV locaux, puis effectue un all-gather de tous les fragments KV pour calculer l’attention complète en une seule passe. Mémoire plus élevée (stocke tous les KV), nécessite une communication all-to-all à haut débit, mais offre une latence plus faible. Idéal pour des séquences de taille modérée avec une bande passante d’interconnexion élevée.

	convert_to_fp32 (`bool`, facultatif, par défaut `True`) : Indique s'il faut convertir la sortie et LSE en float32 pour la stabilité numérique de ring attention.

	rotate_method (`str`, facultatif, par défaut `"allgather"`) : Méthode à utiliser pour faire tourner les états clé/valeur entre les appareils dans l'attention en anneau. Actuellement, seul `"allgather"` est pris en charge.

	ulysses_anything (`bool`, facultatif, valeur par défaut `False`) : Indique s'il faut activer le mode « Ulysses Anything », qui prend en charge des longueurs de séquence et des nombres de têtes arbitraires, non divisibles uniformément par `ulysses_degree`. Lorsqu'il est activé, `ulysses_degree` doit être supérieur à 1 et `ring_degree` doit être égal à 1.

	ring_anything (`bool`, facultatif, valeur par défaut `False`) : Indique s'il faut activer le mode « Ring Anything », qui prend en charge des longueurs de séquence arbitraires. Lorsqu'il est activé, `ring_degree` doit être supérieur à 1 et `ulysses_degree` doit être égal à 1.

	mesh (`torch.distributed.device_mesh.DeviceMesh`, facultatif) : Un maillage d’appareils personnalisé à utiliser pour le parallélisme de contexte. S’il est fourni, ce maillage sera utilisé au lieu d’en créer un nouveau. Cela est utile lors de la combinaison du parallélisme de contexte avec d’autres stratégies de parallélisme (par exemple, FSDP, parallélisme de tenseurs) qui partagent le même maillage d’appareils. Le maillage doit posséder les dimensions « ring » et « ulysses ». Utilisez la taille 1 pour les dimensions non utilisées (par exemple, `mesh_shape=(2, 1, 4)` avec `mesh_dim_names=("ring", "ulysses", "fsdp")` pour l’attention en anneau uniquement avec FSDP).

	Configuration pour le parallélisme de contexte.

	#### 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, ...]]])
	```

	[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/context_parallel.py#L80)

	Appliquer le parallélisme de contexte à un modèle.

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

	[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L157)

	Paramètres :

	tp_degree (`int`, par défaut `1`) : Nombre d'appareils sur lesquels effectuer le sharding. Doit être un diviseur du nombre de têtes d'attention (et des dimensions cachées du FFN) du modèle parallélisé.

	mesh (`torch.distributed.device_mesh.DeviceMesh`, facultatif) : Un maillage d’appareils personnalisé à utiliser. S’il est fourni, `tp_degree` est déduit de `mesh.size()` et l’argument est ignoré. Utile lors de la combinaison du TP avec d’autres stratégies de parallélisme (par ex. CP) qui partagent le même maillage.

	Configuration pour le parallélisme de tenseurs.

	Le parallélisme tensoriel répartit les matrices de poids (par colonnes et par lignes) sur plusieurs appareils. Chaque appareil calcule un résultat partiel ; un AllReduce/AllGather aux frontières des couches reconstruit la sortie complète. Utilise `torch.distributed.tensor.parallelize_module` avec les styles de répartition `ColwiseParallel` / `RowwiseParallel`. Les types d’appareils pris en charge sont `"cuda"`, `"neuron"` et `"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)
	```

	[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/tensor_parallel.py#L481)

	Paramètres :

	model (`torch.nn.Module`) : Le modèle à fractionner sur place.

	config (`TensorParallelConfig`) : la configuration du parallélisme de tenseurs. Son maillage d'appareils doit déjà être configuré avec `config.setup(...)`.

	tp_plan (`dict`) : Un mappage plat des glob de noms de modules vers un style `"colwise"`/`"rowwise"` (ou une variante packée), généralement le `_tp_plan` du modèle.

	weights_already_sharded (`bool`, par défaut `False`) : Indique si les paramètres planifiés sont déjà des fragments `DTensor`, comme c’est le cas après un chargement en streaming via `from_pretrained`. Si `True`, seuls les hooks de propagation avant sont enregistrés. Cette valeur est transmise explicitement plutôt que détectée, car un paramètre planifié manquant dans le point de contrôle resterait un tenseur méta et ferait dire à la détection « non fragmenté » pour un modèle qui est en réalité partiellement fragmenté.

	Appliquer le parallélisme de tenseurs sur un modèle à partir de son `_tp_plan` aplati.