# 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/main/en/package_reference/state#accelerate.PartialState) dans un fichier nommé `run_distributed.py` pour configurer l’environnement distribué. Déplacez le [DiffusionPipeline](/docs/diffusers/main/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/main/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
```