Diffusers documentation

Paralelismo

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Paralelismo

As estratégias de paralelismo ajudam a acelerar os difusão transformers distribuindo os cálculos entre vários dispositivos, permitindo tempos de inferência/treino mais rápidos. Consulte o guia Inferência distribuída para saber mais.

ParallelConfig

classe diffusers.ParallelConfig

< >

( context_parallel_config: diffusers.models._modeling_parallel.ContextParallelConfig | None = Nonetensor_parallel_config: diffusers.models._modeling_parallel.TensorParallelConfig | None = None_rank: int = None_world_size: int = None_device: device = None_mesh: DeviceMesh = None )

Parâmetros

  • context_parallel_config (ContextParallelConfig, opcional) — Configuração para paralelismo de contexto.
  • tensor_parallel_config (TensorParallelConfig, opcional) — Configuração para paralelismo de tensor.

Configuração para aplicar diferentes paralelismos.

ContextParallelConfig

classe diffusers.ContextParallelConfig

< >

( ring_degree: int | None = Noneulysses_degree: int | None = Noneconvert_to_fp32: bool = Truerotate_method: typing.Literal['allgather', 'alltoall'] = 'allgather'mesh: typing.Optional[torch.distributed.device_mesh.DeviceMesh] = Noneulysses_anything: bool = Falsering_anything: bool = False_rank: int = None_world_size: int = None_device: device = None_mesh: DeviceMesh = None_flattened_mesh: DeviceMesh = None_ring_mesh: DeviceMesh = None_ulysses_mesh: DeviceMesh = None_ring_local_rank: int = None_ulysses_local_rank: int = None )

Parâmetros

  • ring_degree (int, opcional, padrão 1) — Número de dispositivos a serem usados para Ring Attention. A sequência é dividida entre os dispositivos. Cada dispositivo calcula a atenção entre seus blocos locais de Q e KV, que são passados sequencialmente ao redor do anel. Menor uso de memória (mantém apenas 1/N de KV por vez), sobrepõe o cálculo à comunicação, mas requer N iterações para ver todos os tokens. Ideal para sequências longas com memória/largura de banda limitadas. Número de dispositivos a serem usados para ring attention dentro de uma região de paralelismo de contexto. Deve ser um divisor do número total de dispositivos na malha de paralelismo de contexto.
  • ulysses_degree (int, opcional, padrão 1) — Número de dispositivos a serem usados para Ulysses Attention. A sequência é dividida entre os dispositivos. Cada dispositivo calcula o QKV local e, em seguida, faz o all-gather de todos os blocos KV para calcular a atenção completa em uma única passagem. Maior uso de memória (armazena todos os KV), requer comunicação all-to-all de alta largura de banda, mas com menor latência. Ideal para sequências moderadas com boa largura de banda de interconexão.
  • convert_to_fp32 (bool, opcional, padrão True) — Se deve converter a saída e o LSE para float32 para estabilidade numérica do ring attention.
  • rotate_method (str, opcional, padrão "allgather") — Método a ser usado para rotacionar os estados de chave/valor entre dispositivos no ring attention. Atualmente, apenas "allgather" é suportado.
  • ulysses_anything (bool, opcional, padrão False) — Se deve ativar o modo “Ulysses Anything”, que suporta comprimentos de sequência e números de cabeças arbitrários que não são divisíveis uniformemente por ulysses_degree. Quando ativado, ulysses_degree deve ser maior que 1 e ring_degree deve ser 1.
  • ring_anything (bool, opcional, padrão False) — Se deve ativar o modo “Ring Anything”, que suporta comprimentos de sequência arbitrários. Quando ativado, ring_degree deve ser maior que 1 e ulysses_degree deve ser 1.
  • mesh (torch.distributed.device_mesh.DeviceMesh, opcional) — Um device mesh personalizado para usar em paralelismo de contexto. Se fornecido, este mesh será usado em vez de criar um novo. Isso é útil ao combinar paralelismo de contexto com outras estratégias de paralelismo (p. ex., FSDP, paralelismo de tensor) que compartilham o mesmo device mesh. O mesh deve ter as dimensões “ring” e “ulysses”. Use tamanho 1 para dimensões que não estão sendo usadas (p. ex., mesh_shape=(2, 1, 4) com mesh_dim_names=("ring", "ulysses", "fsdp") para apenas ring attention com FSDP).

Configuração para paralelismo de contexto.

diffusers.hooks.apply_context_parallel

< >

( module: Moduleparallel_config: ContextParallelConfigplan: dict[str, dict[str, dict[str | int, diffusers.models._modeling_parallel.ContextParallelInput | list[diffusers.models._modeling_parallel.ContextParallelInput] | tuple[diffusers.models._modeling_parallel.ContextParallelInput, ...]] | diffusers.models._modeling_parallel.ContextParallelOutput | list[diffusers.models._modeling_parallel.ContextParallelOutput] | tuple[diffusers.models._modeling_parallel.ContextParallelOutput, ...]]] )

Aplicar paralelismo de contexto em um modelo.

TensorParallelConfig

classe diffusers.TensorParallelConfig

< >

( tp_degree: int = 1mesh: typing.Optional[torch.distributed.device_mesh.DeviceMesh] = None_rank: int = None_world_size: int = None_device: device = None_mesh: DeviceMesh = None_tp_degree: int = None )

Parâmetros

  • tp_degree (int, padrão 1) — Número de dispositivos para dividir. Deve ser um divisor do número de cabeças de atenção (e dimensões ocultas do FFN) do modelo que está sendo paralelizado.
  • mesh (torch.distributed.device_mesh.DeviceMesh, opcional) — Um device mesh personalizado para usar. Se fornecido, tp_degree é inferido a partir de mesh.size() e o argumento é ignorado. Útil ao combinar TP com outras estratégias de paralelismo (por exemplo, CP) que compartilham o mesmo mesh.

Configuração para paralelismo de tensor.

O paralelismo de tensor divide as matrizes de pesos (por coluna e por linha) entre os dispositivos. Cada dispositivo calcula um resultado parcial; um AllReduce/AllGather nas fronteiras das camadas reconstrói a saída completa. Utiliza torch.distributed.tensor.parallelize_module com os estilos de divisão ColwiseParallel / RowwiseParallel. Os tipos de dispositivo suportados são "cuda", "neuron" e "tpu".

diffusers.hooks.apply_tensor_parallel

< >

( model: Moduleconfig: TensorParallelConfigtp_plan: dictweights_already_sharded: bool = False )

Parâmetros

  • model (torch.nn.Module) — O modelo a ser fragmentado no local.
  • config (TensorParallelConfig) — The tensor-parallel config. Its device mesh must already be set up with config.setup(...).
  • tp_plan (dict) — Um mapeamento plano de globs de nomes de módulos para um estilo "colwise"/"rowwise" (ou uma variante empacotada), geralmente o _tp_plan do modelo.
  • weights_already_sharded (bool, padrão False) — Indica se os parâmetros planejados já são shards de DTensor, como ocorre após um carregamento streaming de from_pretrained. Se True, apenas os forward hooks são registrados. Isso é passado explicitamente em vez de ser detectado, porque um parâmetro planejado ausente do checkpoint ainda seria um meta tensor e faria a detecção indicar “não shardado” para um modelo que, na verdade, está parcialmente shardado.

Aplique o paralelismo de tensor em um modelo a partir do seu _tp_plan plano.

Update on GitHub