Buckets:
| # Paralelismo de datos | |
| [Paralelismo de datos](https://huggingface.co/spaces/nanotron/ultrascale-playbook?section=data_parallelism) replica el mismo modelo en cada GPU y asigna a cada GPU diferentes prompts. Aumenta el rendimiento cuando el modelo ya cabe en una GPU y deja invariada la latencia de un solo prompt. Si aún no lo has hecho, prueba primero [Inferencia por lotes](../using-diffusers/batched_inference) en una GPU. Consulta [Inferencia distribuida](../training/distributed_inference) para compararlo con las demás estrategias. | |
| Puede configurar el paralelismo de datos con [Accelerate](https://huggingface.co/docs/accelerate/index) o directamente con [PyTorch Distributed](https://pytorch.org/tutorials/beginner/dist_overview.html). | |
| ## Accelerate | |
| Accelerate configura los procesos y asigna una GPU a cada uno. | |
| Instale Accelerate con el siguiente comando. | |
| ```bash | |
| uv pip install accelerate | |
| ``` | |
| Cree un [PartialState](https://huggingface.co/docs/accelerate/main/en/package_reference/state#accelerate.PartialState) en un archivo llamado `run_distributed.py` para configurar el entorno distribuido. Mueva el [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline) al `PartialState.device` para asignar una GPU a cada proceso. | |
| ```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) | |
| ``` | |
| En el mismo archivo, use [split_between_processes](https://huggingface.co/docs/accelerate/main/en/package_reference/state#accelerate.PartialState.split_between_processes) como un administrador de contexto para dividir los prompts entre procesos. | |
| ```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") | |
| ``` | |
| Ejecuta el script con `accelerate launch` y establece `--num_processes` en el número de GPUs. | |
| ```bash | |
| accelerate launch --num_processes=2 run_distributed.py | |
| ``` | |
| > [!TIP] | |
| > Para un ejemplo completo, consulte este [script de inferencia multi-GPU minimalista](https://gist.github.com/sayakpaul/cfaebd221820d7b43fae638b4dfa01ba). Para obtener más información, consulte la guía [Inferencia distribuida con Accelerate](https://huggingface.co/docs/accelerate/en/usage_guides/distributed_inference#distributed-inference-with-accelerate). | |
| ## PyTorch Distributed | |
| También puede configurar el paralelismo de datos directamente con `torch.distributed`, sin Accelerate. | |
| Llama a [init_process_group](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) para crear el entorno distribuido. `torchrun` establece el rango de cada proceso y el número total de procesos (el tamaño del mundo) a través de variables de entorno, por lo que no los pasas tú mismo. | |
| Cada proceso necesita su propia GPU y su propio prompt. `torchrun` establece la variable de entorno `LOCAL_RANK` con el índice de la GPU del proceso en su nodo, por lo que se debe usar para seleccionar la GPU. Utilice `get_rank`, que cuenta los procesos en todos los nodos, para seleccionar el 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() | |
| ``` | |
| Guarda el script como `run_distributed.py` y ejecútalo con `torchrun`. Establece `--nproc-per-node` al número de GPUs. La lista `prompts` tiene un prompt por proceso, así que añade un prompt para cada GPU que uses. | |
| ```bash | |
| torchrun --nproc-per-node 2 run_distributed.py | |
| ``` | |
Xet Storage Details
- Size:
- 4.18 kB
- Xet hash:
- e443b585cce3e33831b8464c7204c2cda53af1a0d3dc11fe8f3ea0eb8f9e55e3
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.