# Paralelismo

Las estrategias de paralelismo ayudan a acelerar los transformadores de difusión distribuyendo los cálculos en varios dispositivos, lo que permite tiempos de inferencia/entrenamiento más rápidos. Consulte la guía de [Inferencia distribuida](../training/distributed_inference) para obtener más información.

## ParallelConfig[[diffusers.ParallelConfig]]

#### diffusers.ParallelConfig[[diffusers.ParallelConfig]]

```python
diffusers.ParallelConfig(context_parallel_config: diffusers.models._modeling_parallel.ContextParallelConfig | None = None, tensor_parallel_config: diffusers.models._modeling_parallel.TensorParallelConfig | None = None, _rank: int = None, _world_size: int = None, _device: device = None, _mesh: DeviceMesh = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L199)

**Parámetros:**

context_parallel_config (`ContextParallelConfig`, *opcional*) : Configuración para el paralelismo de contexto.

tensor_parallel_config (`TensorParallelConfig`, *opcional*) : Configuración para la paralelización de tensores.

Configuración para aplicar diferentes paralelismos.

## ContextParallelConfig[[diffusers.ContextParallelConfig]]

#### diffusers.ContextParallelConfig[[diffusers.ContextParallelConfig]]

```python
diffusers.ContextParallelConfig(ring_degree: int | None = None, ulysses_degree: int | None = None, convert_to_fp32: bool = True, rotate_method: typing.Literal['allgather', 'alltoall'] = 'allgather', mesh: typing.Optional[torch.distributed.device_mesh.DeviceMesh] = None, ulysses_anything: bool = False, ring_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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L41)

**Parámetros:**

ring_degree (`int`, *opcional*, valor predeterminado `1`) : Número de dispositivos a utilizar para Ring Attention. La secuencia se divide entre los dispositivos. Cada dispositivo calcula la atención entre sus bloques locales de Q y KV que se pasan secuencialmente alrededor del anillo. Menor uso de memoria (solo mantiene 1/N de KV a la vez), solapa el cálculo con la comunicación, pero requiere N iteraciones para ver todos los tokens. Ideal para secuencias largas con memoria o ancho de banda limitados. Número de dispositivos a utilizar para ring attention dentro de una región de paralelismo de contexto. Debe ser un divisor del número total de dispositivos en la malla de paralelismo de contexto.

ulysses_degree (`int`, *opcional*, valor predeterminado `1`) : Número de dispositivos a utilizar para Ulysses Attention. La secuencia se divide entre los dispositivos. Cada dispositivo calcula el QKV local y luego realiza un all-gather de todos los fragmentos KV para calcular la atención completa en una sola pasada. Requiere más memoria (almacena todos los KV) y comunicación all-to-all de alto ancho de banda, pero tiene una latencia menor. Es ideal para secuencias moderadas con un buen ancho de banda de interconexión.

convert_to_fp32 (`bool`, *opcional*, por defecto `True`) : Si se debe convertir la salida y el LSE a float32 para la estabilidad numérica de ring attention.

rotate_method (`str`, *opcional*, por defecto `"allgather"`) : Método a utilizar para rotar los estados de clave/valor entre dispositivos en ring attention. Actualmente, solo se admite `"allgather"`.

ulysses_anything (`bool`, *opcional*, valor predeterminado `False`) : Si se habilita el modo "Ulysses Anything", que admite longitudes de secuencia y números de cabeceras arbitrarios que no son divisibles uniformemente por `ulysses_degree`. Cuando está habilitado, `ulysses_degree` debe ser mayor que 1 y `ring_degree` debe ser 1.

ring_anything (`bool`, *opcional*, valor predeterminado `False`) : Si se habilita el modo "Ring Anything", que admite longitudes de secuencia arbitrarias. Cuando está habilitado, `ring_degree` debe ser mayor que 1 y `ulysses_degree` debe ser 1.

mesh (`torch.distributed.device_mesh.DeviceMesh`, *opcional*) : Una malla de dispositivos personalizada para usar en la paralelización de contexto. Si se proporciona, esta malla se usará en lugar de crear una nueva. Esto es útil al combinar la paralelización de contexto con otras estrategias de paralelización (p. ej., FSDP, paralelización de tensores) que comparten la misma malla de dispositivos. La malla debe tener las dimensiones "ring" y "ulysses". Use tamaño 1 para las dimensiones que no se estén utilizando (p. ej., `mesh_shape=(2, 1, 4)` con `mesh_dim_names=("ring", "ulysses", "fsdp")` para solo ring attention con FSDP).

Configuración para el paralelismo de contexto.

#### diffusers.hooks.apply_context_parallel[[diffusers.hooks.apply_context_parallel]]

```python
diffusers.hooks.apply_context_parallel(module: Module, parallel_config: ContextParallelConfig, plan: 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, ...]]])
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/context_parallel.py#L80)

Aplicar el paralelismo de contexto en un modelo.

## TensorParallelConfig[[diffusers.TensorParallelConfig]]

#### diffusers.TensorParallelConfig[[diffusers.TensorParallelConfig]]

```python
diffusers.TensorParallelConfig(tp_degree: int = 1, mesh: 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/_modeling_parallel.py#L157)

**Parámetros:**

tp_degree (`int`, por defecto `1`) : Número de dispositivos en los que dividir. Debe ser un divisor del número de cabezas de atención (y dimensiones ocultas del FFN) del modelo que se está paralelizando.

mesh (`torch.distributed.device_mesh.DeviceMesh`, *opcional*) : Una malla de dispositivos personalizada para usar. Si se proporciona, `tp_degree` se infiere a partir de `mesh.size()` y el argumento se ignora. Útil al combinar TP con otras estrategias de paralelismo (p. ej. CP) que comparten la misma malla.

Configuración para el paralelismo de tensores.

La paralelización de tensores divide las matrices de pesos (por columnas y por filas) entre dispositivos. Cada dispositivo calcula un resultado parcial; un AllReduce/AllGather en los límites de las capas reconstruye la salida completa. Utiliza `torch.distributed.tensor.parallelize_module` con los estilos de partición `ColwiseParallel` / `RowwiseParallel`. Los tipos de dispositivo admitidos son `"cuda"`, `"neuron"` y `"tpu"`.

#### diffusers.hooks.apply_tensor_parallel[[diffusers.hooks.apply_tensor_parallel]]

```python
diffusers.hooks.apply_tensor_parallel(model: Module, config: TensorParallelConfig, tp_plan: dict, weights_already_sharded: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/tensor_parallel.py#L481)

**Parámetros:**

model (`torch.nn.Module`) : El modelo que se debe fragmentar in situ.

config (`TensorParallelConfig`) : La configuración de paralelismo de tensores. Su malla de dispositivos ya debe estar configurada con `config.setup(...)`.

tp_plan (`dict`) : Un mapeo plano de glob de nombres de módulos a un estilo `"colwise"`/`"rowwise"` (o una variante empaquetada), generalmente el `_tp_plan` del modelo.

weights_already_sharded (`bool`, por defecto `False`) : Indica si los parámetros planificados ya son fragmentos de `DTensor`, como ocurre después de una carga de `from_pretrained` en streaming. Si es `True`, solo se registran los hooks de forward. Este valor se pasa explícitamente en lugar de detectarse, porque un parámetro planificado que falte en el checkpoint seguiría siendo un tensor meta y haría que la detección indicara "no fragmentado" para un modelo que en realidad está medio fragmentado.

Aplicar la paralelización de tensores en un modelo a partir de su `_tp_plan` plano.