# Paralelismo de dados

[Paralelismo de dados](https://huggingface.co/spaces/nanotron/ultrascale-playbook?section=data_parallelism) replica o mesmo modelo em cada GPU e fornece prompts diferentes para cada GPU. Ele aumenta o throughput quando o modelo já cabe em uma única GPU e mantém a latência de um prompt único inalterada. Se ainda não fez, experimente [Inferência em lote](../using-diffusers/batched_inference) em uma única GPU primeiro. Consulte [Inferência distribuída](../training/distributed_inference) para compará-lo com as outras estratégias.

Você pode configurar o paralelismo de dados com [Accelerate](https://huggingface.co/docs/accelerate/index) ou diretamente com [PyTorch Distributed](https://pytorch.org/tutorials/beginner/dist_overview.html).

## Accelerate

O Accelerate configura os processos e atribui uma GPU a cada um deles.

Instale o Accelerate com o seguinte comando.

```bash
uv pip install accelerate
```

Crie um [PartialState](https://huggingface.co/docs/accelerate/main/en/package_reference/state#accelerate.PartialState) em um arquivo chamado `run_distributed.py` para configurar o ambiente distribuído. Mova o [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline) para o `PartialState.device` para atribuir uma GPU a cada processo.

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

No mesmo arquivo, use [split_between_processes](https://huggingface.co/docs/accelerate/main/en/package_reference/state#accelerate.PartialState.split_between_processes) como um gerenciador de contexto para dividir os prompts entre os processos.

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

Execute o script com `accelerate launch` e defina `--num_processes` para o número de GPUs.

```bash
accelerate launch --num_processes=2 run_distributed.py
```

> [!TIP]
> Para um exemplo completo, veja este [script de inferência multi-GPU minimalista](https://gist.github.com/sayakpaul/cfaebd221820d7b43fae638b4dfa01ba). Para saber mais, consulte o guia [Inferência distribuída com Accelerate](https://huggingface.co/docs/accelerate/en/usage_guides/distributed_inference#distributed-inference-with-accelerate).

## Distribuído do PyTorch

Você também pode configurar o paralelismo de dados diretamente com `torch.distributed`, sem o Accelerate.

Chame [init_process_group](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) para criar o ambiente distribuído. `torchrun` define o rank de cada processo e o número total de processos (o world size) por meio de variáveis de ambiente, então você não precisa passá-los manualmente.

Cada processo precisa de sua própria GPU e de seu próprio prompt. `torchrun` define a variável de ambiente `LOCAL_RANK` com o índice da GPU do processo em seu nó, portanto, use-a para escolher a GPU. Use `get_rank`, que conta os processos em todos os nós, para escolher o 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()
```

Salve o script como `run_distributed.py` e execute-o com `torchrun`. Defina `--nproc-per-node` para o número de GPUs. A lista `prompts` tem um prompt por processo, então adicione um prompt para cada GPU que você usar.

```bash
torchrun --nproc-per-node 2 run_distributed.py
```