Accelerate documentation

Inferencia distribuida

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Inferencia distribuida

La inferencia distribuida puede dividirse en dos categorías:

  1. Cargar un modelo completo en cada GPU y enviar fragmentos de un lote a través de la copia del modelo de cada GPU a la vez
  2. Cargar partes de un modelo en cada GPU y procesar una sola entrada a la vez

Esta guía cubre el primer paréntesis. Para el segundo, consulte Big Model Inference.

Envío automático de fragmentos de un lote a cada modelo cargado

Esta es la solución que más memoria consume, ya que requiere que cada GPU mantenga una copia completa del modelo en memoria en un momento dado.

Normalmente, al hacer esto, los usuarios envían el modelo a un dispositivo específico para cargarlo desde la CPU y luego mueven cada prompt a un dispositivo diferente.

Un pipeline básico usando la biblioteca diffusers podría verse así:

import torch
import torch.distributed as dist
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)

A continuación, se realiza la inferencia en función del prompt específico:

def run_inference(rank, world_size):
    dist.init_process_group("nccl", rank=rank, world_size=world_size)
    pipe.to(rank)

    if torch.distributed.get_rank() == 0:
        prompt = "a dog"
    elif torch.distributed.get_rank() == 1:
        prompt = "a cat"

    result = pipe(prompt).images[0]
    result.save(f"result_{rank}.png")

Se notará que hay que comprobar el rango para saber qué prompt enviar, lo cual puede resultar un poco tedioso.

Un usuario podría pensar que, con Accelerate, usar Accelerator para preparar un dataloader para una tarea de este tipo también podría ser una forma sencilla de gestionar esto. (Para saber más, consulta la sección correspondiente en Quick Tour)

¿Puede gestionarlo? Sí. ¿Añade, sin embargo, código extra innecesario? También sí.

Con Accelerate, podemos simplificar este proceso utilizando el gestor de contexto Accelerator.split_between_processes() (que también existe en PartialState y AcceleratorState). Esta función dividirá automáticamente los datos que le pases (ya sea un prompt, un conjunto de tensores, un diccionario de datos anteriores, etc.) entre todos los procesos (con la posibilidad de ser rellenados) para que los utilices de inmediato.

Reescribamos el ejemplo anterior utilizando este administrador de contexto:

import torch
from accelerate import PartialState  # Can also be Accelerator or AcceleratorState
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
distributed_state = PartialState()
pipe.to(distributed_state.device)

# Assume two processes
with distributed_state.split_between_processes(["a dog", "a cat"]) as prompt:
    result = pipe(prompt).images[0]
    result.save(f"result_{distributed_state.process_index}.png")

Y luego, para ejecutar el código, podemos usar Accelerate:

Si has generado un archivo de configuración para usarlo con accelerate config:

accelerate launch distributed_inference.py

Si tienes un archivo de configuración específico que quieres usar:

accelerate launch --config_file my_config.json distributed_inference.py

O si no quieres crear ningún archivo de configuración y lanzar en dos GPUs:

Nota: Recibirás algunas advertencias sobre valores que se han estimado en función de tu sistema. Para eliminarlas, puedes ejecutar accelerate config default o completar accelerate config para crear un archivo de configuración.

accelerate launch --num_processes 2 distributed_inference.py

Ahora hemos reducido el código de plantilla necesario para dividir estos datos a unas pocas líneas de código con bastante facilidad.

Pero, ¿qué pasa si tenemos una distribución impar de prompts entre las GPUs? Por ejemplo, ¿qué pasa si tenemos 3 prompts, pero solo 2 GPUs?

Bajo el gestor de contexto, la primera GPU recibiría los dos primeros prompts y la segunda GPU el tercero, garantizando que todos los prompts se dividan y que no se necesite sobrecarga.

Sin embargo, ¿qué pasaría si quisiéramos hacer algo con los resultados de todas las GPUs? (Por ejemplo, reunirlos todos y realizar algún tipo de posprocesamiento) Puedes pasar apply_padding=True para asegurarte de que las listas de prompts se rellenan hasta la misma longitud, tomando los datos adicionales de la última muestra. De esta forma, todas las GPUs tendrán el mismo número de prompts y podrás reunir los resultados.

Esto solo es necesario al intentar realizar una acción como recopilar los resultados, donde los datos en cada dispositivo deben tener la misma longitud. La inferencia básica no requiere esto.

Por ejemplo:

import torch
from accelerate import PartialState  # Can also be Accelerator or AcceleratorState
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
distributed_state = PartialState()
pipe.to(distributed_state.device)

# Assume two processes
with distributed_state.split_between_processes(["a dog", "a cat", "a chicken"], apply_padding=True) as prompt:
    result = pipe(prompt).images

En la primera GPU, los prompts serán ["a dog", "a cat"], y en la segunda GPU serán ["a chicken", "a chicken"]. Asegúrate de descartar la última muestra, ya que será un duplicado de la anterior.

Puedes encontrar ejemplos más complejos aquí, como cómo usarlo con LLMs.

Update on GitHub