Diffusers documentation
Paralelismo
Paralelismo
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 Distributed inferece para saber mais.
ParallelConfig
classe diffusers.ParallelConfig
< source >( 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 )
Configuração para aplicar diferentes paralelismos.
ContextParallelConfig
classe diffusers.ContextParallelConfig
< source >( 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ão1) — 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ão1) — 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ãoTrue) — 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ãoFalse) — 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 porulysses_degree. Quando ativado,ulysses_degreedeve ser maior que 1 ering_degreedeve ser 1. - ring_anything (
bool, opcional, padrãoFalse) — Se deve ativar o modo “Ring Anything”, que suporta comprimentos de sequência arbitrários. Quando ativado,ring_degreedeve ser maior que 1 eulysses_degreedeve 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)commesh_dim_names=("ring", "ulysses", "fsdp")para apenas ring attention com FSDP).
Configuração para paralelismo de contexto.
diffusers.hooks.apply_context_parallel
< source >( module: Moduleparallel_config: ContextParallelConfigplan: dict )
Aplicar paralelismo de contexto em um modelo.
TensorParallelConfig
classe diffusers.TensorParallelConfig
< source >( 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ão1) — 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 demesh.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
< source >( 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 withconfig.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_plando modelo. - weights_already_sharded (
bool, padrãoFalse) — Indica se os parâmetros planejados já são shards deDTensor, como ocorre após um carregamento streaming defrom_pretrained. SeTrue, 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.