diffusers/v0.43.0/fr/api/parallel.md

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 pour en savoir plus.

ParallelConfig[[diffusers.ParallelConfig]]

diffusers.ParallelConfig[[diffusers.ParallelConfig]]

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

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

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

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

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

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

TensorParallelConfig[[diffusers.TensorParallelConfig]]

diffusers.TensorParallelConfig[[diffusers.TensorParallelConfig]]

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

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

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

Source

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.