Buckets:
| # Parallélisme des données | |
| [La parallélisation des données](https://huggingface.co/spaces/nanotron/ultrascale-playbook?section=data_parallelism) réplique le même modèle sur chaque GPU et attribue à chaque GPU des prompts différents. Elle augmente le débit lorsque le modèle tient déjà sur un seul GPU, et elle laisse inchangée la latence d'un prompt unique. Si vous ne l'avez pas encore fait, essayez d'abord [l'inférence par lots](../using-diffusers/batched_inference) sur un seul GPU. Reportez-vous à [l'inférence distribuée](../training/distributed_inference) pour la comparer aux autres stratégies. | |
| Vous pouvez configurer le parallélisme de données avec [Accelerate](https://huggingface.co/docs/accelerate/index) ou directement avec [PyTorch Distributed](https://pytorch.org/tutorials/beginner/dist_overview.html). | |
| ## Accelerate | |
| Accelerate configure les processus et attribue un GPU à chacun d'entre eux. | |
| Installez Accelerate avec la commande suivante. | |
| ```bash | |
| uv pip install accelerate | |
| ``` | |
| Créez un [PartialState](https://huggingface.co/docs/accelerate/v1.15.0/en/package_reference/state#accelerate.PartialState) dans un fichier nommé `run_distributed.py` pour configurer l’environnement distribué. Déplacez le [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline) sur le `PartialState.device` pour attribuer une GPU à chaque processus. | |
| ```py | |
| import torch | |
| from accelerate import PartialState | |
| from diffusers import DiffusionPipeline | |
| pipeline = DiffusionPipeline.from_pretrained( | |
| "Qwen/Qwen-Image", dtype=torch.bfloat16 | |
| ) | |
| distributed_state = PartialState() | |
| pipeline.to(distributed_state.device) | |
| ``` | |
| Dans le même fichier, utilisez [split_between_processes](https://huggingface.co/docs/accelerate/v1.15.0/en/package_reference/state#accelerate.PartialState.split_between_processes) comme gestionnaire de contexte pour répartir les invites entre les processus. | |
| ```py | |
| with distributed_state.split_between_processes(["a dog", "a cat"]) as prompt: | |
| result = pipeline(prompt).images[0] | |
| result.save(f"result_{distributed_state.process_index}.png") | |
| ``` | |
| Exécutez le script avec `accelerate launch` et définissez `--num_processes` sur le nombre de GPU. | |
| ```bash | |
| accelerate launch --num_processes=2 run_distributed.py | |
| ``` | |
| > [!TIP] | |
| > Pour un exemple complet, consultez ce [script minimal d’inférence multi-GPU](https://gist.github.com/sayakpaul/cfaebd221820d7b43fae638b4dfa01ba). Pour en savoir plus, consultez le guide [Inférence distribuée avec Accelerate](https://huggingface.co/docs/accelerate/en/usage_guides/distributed_inference#distributed-inference-with-accelerate). | |
| ## PyTorch Distributed | |
| Vous pouvez également configurer le parallélisme de données directement avec `torch.distributed`, sans Accelerate. | |
| Appel [init_process_group](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) pour créer l’environnement distribué. `torchrun` définit le rang de chaque processus et le nombre total de processus (la taille du monde) via des variables d’environnement, vous n’avez donc pas besoin de les passer vous-même. | |
| Chaque processus a besoin de sa propre GPU et de son propre prompt. `torchrun` définit la variable d'environnement `LOCAL_RANK` sur l'indice de la GPU du processus sur son nœud, utilisez-la donc pour sélectionner la GPU. Utilisez `get_rank`, qui compte les processus sur tous les nœuds, pour sélectionner le prompt. | |
| ```py | |
| import os | |
| import torch | |
| import torch.distributed as dist | |
| from diffusers import DiffusionPipeline | |
| def main(): | |
| dist.init_process_group("nccl") | |
| rank = dist.get_rank() | |
| local_rank = int(os.environ["LOCAL_RANK"]) | |
| device = torch.device(f"cuda:{local_rank}") | |
| pipeline = DiffusionPipeline.from_pretrained( | |
| "Qwen/Qwen-Image", dtype=torch.bfloat16, | |
| ).to(device) | |
| prompts = ["a dog", "a cat"] | |
| prompt = prompts[rank] | |
| image = pipeline(prompt).images[0] | |
| image.save(f"{prompt.replace(' ', '_')}.png") | |
| dist.destroy_process_group() | |
| if __name__ == "__main__": | |
| main() | |
| ``` | |
| Enregistrez le script sous le nom `run_distributed.py` et exécutez-le avec `torchrun`. Définissez `--nproc-per-node` sur le nombre de GPU. La liste `prompts` contient un prompt par processus, ajoutez donc un prompt pour chaque GPU utilisé. | |
| ```bash | |
| torchrun --nproc-per-node 2 run_distributed.py | |
| ``` | |
Xet Storage Details
- Size:
- 4.41 kB
- Xet hash:
- 14b116135b44ec36154aa5b62e6746f86f5805b5ddede8eff87f8375a261bb3c
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.