# Funciones y clases de utilidad

A continuación se muestran diversas funciones de utilidad que proporciona 🤗 Accelerate, clasificadas por caso de uso.

## Constantes

Constantes utilizadas en todo 🤗 Accelerate como referencia

Los siguientes son constantes utilizadas al emplear [Accelerator.save_state()](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator.save_state)

`utils.MODEL_NAME`: `"pytorch_model"`
`utils.OPTIMIZER_NAME`: `"optimizer"`
`utils.RNG_STATE_NAME`: `"random_states"`
`utils.SCALER_NAME`: `"scaler.pt`
`utils.SCHEDULER_NAME`: `"scheduler`

Los siguientes son constantes utilizadas al emplear [Accelerator.save_model()](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator.save_model)

`utils.WEIGHTS_NAME`: `"pytorch_model.bin"`
`utils.SAFE_WEIGHTS_NAME`: `"model.safetensors"`
`utils.WEIGHTS_INDEX_NAME`: `"pytorch_model.bin.index.json"`
`utils.SAFE_WEIGHTS_INDEX_NAME`: `"model.safetensors.index.json"`

## Clases de datos

Estas son dataclasses básicas que se utilizan en todo 🤗 Accelerate y pueden pasarse como parámetros.

### Independiente[[accelerate.utils.ComputeEnvironment]]

Estas son dataclasses independientes que se utilizan para comprobaciones, como el tipo de sistema distribuido que se está utilizando

#### accelerate.utils.ComputeEnvironment[[accelerate.utils.ComputeEnvironment]]

```python
accelerate.utils.ComputeEnvironment(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L600)

Representa un tipo de entorno de cálculo.

Valores:

- **LOCAL_MACHINE** -- hardware de clúster privado/personalizado.
- **AMAZON_SAGEMAKER** -- Amazon SageMaker como entorno de cálculo.

#### accelerate.DistributedType[[accelerate.DistributedType]]

```python
accelerate.DistributedType(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L529)

Representa un tipo de entorno distribuido.

Valores:

- **NO** -- No es un entorno distribuido, solo un proceso único.
- **MULTI_CPU** -- Distribuido en varios nodos de CPU.
- **MULTI_GPU** -- Distribuido en varias GPU.
- **MULTI_MLU** -- Distribuido en varias MLU.
- **MULTI_SDAA** -- Distribuido en múltiples SDAAs.
- **MULTI_MUSA** -- Distribuido en múltiples MUSAs.
- **MULTI_NPU** -- Distribuido en múltiples NPUs.
- **MULTI_XPU** -- Distribuido en múltiples XPUs.
- **MULTI_HPU** -- Distribuido en varios HPU.
- **MULTI_NEURON** -- Distribuido en varios núcleos Neuron.
- **DEEPSPEED** -- Uso de DeepSpeed.
- **FSDP** -- Uso de Fully Sharded Data Parallelism (FSDP).
- **XLA** -- Uso de TorchXLA.
- **MEGATRON_LM** -- Uso de Megatron-LM.

#### accelerate.utils.DynamoBackend[[accelerate.utils.DynamoBackend]]

```python
accelerate.utils.DynamoBackend(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L615)

Representa un backend de dynamo (consulte https://pytorch.org/docs/stable/torch.compiler.html).

Valores:

- **NO** -- No utilices torch dynamo.
- **EAGER** -- Utiliza PyTorch para ejecutar el GraphModule extraído. Esto resulta bastante útil para depurar problemas de TorchDynamo.
- **AOT_EAGER** -- Utiliza AotAutograd sin compilador, es decir, solo usa PyTorch eager para los grafos de forward y backward extraídos por AotAutograd. Esto es útil para depurar y es poco probable que ofrezca mejoras de velocidad.
- **INDUCTOR** -- Utiliza el backend TorchInductor con AotAutograd y cudagraphs aprovechando kernels de Triton generados por código. [Leer más](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- nvFuser con AotAutograd/TorchScript. [Leer más](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- nvFuser con PrimTorch. [Leer más](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** -- cudagraphs con AotAutograd. [Leer más](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Utiliza Torchscript optimize_for_inference. Solo para inferencia. [Leer más](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- Utiliza Nvidia TensorRT para optimizaciones de inferencia. Solo inferencia. [Leer más](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- Utiliza ONNXRT para la inferencia en CPU/GPU. Solo inferencia. [Leer más](https://onnxruntime.ai/)
- **TENSORRT** -- Utiliza ONNXRT para ejecutar TensorRT con fines de optimización de inferencia. [Leer más](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- Utiliza Pytorch/XLA con la optimización de TorchDynamo, para el entrenamiento. [Leer más](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- Utiliza Pytorch/XLA con la optimización de TorchDynamo, para inferencia. [Leer más](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Utiliza Apache TVM para optimizaciones de inferencia. [Leer más](https://tvm.apache.org/)
- **HPU_BACKEND** -- Utiliza el backend HPU para optimizaciones de inferencia.
- **NEURON** -- Utiliza el backend AWS Neuron para Trainium/Inferentia.

#### accelerate.utils.LoggerType[[accelerate.utils.LoggerType]]

```python
accelerate.utils.LoggerType(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L670)

Representa un tipo de rastreador de experimentos admitido

Valores:

- **TODOS** -- todos los trackers disponibles en el entorno que son compatibles
- **TENSORBOARD** -- TensorBoard como rastreador de experimentos
- **WANDB** -- wandb como rastreador de experimentos
- **TRACKIO** -- trackio como registrador de experimentos
- **COMETML** -- comet_ml como un rastreador de experimentos
- **MLFLOW** -- mlflow como rastreador de experimentos
- **CLEARML** -- clearml como registrador de experimentos
- **DVCLIVE** -- dvclive como rastreador de experimentos
- **SWANLAB** -- swanlab como registrador de experimentos

#### accelerate.utils.PrecisionType[[accelerate.utils.PrecisionType]]

```python
accelerate.utils.PrecisionType(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L698)

Representa un tipo de precisión utilizado en valores de punto flotante

Valores:

- **NO** -- usando precisión completa (FP32)
- **FP16** -- usando media precisión
- **BF16** -- usando precisión de coma flotante cerebral

#### accelerate.utils.RNGType[[accelerate.utils.RNGType]]

```python
accelerate.utils.RNGType(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L714)

#### accelerate.utils.SageMakerDistributedType[[accelerate.utils.SageMakerDistributedType]]

```python
accelerate.utils.SageMakerDistributedType(*values)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L568)

Representa un tipo de entorno distribuido.

Valores:

- **NO** -- No es un entorno distribuido, solo un proceso único.
- **DATA_PARALLEL** -- usando la paralelización distribuida de datos de sagemaker.
- **MODEL_PARALLEL** -- uso de la paralelización distribuida de modelos de sagemaker.

### Kwargs[[accelerate.AutocastKwargs]]

Estos son argumentos configurables para interacciones específicas en todo el ecosistema de PyTorch que Accelerate gestiona internamente.

#### accelerate.AutocastKwargs[[accelerate.AutocastKwargs]]

```python
accelerate.AutocastKwargs(enabled: bool = True, cache_enabled: bool | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L109)

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar el comportamiento de `torch.autocast`. Consulte la documentación de este [context manager](https://pytorch.org/docs/stable/amp.html#torch.autocast) para obtener más información sobre cada argumento.

Ejemplo:

```python
from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.DistributedDataParallelKwargs[[accelerate.DistributedDataParallelKwargs]]

```python
accelerate.DistributedDataParallelKwargs(dim: int = 0, broadcast_buffers: bool = True, bucket_cap_mb: int = 25, find_unused_parameters: bool = False, check_reduction: bool = False, gradient_as_bucket_view: bool = False, static_graph: bool = False, comm_hook: DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>, comm_wrapper: typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>, comm_state_option: dict = <factory>)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L151)

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar cómo se envuelve su modelo en un `torch.nn.parallel.DistributedDataParallel`. Consulte la documentación de este [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) para obtener más información sobre cada argumento.

Ejemplo:

```python
from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.GradScalerKwargs[[accelerate.GradScalerKwargs]]

```python
accelerate.GradScalerKwargs(init_scale: float = 65536.0, growth_factor: float = 2.0, backoff_factor: float = 0.5, growth_interval: int = 2000, enabled: bool = True)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L229)

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar el comportamiento de la precisión mixta, específicamente cómo se crea el `torch.amp.GradScaler` o `torch.cuda.amp.GradScaler` que se utiliza. Consulte la documentación de este [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) para obtener más información sobre cada argumento.

Ejemplo:

```python
from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=0.25)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.InitProcessGroupKwargs[[accelerate.InitProcessGroupKwargs]]

```python
accelerate.InitProcessGroupKwargs(backend: str | None = 'nccl', init_method: str | None = None, timeout: datetime.timedelta | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L254)

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar la inicialización de los procesos distribuidos. Consulte la documentación de este [método](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) para obtener más información sobre cada argumento.

Nota: Si `timeout` se establece en `None`, el valor predeterminado se basará en cómo se configure `backend`.

```python
from datetime import timedelta
from accelerate import Accelerator
from accelerate.utils import InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.utils.KwargsHandler[[accelerate.utils.KwargsHandler]]

```python
accelerate.utils.KwargsHandler()
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L64)

Mixin interno que implementa un método `to_kwargs()` para un dataclass.

#### to_kwargs[[accelerate.utils.KwargsHandler.to_kwargs]]

```python
to_kwargs()
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L72)

Devuelve un diccionario que contiene los atributos con valores diferentes de los valores predeterminados de esta clase.

## Plugins[[accelerate.DeepSpeedPlugin]]

Estos son complementos que pueden pasarse al objeto [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator). Aunque se definen en otras partes de la documentación, por comodidad todos están disponibles para verlos aquí:

#### accelerate.DeepSpeedPlugin[[accelerate.DeepSpeedPlugin]]

```python
accelerate.DeepSpeedPlugin(hf_ds_config: Any = None, gradient_accumulation_steps: int = None, gradient_clipping: float = None, zero_stage: int = None, is_train_batch_min: bool = True, offload_optimizer_device: str = None, offload_param_device: str = None, offload_optimizer_nvme_path: str = None, offload_param_nvme_path: str = None, zero3_init_flag: bool = None, zero3_save_16bit_model: bool = None, transformer_moe_cls_names: str = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1047)

**Parámetros:**

hf_ds_config (`Any`, por defecto `None`) : Ruta al archivo de configuración de DeepSpeed o a un diccionario o a un objeto de la clase `accelerate.utils.deepspeed.HfDeepSpeedConfig`.

gradient_accumulation_steps (`int`, por defecto `None`) : Número de pasos para acumular gradientes antes de actualizar los estados del optimizador. Si no se establece, se usará el valor de `Accelerator` directamente.

gradient_clipping (`float`, por defecto `None`) : Habilita el recorte de gradientes con el valor indicado.

zero_stage (`int`, por defecto `None`) : Las opciones posibles son 0, 1, 2, 3. El valor por defecto se tomará de la variable de entorno.

is_train_batch_min (`bool`, por defecto `True`) : Si se especifican tanto los dataloaders de entrenamiento como de evaluación, esto determinará el `train_batch_size`.

offload_optimizer_device (`str`, por defecto `None`) : Las opciones posibles son none|cpu|nvme. Solo aplicable con las etapas 2 y 3 de ZeRO.

offload_param_device (`str`, por defecto `None`) : Las opciones posibles son none|cpu|nvme. Solo aplicable con ZeRO Stage 3.

offload_optimizer_nvme_path (`str`, por defecto `None`) : Las opciones posibles son /nvme|/local_nvme. Solo aplicable con ZeRO Stage 3.

offload_param_nvme_path (`str`, por defecto `None`) : Las opciones posibles son /nvme|/local_nvme. Solo aplicable con ZeRO Stage 3.

zero3_init_flag (`bool`, por defecto `None`) : Bandera para indicar si se debe guardar el modelo de 16 bits. Solo aplicable con ZeRO Stage-3.

zero3_save_16bit_model (`bool`, por defecto `None`) : Bandera para indicar si se debe guardar el modelo de 16 bits. Solo aplicable con ZeRO Stage-3.

transformer_moe_cls_names (`str`, por defecto `None`) : Lista separada por comas de nombres de clases de capas MoE de Transformers (distingue entre mayúsculas y minúsculas). Por ejemplo, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention`, `JetMoEBlock`, etc.

Este plugin se utiliza para integrar DeepSpeed.

#### deepspeed_config_process[[accelerate.DeepSpeedPlugin.deepspeed_config_process]]

```python
deepspeed_config_process(prefix = '', mismatches = None, config = None, must_match = True, **kwargs)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1283)

Procesa la configuración de DeepSpeed con los valores de kwargs.

#### seleccionar[[accelerate.DeepSpeedPlugin.select]]

```python
select(_from_accelerator_state: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1438)

Establece el HfDeepSpeedWeakref para que utilice la configuración actual del plugin de deepspeed

#### accelerate.FullyShardedDataParallelPlugin[[accelerate.FullyShardedDataParallelPlugin]]

```python
accelerate.FullyShardedDataParallelPlugin(fsdp_version: int = None, sharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = None, reshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = None, backward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = None, mixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = None, auto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = None, cpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = None, ignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = None, state_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = None, state_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = None, optim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = None, limit_all_gathers: bool = True, use_orig_params: bool | None = None, param_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = None, sync_module_states: bool | None = None, forward_prefetch: bool = None, activation_checkpointing: bool = None, activation_checkpointing_offload: bool = None, cpu_ram_efficient_loading: bool = None, transformer_cls_names_to_wrap: list[str] | None = None, min_num_params: int | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1470)

**Parámetros:**

fsdp_version (`int`, por defecto `1`) : La versión de FSDP a utilizar. Por defecto es 1. Si se establece en 2, el launcher espera que la configuración esté convertida al formato FSDP2.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, por defecto `'FULL_SHARD'`) : Estrategia de particionamiento a utilizar. Debe ser una `str` o una instancia de `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`. Está en desuso a favor de `reshard_after_forward`.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, por defecto `'FULL_SHARD'` para `fsdp_version=1` y `True` para `fsdp_version=2`) : Estrategia de sharding a utilizar. Debe ser un bool si `fsdp_version` está establecido en 2, en caso contrario, un `str` o una instancia de `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, por defecto `'NO_PREFETCH'`) : Estrategia de prefetch hacia atrás a utilizar. Debe ser una `str` o una instancia de `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, por defecto `None`) : Una configuración para habilitar el entrenamiento con precisión mixta mediante FullyShardedDataParallel. Si se pasa un `dict`, debe tener las siguientes claves: `param_dtype`, `reduce_dtype` y `buffer_dtype`; puede ser una instancia de `torch.distributed.fsdp.MixedPrecisionPolicy` si `fsdp_version` está establecido en 2. Si se pasa un `str`, debe ser uno de los siguientes valores: fp8, fp16, bf16, fp32, y se utiliza para establecer `param_dtype`, `reduce_dtype` y `buffer_dtype`.

auto_wrap_policy (`Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to `NO_WRAP`) : A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of `transformer_based_wrap`, `size_based_wrap`, or `no_wrap`. See `torch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like.

cpu_offload (`Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy]`, por defecto `False`) : Si se deben descargar los parámetros a la CPU. Debe ser un `bool` o una instancia de `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` o `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy` si `fsdp_version` está establecido en 2.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, por defecto `None`) : Una lista de módulos para ignorar al envolver con FSDP. Al pasar una cadena, coincidirá con los módulos por nombre usando regex fullmatch. Si `fsdp_version` está establecido en 2, los módulos se convierten en parámetros y se usan.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, por defecto `'FULL_STATE_DICT'`) : Tipo de state dict a utilizar. Si es una cadena, debe ser uno de `full_state_dict`, `local_state_dict` o `sharded_state_dict`.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, por defecto `None`) : Configuración del state dict a utilizar. Se determina en función de `state_dict_type` si no se proporciona.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, por defecto `None`) : Configuración del state dict de optimizador a utilizar. Se determina en función de `state_dict_type` si no se proporciona.

limit_all_gathers (`bool`, por defecto `True`) : Si FSDP debe sincronizar explícitamente el hilo de CPU para evitar demasiados all-gathers en curso. Este bool solo afecta a las estrategias fragmentadas que programan all-gathers. Habilitar esto puede ayudar a reducir el número de reintentos de malloc de CUDA.

use_orig_params (`bool`, por defecto `False`) : Si se deben usar los parámetros originales para el optimizador.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, por defecto `None`) : Un `Callable[torch.nn.Module] -> None` que especifica cómo deben inicializarse en un dispositivo real los módulos que actualmente están en el dispositivo meta. Solo es aplicable cuando `sync_module_states` es `True`. Por defecto, es un `lambda` que llama a `to_empty` en el módulo.

sync_module_states (`bool`, por defecto `False`) : Si cada unidad FSDP envuelta individualmente debe difundir los parámetros del módulo desde el rango 0 para garantizar que sean los mismos en todos los rangos después de la inicialización. Por defecto es `False` a menos que `cpu_ram_efficient_loading` sea `True`, en cuyo caso se habilitará forzosamente.

forward_prefetch (`bool`, por defecto `False`) : Si FSDP debe preobtener explícitamente el próximo all-gather mientras se ejecuta en la pasada hacia adelante. Úsalo solo con grafos estáticos.

activation_checkpointing (`bool`, por defecto `False`) : Una técnica para reducir el uso de memoria borrando las activaciones de ciertas capas y recalcándolas durante una pasada hacia atrás. En la práctica, esto intercambia tiempo de cálculo adicional por un menor uso de memoria.

cpu_ram_efficient_loading (`bool`, por defecto `None`) : Si es True, solo el primer proceso carga el punto de control del modelo preentrenado, mientras que todos los demás procesos tienen pesos vacíos. Solo aplicable para Transformers. Al usar esto, `sync_module_states` debe ser `True`.

transformer_cls_names_to_wrap (`Optional[List[str]]`, por defecto `None`) : Una lista de nombres de clases de capas de transformador para envolver. Solo aplicable cuando `auto_wrap_policy` es `transformer_based_wrap`.

min_num_params (`Optional[int]`, por defecto `None`) : El número mínimo de parámetros que debe tener un módulo para ser envuelto. Solo aplicable cuando `auto_wrap_policy` es `size_based_wrap`.

Este plugin se utiliza para habilitar el paralelismo de datos totalmente fragmentado.

#### set_auto_wrap_policy[[accelerate.FullyShardedDataParallelPlugin.set_auto_wrap_policy]]

```python
set_auto_wrap_policy(model)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1955)

Dado `model`, crea una `auto_wrap_policy` basada en la política pasada y si podemos usar `transformer_cls_to_wrap`

#### set_mixed_precision[[accelerate.FullyShardedDataParallelPlugin.set_mixed_precision]]

```python
set_mixed_precision(mixed_precision, buffer_autocast = False, override = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1995)

Establece la política de precisión mixta para FSDP

#### set_state_dict_type[[accelerate.FullyShardedDataParallelPlugin.set_state_dict_type]]

```python
set_state_dict_type(state_dict_type = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1910)

Establece la configuración del state dict en función del `StateDictType`.

#### validate_mixed_precision_policy[[accelerate.FullyShardedDataParallelPlugin.validate_mixed_precision_policy]]

```python
validate_mixed_precision_policy()
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2043)

Valida la política de precisión mixta, abstraída para no importar las dependencias si no son necesarias.

#### accelerate.utils.GradientAccumulationPlugin[[accelerate.utils.GradientAccumulationPlugin]]

```python
accelerate.utils.GradientAccumulationPlugin(num_steps: int = None, adjust_scheduler: bool = True, sync_with_dataloader: bool = True, sync_each_batch: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L906)

**Parámetros:**

num_steps (`int`) : El número de pasos para acumular gradientes.

adjust_scheduler (`bool`, *opcional*, valor predeterminado `True`) : Si se deben ajustar los pasos del programador para tener en cuenta el número de pasos acumulados. Debe ser `True` si el programador utilizado no se ajustó para la acumulación de gradientes.

sync_with_dataloader (`bool`, *opcional*, por defecto `True`) : Si se debe sincronizar la configuración de los gradientos al final del dataloader.

sync_each_batch (`bool`, *opcional*) : Si se sincroniza la configuración de los gradientes en cada lote de datos. Establecerlo en `True` puede reducir los requisitos de memoria al usar acumulación de gradientes con entrenamiento distribuido, a costa de la velocidad.

Un plugin para configurar el comportamiento de la acumulación de gradientes. Solo puede pasar uno de `gradient_accumulation_plugin` o `gradient_accumulation_steps` a [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator). Pasar ambos provoca un error.

Ejemplo:

```python
from accelerate.utils import GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=2)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)
```

#### accelerate.utils.MegatronLMPlugin[[accelerate.utils.MegatronLMPlugin]]

```python
accelerate.utils.MegatronLMPlugin(tp_degree: int = None, pp_degree: int = None, use_custom_fsdp: bool = None, overlap_cpu_optimizer_d2h_h2d: bool = None, no_load_optim: bool = None, eod_mask_loss: bool = None, no_save_optim: bool = None, optimizer_cpu_offload: bool = None, use_precision_aware_optimizer: bool = None, decoder_last_pipeline_num_layers: int = None, recompute_granularity: str = None, recompute_method: str = None, recompute_num_layers: int = None, attention_backend: bool = None, expert_model_parallel_size: int = None, context_parallel_size: int = None, attention_dropout: float = None, hidden_dropout: float = None, attention_softmax_in_fp32: bool = None, expert_tensor_parallel_size: int = None, calculate_per_token_loss: bool = None, use_rotary_position_embeddings: bool = None, num_micro_batches: int = None, gradient_clipping: float = None, sequence_parallelism: bool = None, recompute_activations: bool = None, use_distributed_optimizer: bool = None, pipeline_model_parallel_split_rank: int = None, num_layers_per_virtual_pipeline_stage: int = None, is_train_batch_min: str = True, train_iters: int = None, train_samples: int = None, weight_decay_incr_style: str = 'constant', start_weight_decay: float = None, end_weight_decay: float = None, lr_decay_style: str = 'linear', lr_decay_iters: int = None, lr_decay_samples: int = None, lr_warmup_iters: int = None, lr_warmup_samples: int = None, lr_warmup_fraction: float = None, min_lr: float = 0, consumed_samples: list = None, no_wd_decay_cond: typing.Callable | None = None, scale_lr_cond: typing.Callable | None = None, lr_mult: float = 1.0, megatron_dataset_flag: bool = False, seq_length: int = None, encoder_seq_length: int = None, decoder_seq_length: int = None, tensorboard_dir: str = None, set_all_logging_options: bool = False, eval_iters: int = 100, eval_interval: int = 1000, return_logits: bool = False, custom_train_step_class: typing.Any | None = None, custom_train_step_kwargs: dict[str, typing.Any] | None = None, custom_model_provider_function: typing.Callable | None = None, custom_prepare_model_function: typing.Callable | None = None, custom_megatron_datasets_provider_function: typing.Callable | None = None, custom_get_batch_function: typing.Callable | None = None, custom_loss_function: typing.Callable | None = None, other_megatron_args: dict[str, typing.Any] | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2205)

**Parámetros:**

tp_degree (`int`, por defecto `None`) : Grado de paralelismo de tensor.

pp_degree (`int`, por defecto `None`) : Grado de paralelismo de pipeline.

num_micro_batches (`int`, por defecto `None`) : Número de micro-lotes.

gradient_clipping (`float`, por defecto `None`) : Valor de recorte de gradiente basado en la norma L2 global (0 para desactivar).

sequence_parallelism (`bool`, por defecto `None`) : Habilita el paralelismo de secuencias.

recompute_activations (`bool`, por defecto `None`) : Habilita la recomputación selectiva de activaciones.

use_distributed_optimizer (`bool`, por defecto `None`) : Habilita el optimizador distribuido.

pipeline_model_parallel_split_rank (`int`, por defecto `None`) : Rango donde se deben dividir el codificador y el decodificador.

num_layers_per_virtual_pipeline_stage (`int`, por defecto `None`) : Número de capas por etapa de pipeline virtual.

is_train_batch_min (`str`, por defecto `True`) : Si se especifican tanto los dataloaders de entrenamiento como de evaluación, esto determinará el `micro_batch_size`.

train_iters (`int`, por defecto `None`) : Número total de muestras para entrenar en todas las ejecuciones de entrenamiento. Tenga en cuenta que debe proporcionar train-iters o train-samples al usar `MegatronLMDummyScheduler`.

train_samples (`int`, por defecto `None`) : Número total de muestras para entrenar en todas las ejecuciones de entrenamiento. Tenga en cuenta que debe proporcionar train-iters o train-samples al usar `MegatronLMDummyScheduler`.

weight_decay_incr_style (`str`, por defecto `'constant'`) : Función de incremento del decaimiento de peso. opciones=["constant", "linear", "cosine"].

start_weight_decay (`float`, por defecto `None`) : Coeficiente inicial de decaimiento de peso para la regularización L2.

end_weight_decay (`float`, por defecto `None`) : Coeficiente de decaimiento del peso al final de la ejecución para la regularización L2.

lr_decay_style (`str`, por defecto `'linear'`) : Función de decaimiento de la tasa de aprendizaje. choices=['constant', 'linear', 'cosine'].

lr_decay_iters (`int`, por defecto `None`) : Número de iteraciones para el decaimiento de la tasa de aprendizaje. Si es None, por defecto es `train_iters`.

lr_decay_samples (`int`, por defecto `None`) : Número de muestras para el decaimiento de la tasa de aprendizaje. Si es None, por defecto es `train_samples`.

lr_warmup_iters (`int`, por defecto `None`) : Número de iteraciones para calentar linealmente la tasa de aprendizaje.

lr_warmup_samples (`int`, por defecto `None`) : Número de muestras para calentar linealmente la tasa de aprendizaje.

lr_warmup_fraction (`float`, por defecto `None`) : Fracción de lr-warmup-(iters/samples) sobre la que se calienta linealmente la tasa de aprendizaje.

min_lr (`float`, por defecto `0`) : Valor mínimo para la tasa de aprendizaje. El programador recorta los valores por debajo de este umbral.

consumed_samples (`List`, por defecto `None`) : Número de muestras consumidas en el mismo orden que los dataloaders para la llamada a `accelerator.prepare`.

no_wd_decay_cond (`Optional`, defaults to `None`) : Condition to disable weight decay.

scale_lr_cond (`Optional`, defaults to `None`) : Condition to scale learning rate.

lr_mult (`float`, por defecto `1.0`) : Multiplicador de la tasa de aprendizaje.

megatron_dataset_flag (`bool`, por defecto `False`) : Si el formato del conjunto de datos sigue el formato Indexed/Cached/MemoryMapped de Megatron-LM.

seq_length (`int`, por defecto `None`) : Longitud máxima de la secuencia a procesar.

encoder_seq_length (`int`, por defecto `None`) : Longitud máxima de secuencia a procesar para el codificador.

decoder_seq_length (`int`, por defecto `None`) : Longitud máxima de secuencia a procesar para el decodificador.

tensorboard_dir (`str`, por defecto `None`) : Ruta para guardar los registros de tensorboard.

set_all_logging_options (`bool`, por defecto `False`) : Si se deben establecer todas las opciones de registro.

eval_iters (`int`, por defecto `100`) : Número de iteraciones para ejecutar la validación/prueba de evaluación.

eval_interval (`int`, por defecto `1000`) : Intervalo entre la ejecución de la evaluación en el conjunto de validación.

return_logits (`bool`, por defecto `False`) : Si se deben devolver los logits del modelo.

custom_train_step_class (`Optional`, por defecto `None`) : Clase de paso de entrenamiento personalizada.

custom_train_step_kwargs (`Optional`, defaults to `None`) : Custom train step kwargs.

custom_model_provider_function (`Optional`, por defecto `None`) : Función de proveedor de modelo personalizada.

custom_prepare_model_function (`Optional`, por defecto `None`) : Función de preparación de modelo personalizada.

custom_megatron_datasets_provider_function (`Optional`, defaults to `None`) : Custom megatron train_valid_test datasets provider function.

custom_get_batch_function (`Optional`, defaults to `None`) : Custom get batch function.

custom_loss_function (`Optional`, por defecto `None`) : Función de pérdida personalizada.

other_megatron_args (`Optional`, por defecto `None`) : Otros argumentos de Megatron-LM. Consulte Megatron-LM.

Plugin para Megatron-LM que habilita el paralelismo de tensor, pipeline, secuencia y datos. También habilita la recomputación selectiva de activaciones y los kernels fusionados optimizados.

#### accelerate.utils.TorchDynamoPlugin[[accelerate.utils.TorchDynamoPlugin]]

```python
accelerate.utils.TorchDynamoPlugin(backend: DynamoBackend = None, mode: str = None, fullgraph: bool = None, dynamic: bool = None, options: Any = None, disable: bool = False, use_regional_compilation: bool = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L958)

**Parámetros:**

backend (`DynamoBackend`, por defecto `None`) : Un backend de Dynamo válido. Consulte https://pytorch.org/docs/stable/torch.compiler.html para obtener más detalles.

mode (`str`, por defecto `None`) : Las opciones posibles son 'default', 'reduce-overhead' o 'max-autotune'.

fullgraph (`bool`, por defecto `None`) : Si es aceptable dividir el modelo en varios subgrafos.

dynamic (`bool`, por defecto `None`) : Si se debe usar una forma dinámica para el trazado.

options (`Any`, por defecto `None`) : Un diccionario de opciones para pasar al backend.

disable (`bool`, por defecto `False`) : Convierte torch.compile() en una operación sin efecto para pruebas

use_regional_compilation (`bool`, por defecto `None`) : Úsalo para reducir el tiempo de compilación en frío de torch.compile() dirigiéndote a bloques repetidos de la misma clase y compilándolos secuencialmente para aprovechar la caché del compilador. Por ejemplo, en `GPT2LMHeadModel`, el bloque/clase repetido es `GPT2Block`, y se puede acceder a él como `model.transformer.h[0]`. El resto del modelo (p. ej. model.lm_head) se compila por separado.

Este plugin se utiliza para compilar un modelo con PyTorch 2.0

## Configuraciones[[accelerate.utils.BnbQuantizationConfig]]

Estas son clases que se pueden configurar y pasar a la integración correspondiente

#### accelerate.utils.BnbQuantizationConfig[[accelerate.utils.BnbQuantizationConfig]]

```python
accelerate.utils.BnbQuantizationConfig(load_in_8bit: bool = False, llm_int8_threshold: float = 6.0, load_in_4bit: bool = False, bnb_4bit_quant_type: str = 'fp4', bnb_4bit_use_double_quant: bool = False, bnb_4bit_compute_dtype: str = 'fp16', torch_dtype: dtype = None, skip_modules: list = None, keep_in_fp32_modules: list = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2944)

**Parámetros:**

load_in_8bit (`bool`, por defecto `False`) : Habilita la cuantización de 8 bits.

llm_int8_threshold (`float`, por defecto `6.0`) : Valor del umbral del outliner. Solo es relevante cuando `load_in_8bit=True`.

load_in_4bit (`bool`, por defecto `False`) : Habilita la cuantización de 4 bits.

bnb_4bit_quant_type (`str`, por defecto `fp4`) : Establece el tipo de datos de cuantización en las capas `bnb.nn.Linear4Bit`. Las opciones son {'fp4','np4'}.

bnb_4bit_use_double_quant (`bool`, por defecto `False`) : Habilita la cuantización anidada, donde las constantes de cuantización de la primera cuantización se cuantizan de nuevo.

bnb_4bit_compute_dtype (`bool`, por defecto `fp16`) : Esto establece el tipo de cómputo, que puede ser diferente al tipo de entrada. Por ejemplo, las entradas pueden ser fp32, pero el cómputo puede configurarse en bf16 para obtener mejoras de velocidad. Las opciones son {'fp32','fp16','bf16'}.

torch_dtype (`torch.dtype`, por defecto `None`) : Esto establece el dtype de las capas restantes no cuantizadas. La biblioteca `bitsandbytes` sugiere establecer el valor en `torch.float16` para modelos de 8 bits y usar el mismo dtype que el dtype de cálculo para modelos de 4 bits.

skip_modules (`List[str]`, por defecto `None`) : Una lista explícita de los módulos que no cuantizamos. El dtype de estos módulos será `torch_dtype`.

keep_in_fp32_modules (`List`, por defecto `None`) : Una lista explícita de los módulos que no cuantizamos. Los mantenemos en `torch.float32`.

Un plugin para habilitar la cuantización de 4 bits y 8 bits de BitsAndBytes

#### accelerate.DataLoaderConfiguration[[accelerate.DataLoaderConfiguration]]

```python
accelerate.DataLoaderConfiguration(split_batches: bool = False, dispatch_batches: bool = None, even_batches: bool = True, use_seedable_sampler: bool = False, data_seed: int = None, non_blocking: bool = False, use_stateful_dataloader: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L748)

**Parámetros:**

split_batches (`bool`, por defecto `False`) : Indica si el acelerador debe dividir los lotes generados por los dataloaders entre los dispositivos. Si es `True`, el tamaño de lote real utilizado será el mismo en cualquier tipo de procesos distribuidos, pero debe ser un múltiplo exacto de `num_processes` que estés utilizando. Si es `False`, el tamaño de lote real utilizado será el establecido en tu script multiplicado por el número de procesos.

dispatch_batches (`bool`, por defecto `None`) : Si se establece en `True`, el dataloader preparado por el Accelerator solo se itera en el proceso principal y luego los lotes se dividen y se difunden a cada proceso. Por defecto será `True` para un `DataLoader` cuyo conjunto de datos subyacente es un `IterableDataset`, y `False` en caso contrario.

even_batches (`bool`, por defecto `True`) : Si se establece en `True`, en los casos en que el tamaño total del lote en todos los procesos no divide exactamente el conjunto de datos, se duplicarán las muestras del inicio del conjunto de datos para que el lote pueda dividirse equitativamente entre todos los trabajadores.

use_seedable_sampler (`bool`, por defecto `False`) : Si se utiliza o no un muestreador aleatorio totalmente sembrable (`data_loader.SeedableRandomSampler`). Garantiza que los resultados del entrenamiento sean totalmente reproducibles mediante una técnica de muestreo diferente. Si bien los resultados de una semilla a otra pueden variar, en promedio las diferencias son despreciables al utilizar varias semillas diferentes para comparar. También debe ejecutarse con [set_seed()](/docs/accelerate/main/es/package_reference/utilities#accelerate.utils.set_seed) para obtener los mejores resultados.

data_seed (`int`, por defecto `None`) : La semilla a utilizar para el generador subyacente al usar `use_seedable_sampler`. Si es `None`, el generador utilizará la semilla predeterminada actual de torch.

non_blocking (`bool`, por defecto `False`) : Si se establece en `True`, el dataloader preparado por el Accelerator utilizará transferencias no bloqueantes de host a dispositivo, lo que permite una mejor superposición entre la comunicación del dataloader y la computación. Se recomienda que el dataloader preparado tenga `pin_memory` establecido en `True` para que funcione correctamente.

use_stateful_dataloader (`bool`, por defecto `False`) : Si se establece en `True`, el dataloader preparado por el Accelerator estará respaldado por [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Esto requiere que esté instalada la versión 0.8.0 o superior de `torchdata` que admita StatefulDataLoader.

Configuración para los elementos relacionados con el dataloader al llamar a `accelerator.prepare`.

#### accelerate.utils.ProjectConfiguration[[accelerate.utils.ProjectConfiguration]]

```python
accelerate.utils.ProjectConfiguration(project_dir: str = None, logging_dir: str = None, automatic_checkpoint_naming: bool = False, total_limit: int = None, iteration: int = 0, save_on_each_node: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L843)

**Parámetros:**

project_dir (`str`, por defecto `None`) : Una ruta a un directorio para almacenar datos.

logging_dir (`str`, por defecto `None`) : Una ruta a un directorio para almacenar registros de registradores compatibles localmente. Si es None, por defecto es `project_dir`.

automatic_checkpoint_naming (`bool`, por defecto `False`) : Si los estados guardados deben nombrarse automáticamente de forma iterativa.

total_limit (`int`, por defecto `None`) : El número máximo de estados guardados totales a mantener.

iteration (`int`, por defecto `0`) : La iteración de guardado actual.

save_on_each_node (`bool`, por defecto `False`) : Al realizar entrenamiento distribuido multinodo, si se deben guardar los modelos y puntos de control en cada nodo o solo en el principal.

Configuración del objeto Accelerator según las necesidades internas del proyecto.

#### set_directories[[accelerate.utils.ProjectConfiguration.set_directories]]

```python
set_directories(project_dir: str | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L895)

Establece `self.project_dir` y `self.logging_dir` en los valores apropiados.

## Variables de entorno

Estas son variables de entorno que se pueden habilitar para diferentes casos de uso

* `ACCELERATE_DEBUG_MODE` (`str`): Si se ejecuta accelerate en modo de depuración. Más información disponible [aquí](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors).

## Manipulación de datos y operaciones[[accelerate.utils.broadcast]]

Estas incluyen operaciones de datos que imitan las mismas operaciones de `torch` pero que pueden usarse en procesos distribuidos.

#### accelerate.utils.broadcast[[accelerate.utils.broadcast]]

```python
accelerate.utils.broadcast(tensor, from_process: int = 0)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L604)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos que se deben recopilar.

from_process (`int`, *opcional*, valor predeterminado 0) : El proceso desde el que se envían los datos

**Devuelve:**

La misma estructura de datos que `tensor` con todos los tensores transmitidos al dispositivo adecuado.

Difunde recursivamente el tensor en una lista/tupla/diccionario anidado de tensors a todos los dispositivos.

#### accelerate.utils.broadcast_object_list[[accelerate.utils.broadcast_object_list]]

```python
accelerate.utils.broadcast_object_list(object_list, from_process: int = 0)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L679)

**Parámetros:**

object_list (lista de objetos serializables) : La lista de objetos que se van a difundir. Esta lista se modificará in situ.

from_process (`int`, *opcional*, valor predeterminado 0) : El proceso desde el que se envían los datos.

**Devuelve:**

La misma lista que contiene los objetos del proceso 0.

Difunda una lista de objetos serializables desde un proceso a los demás.

#### accelerate.utils.concatenate[[accelerate.utils.concatenate]]

```python
accelerate.utils.concatenate(data, dim = 0)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L723)

**Parámetros:**

data (lista/tupla/diccionario anidado de listas de tensores `torch.Tensor`) : Los datos a concatenar.

dim (`int`, *opcional*, valor predeterminado 0) : La dimensión sobre la que concatenar.

**Devuelve:**

La misma estructura de datos que `data` con todos los tensores concatenados.

Concatena recursivamente los tensores en una lista/tupla/diccionario anidado de listas de tensores con la misma forma. Si solo hay un solo lote de datos, se devuelve tal cual.

#### accelerate.utils.convert_outputs_to_fp32[[accelerate.utils.convert_outputs_to_fp32]]

```python
accelerate.utils.convert_outputs_to_fp32(model_forward)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L943)

#### accelerate.utils.convert_to_fp32[[accelerate.utils.convert_to_fp32]]

```python
accelerate.utils.convert_to_fp32(tensor)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L893)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos que se van a convertir de FP16/BF16 a FP32.

**Devuelve:**

La misma estructura de datos que `tensor` con todas las tensores que estaban en precisión FP16/BF16 convertidas a FP32.

Convierte recursivamente los elementos de listas/tuplas/diccionarios anidados de tensores en precisión FP16/BF16 a FP32.

#### accelerate.utils.gather[[accelerate.utils.gather]]

```python
accelerate.utils.gather(tensor)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L428)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos que se deben recopilar.

**Devuelve:**

La misma estructura de datos que `tensor` con todos los tensores enviados al dispositivo adecuado.

Recolectar recursivamente un tensor en una lista/tupla/diccionario anidado de tensors desde todos los dispositivos.

#### accelerate.utils.gather_object[[accelerate.utils.gather_object]]

```python
accelerate.utils.gather_object(object: Any)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L509)

**Parámetros:**

object (nested list/tuple/dictionary of picklable object) : Los datos que se deben recopilar.

**Devuelve:**

La misma estructura de datos que `object` con todos los objetos enviados a cada dispositivo.

Recolectar recursivamente un objeto en una lista/tupla/diccionario anidado de objetos desde todos los dispositivos.

#### accelerate.utils.get_grad_scaler[[accelerate.utils.get_grad_scaler]]

```python
accelerate.utils.get_grad_scaler(distributed_type: DistributedType = None, **kwargs)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2133)

**Parámetros:**

distributed_type (`DistributedType`, *opcional*, valor predeterminado None) : El tipo de entorno distribuido.

kwargs : Argumentos adicionales para el constructor de `GradScaler` utilizado.

Un helper genérico que inicializa la implementación correcta de `GradScaler` en función del entorno y la devuelve.

#### accelerate.utils.get_mixed_precision_context_manager[[accelerate.utils.get_mixed_precision_context_manager]]

```python
accelerate.utils.get_mixed_precision_context_manager(native_amp: bool = False, autocast_kwargs: AutocastKwargs = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2091)

**Parámetros:**

native_amp (`bool`, *opcional*, predeterminado en False) : Si la precisión mixta está realmente habilitada.

Devuelve un gestor de contexto para el autocast de precisión mixta

#### accelerate.utils.listify[[accelerate.utils.listify]]

```python
accelerate.utils.listify(data)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L284)

**Parámetros:**

data (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos de los que se debe convertir a números regulares.

**Devuelve:**

La misma estructura de datos que `data` con listas de números en lugar de `torch.Tensor`.

Encuentra recursivamente tensores en una lista/tupla/diccionario anidado y los convierte en una lista de números.

#### accelerate.utils.pad_across_processes[[accelerate.utils.pad_across_processes]]

```python
accelerate.utils.pad_across_processes(tensor, dim = 0, pad_index = 0, pad_first = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L753)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos que se deben recopilar.

dim (`int`, *opcional*, valor predeterminado 0) : La dimensión sobre la que se debe aplicar el relleno.

pad_index (`int`, *opcional*, valor predeterminado 0) : El valor con el que se rellena.

pad_first (`bool`, *opcional*, valor predeterminado `False`) : Si se debe rellenar al principio o al final.

Rellena recursivamente los tensores en una lista/tupla/diccionario anidado de tensores de todos los dispositivos hasta el mismo tamaño para que puedan recopilarse de forma segura.

#### accelerate.utils.recursively_apply[[accelerate.utils.recursively_apply]]

```python
accelerate.utils.recursively_apply(func, data, *args, test_type = <function is_torch_tensor at 0x7fe7449bfed0>, error_on_other_type = False, **kwargs)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L85)

**Parámetros:**

func (`callable`) : La función que se aplicará de forma recursiva.

data (nested list/tuple/dictionary of objects accepted by `test_type`) : Los datos sobre los que aplicar `func`

- ***args** : Argumentos posicionales que se pasarán a `func` cuando se aplique sobre los datos desempaquetados.

test_type (`Callable[[Any], bool]`, *opcional*, valor predeterminado `is_torch_tensor`) : El predicado que decide si `func` debe aplicarse a un objeto hoja dado.

error_on_other_type (`bool`, *opcional*, por defecto `False`) : Si se debe devolver un error o no si, después de desempaquetar `data`, se obtiene un objeto para el cual `test_type` devuelve `False`. Si es `False`, la función dejará dichos objetos sin cambios.

- ****kwargs** (argumentos de palabra clave adicionales, *opcional*) : Argumentos de palabra clave que se pasarán a `func` cuando se aplique a los datos desempaquetados.

**Devuelve:**

La misma estructura de datos que `data` con `func` aplicada a cada objeto para el cual `test_type` devuelve `True`.

Aplicar recursivamente una función sobre una estructura de datos que es una lista/tupla/diccionario anidado de un tipo base dado.

#### accelerate.utils.reduce[[accelerate.utils.reduce]]

```python
accelerate.utils.reduce(tensor, reduction = 'mean', scale = 1.0)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L849)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos a reducir.

reduction (`str`, *opcional*, valor predeterminado `"mean"`) : Un método de reducción. Puede ser "mean", "sum", "max" o "none"

scale (`float`, *opcional*) : Un valor de escalado predeterminado que se aplicará después de la reducción, válido solo en XLA.

**Devuelve:**

La misma estructura de datos que `data` con todos los tensores reducidos.

Reducir recursivamente los tensores en una lista/tupla/diccionario anidado de listas de tensores en todos los procesos mediante la media de una operación dada.

#### accelerate.utils.send_to_device[[accelerate.utils.send_to_device]]

```python
accelerate.utils.send_to_device(tensor, device, non_blocking = False, skip_keys = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L136)

**Parámetros:**

tensor (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos que se enviarán a un dispositivo determinado.

device (`torch.device`) : El dispositivo al que se enviarán los datos.

non_blocking (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, la transferencia al dispositivo se realiza de forma asíncrona, lo que permite superponer el movimiento de datos con la computación. Solo es efectivo cuando el dispositivo lo admite (p. ej., CUDA).

skip_keys (`str` o `List[str]`, *opcional*) : Una clave o lista de claves en un diccionario `tensor` cuyos valores no deben enviarse al `device` indicado. Las entradas con estas claves se mantienen en su dispositivo original.

**Devuelve:**

La misma estructura de datos que `tensor` con todos los tensores enviados al dispositivo adecuado.

Envía recursivamente los elementos de una lista/tupla/diccionario anidado de tensores a un dispositivo dado.

#### accelerate.utils.slice_tensors[[accelerate.utils.slice_tensors]]

```python
accelerate.utils.slice_tensors(data, tensor_slice, process_index = None, num_processes = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L703)

**Parámetros:**

data (lista/tupla/diccionario anidado de `torch.Tensor`) : Los datos a segmentar.

tensor_slice (`slice`) : La porción a tomar.

**Devuelve:**

La misma estructura de datos que `data` con todas las rebanadas de tensores.

Toma recursivamente una porción de una lista/tupla/diccionario anidado de tensores.

## Comprobaciones del entorno[[accelerate.utils.is_bf16_available]]

Estas funcionalidades verifican el estado del entorno de trabajo actual, incluida información sobre el propio sistema operativo, lo que puede admitir y si se han instalado dependencias específicas.

#### accelerate.utils.is_bf16_available[[accelerate.utils.is_bf16_available]]

```python
accelerate.utils.is_bf16_available(ignore_tpu = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L156)

Comprueba si bf16 es compatible, ignorando opcionalmente el TPU

#### accelerate.utils.is_mps_available[[accelerate.utils.is_mps_available]]

```python
accelerate.utils.is_mps_available(min_version = '1.12')
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L326)

Comprueba si el dispositivo MPS está disponible. La versión mínima requerida es 1.12.

#### accelerate.utils.is_npu_available[[accelerate.utils.is_npu_available]]

```python
accelerate.utils.is_npu_available(check_device = False)
```

Comprueba si `torch_npu` está instalado y, en su caso, si hay una NPU en el entorno

#### accelerate.utils.is_torch_version[[accelerate.utils.is_torch_version]]

```python
accelerate.utils.is_torch_version(operation: str, version: str)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/versions.py#L46)

**Parámetros:**

operation (`str`) : Una representación en cadena de un operador, como `">"` o `"<="`

version (`str`) : Una versión en cadena de PyTorch

Compara la versión actual de PyTorch con una referencia dada mediante una operación.

#### accelerate.utils.is_torch_xla_available[[accelerate.utils.is_torch_xla_available]]

```python
accelerate.utils.is_torch_xla_available(check_is_tpu = False, check_is_gpu = False)
```

Comprueba si `torch_xla` está disponible. Para entrenar un trabajo nativo de pytorch en un entorno con torch xla instalado, establece USE_TORCH_XLA en false.

#### accelerate.utils.is_xpu_available[[accelerate.utils.is_xpu_available]]

```python
accelerate.utils.is_xpu_available(check_device = False)
```

Comprueba si la aceleración XPU está disponible a través de PyTorch estándar (>=2.7) y, potencialmente, si hay una XPU en el entorno

## Manipulación del entorno[[accelerate.utils.patch_environment]]

#### accelerate.utils.patch_environment[[accelerate.utils.patch_environment]]

```python
accelerate.utils.patch_environment(**kwargs)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L416)

Un gestor de contexto que añadirá cada argumento de palabra clave pasado a `os.environ` y los eliminará al salir.

Convertirá los valores en `kwargs` a cadenas de texto y pondrá todas las claves en mayúsculas.

Ejemplo:

```python
>>> import os
>>> from accelerate.utils import patch_environment

>>> with patch_environment(FOO="bar"):
...     print(os.environ["FOO"])  # prints "bar"
>>> print(os.environ["FOO"])  # raises KeyError
```

#### accelerate.utils.clear_environment[[accelerate.utils.clear_environment]]

```python
accelerate.utils.clear_environment()
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L381)

Un administrador de contexto que limpiará temporalmente las variables de entorno.

Cuando este contexto termina, las variables de entorno anteriores se restaurarán.

Ejemplo:

```python
>>> import os
>>> from accelerate.utils import clear_environment

>>> os.environ["FOO"] = "bar"
>>> with clear_environment():
...     print(os.environ)
...     os.environ["FOO"] = "new_bar"
...     print(os.environ["FOO"])
{}
new_bar

>>> print(os.environ["FOO"])
bar
```

#### accelerate.commands.config.default.write_basic_config[[accelerate.commands.config.default.write_basic_config]]

```python
accelerate.commands.config.default.write_basic_config(mixed_precision = 'no', save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml')
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/commands/config/default.py#L37)

**Parámetros:**

mixed_precision (`str`, *opcional*, valor predeterminado "no") : Precisión mixta a utilizar. Debe ser uno de "no", "fp16" o "bf16"

save_location (`str`, *opcional*, por defecto `default_json_config_file`) : Ubicación de guardado personalizada opcional. Debe pasarse a `--config_file` al usar `accelerate launch`. La ubicación predeterminada está dentro de la carpeta de caché de huggingface (`~/.cache/huggingface`) pero puede sobrescribirse configurando la variable de entorno `HF_HOME`, seguida de `accelerate/default_config.yaml`.

Crea y guarda una configuración básica de clúster para usarla en una máquina local con varias GPU. También configurará la CPU si se trata de una máquina solo de CPU.

Al configurar 🤗 Accelerate por primera vez, en lugar de ejecutar `accelerate config` [~utils.write_basic_config] puede usarse como alternativa para una configuración rápida.

#### accelerate.utils.set_numa_affinity[[accelerate.utils.set_numa_affinity]]

```python
accelerate.utils.set_numa_affinity(local_process_index: int, verbose: bool | None = None)
```

**Parámetros:**

local_process_index (int) : El índice del proceso actual en el servidor actual.

verbose (bool, *opcional*) : Si se debe imprimir la nueva asignación de núcleos de CPU para cada proceso. Si `ACCELERATE_DEBUG_MODE` está habilitado, el valor predeterminado será True.

Asigna el proceso actual a un nodo NUMA específico. Es más eficiente idealmente cuando se tienen al menos 2 cpus por nodo.

Este resultado se almacena en caché entre llamadas. Si desea invalidarlo, use `accelerate.utils.environment.override_numa_afifnity`.

#### accelerate.utils.environment.override_numa_affinity[[accelerate.utils.environment.override_numa_affinity]]

```python
accelerate.utils.environment.override_numa_affinity(local_process_index: int, verbose: bool | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L298)

**Parámetros:**

local_process_index (int) : El índice del proceso actual en el servidor actual.

verbose (bool, *opcional*) : Si se debe registrar la asignación de cada CPU. Si `ACCELERATE_DEBUG_MODE` está habilitado, el valor predeterminado será True.

Anula la afinidad NUMA establecida para el proceso actual. Esta operación es muy costosa y requiere recalcular la afinidad a establecer; idealmente, debería usar `utils.environment.set_numa_affinity` en su lugar.

#### accelerate.utils.purge_accelerate_environment[[accelerate.utils.purge_accelerate_environment]]

```python
accelerate.utils.purge_accelerate_environment(func_or_cls)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L453)

Decorador para limpiar las variables de entorno de accelerate establecidas por la clase o función decorada.

En algunas circunstancias, la llamada a ciertas clases o funciones puede provocar que se establezcan variables de entorno de accelerate y no se limpien posteriormente. Por ejemplo, al llamar a:

TrainingArguments(fp16=True, ...)

Se establecerá la siguiente variable de entorno:

ACCELERATE_MIXED_PRECISION=fp16

Esto puede afectar al código posterior, ya que la variable de entorno tiene prioridad sobre TrainingArguments(fp16=False). Esto es especialmente relevante para las pruebas unitarias, donde queremos evitar que las pruebas individuales tengan efectos secundarios entre sí. Decore la función de prueba unitaria o la clase completa con este decorador para asegurarse de que, después de cada prueba, las variables de entorno se limpien. Esto funciona tanto para unittest.TestCase como para clases normales (pytest); también funciona al decorar la clase padre.

## Memoria[[accelerate.find_executable_batch_size]]

#### accelerate.find_executable_batch_size[[accelerate.find_executable_batch_size]]

```python
accelerate.find_executable_batch_size(function: callable | None = None, starting_batch_size: int = 128, reduce_batch_size_fn: callable | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/memory.py#L120)

**Parámetros:**

function (`callable`, *opcional*) : Una función para envolver

starting_batch_size (`int`, *opcional*) : El tamaño de lote que se intentará ajustar en la memoria

reduce_batch_size_fn (`callable`, *opcional*) : Una función para determinar el nuevo tamaño de lote tras un error de memoria insuficiente. Si no se proporciona, el tamaño de lote se multiplica por 0,9 en cada fallo. La función no toma argumentos y debe devolver el nuevo tamaño de lote (reducido) como un `int`.

Un decorador básico que intentará ejecutar `function`. Si falla debido a excepciones relacionadas con la falta de memoria o CUDNN, el tamaño del lote se multiplica por 0.9 y se pasa a `function`

`function` debe recibir un parámetro `batch_size` como su primer argumento.

Ejemplo:

```python
>>> from accelerate.utils import find_executable_batch_size

>>> @find_executable_batch_size(starting_batch_size=128)
... def train(batch_size, model, optimizer):
...     ...

>>> train(model, optimizer)
```

## Modelado[[accelerate.utils.calculate_maximum_sizes]]

Estas utilidades se relacionan con la interacción con modelos de PyTorch

#### accelerate.utils.calculate_maximum_sizes[[accelerate.utils.calculate_maximum_sizes]]

```python
accelerate.utils.calculate_maximum_sizes(model: Module)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1089)

Calcula el tamaño total del modelo y su capa más grande

#### accelerate.utils.compute_module_sizes[[accelerate.utils.compute_module_sizes]]

```python
accelerate.utils.compute_module_sizes(model: Module, dtype: str | torch.device | None = None, special_dtypes: dict[str, str | torch.device] | None = None, buffers_only: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L651)

Calcule el tamaño de cada submódulo de un modelo dado.

#### accelerate.utils.extract_model_from_parallel[[accelerate.utils.extract_model_from_parallel]]

```python
accelerate.utils.extract_model_from_parallel(model, keep_fp32_wrapper: bool = True, keep_torch_compile: bool = True, recursive: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L264)

**Parámetros:**

model (`torch.nn.Module`) : El modelo a extraer.

keep_fp32_wrapper (`bool`, *opcional*) : Si se deben eliminar los hooks de precisión mixta del modelo.

keep_torch_compile (`bool`, *opcional*) : Si se debe desenvolver el modelo compilado.

recursive (`bool`, *opcional*, valor predeterminado `False`) : Si se deben extraer recursivamente todos los casos de `module.module` de `model`, así como desenrollar recursivamente las capas subyacentes, no solo los contenedores distribuidos de nivel superior.

**Devuelve:** `torch.nn.Module`

El modelo extraído.

Extraer un modelo de sus contenedores distribuidos.

#### accelerate.utils.get_balanced_memory[[accelerate.utils.get_balanced_memory]]

```python
accelerate.utils.get_balanced_memory(model: Module, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, dtype: str | torch.dtype | None = None, special_dtypes: dict[str, str | torch.device] | None = None, low_zero: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L938)

**Parámetros:**

model (`torch.nn.Module`) : El modelo a analizar.

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible. Ejemplo: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *opcional*) : Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).

dtype (`str` o `torch.dtype`, *opcional*) : Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *opcional*) : Si se proporciona, dtypes especiales a considerar para algunos pesos específicos (anulará el dtype utilizado de forma predeterminada para todos los pesos).

low_zero (`bool`, *opcional*) : Minimiza el número de pesos en la GPU 0, lo cual es conveniente cuando se utiliza para otras operaciones (como la función generate de Transformers).

Calcule un diccionario `max_memory` para [infer_auto_device_map()](/docs/accelerate/main/es/package_reference/big_modeling#accelerate.infer_auto_device_map) que equilibre el uso de cada GPU disponible.

Todo el cálculo se realiza analizando los tamaños y los dtypes de los parámetros del modelo. Como resultado, el modelo puede estar en el dispositivo meta (como lo estaría si se inicializara dentro del administrador de contexto `init_empty_weights`).

#### accelerate.utils.get_max_layer_size[[accelerate.utils.get_max_layer_size]]

```python
accelerate.utils.get_max_layer_size(modules: list, module_sizes: dict, no_split_module_classes: list)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L705)

**Parámetros:**

modules (`List[Tuple[str, torch.nn.Module]]`) : La lista de módulos con nombre en los que queremos determinar el tamaño máximo de la capa.

module_sizes (`Dict[str, int]`) : Un diccionario que asigna a cada nombre de capa su tamaño (tal como lo genera `compute_module_sizes`).

no_split_module_classes (`List[str]`) : Una lista de nombres de clases para capas que no queremos dividir.

**Devuelve:** `Tuple[int, List[str]]`

El tamaño máximo de una capa con la lista de nombres de capas que alcanzan ese tamaño máximo.

Función de utilidad que escaneará una lista de módulos nombrados y devolverá el tamaño máximo utilizado por una capa completa. La definición de una capa es:
- un módulo sin hijos directos (solo parámetros y búferes)
- un módulo cuyo nombre de clase está en la lista `no_split_module_classes`

#### accelerate.infer_auto_device_map[[accelerate.infer_auto_device_map]]

```python
accelerate.infer_auto_device_map(model: Module, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, dtype: str | torch.dtype | None = None, special_dtypes: dict[str, str | torch.dtype] | None = None, verbose: bool = False, clean_result: bool = True, offload_buffers: bool = False, fallback_allocation: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1319)

**Parámetros:**

model (`torch.nn.Module`) : El modelo a analizar.

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible. Ejemplo: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *opcional*) : Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).

dtype (`str` o `torch.dtype`, *opcional*) : Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *opcional*) : Si se proporciona, dtypes especiales a considerar para algunos pesos específicos (anulará el dtype utilizado de forma predeterminada para todos los pesos).

verbose (`bool`, *opcional*, por defecto `False`) : Indica si se deben proporcionar declaraciones de depuración mientras la función construye el device_map.

clean_result (`bool`, *opcional*, valor predeterminado `True`) : Limpia el device_map resultante agrupando todos los submódulos que se colocan en el mismo dispositivo.

offload_buffers (`bool`, *opcional*, valor predeterminado `False`) : En las capas que se descargan en la CPU o en el disco duro, si se deben descargar o no los búferes además de los parámetros.

fallback_allocation (`bool`, *opcional*, valor predeterminado `False`) : Cuando la asignación regular falla, intenta asignar un módulo que quepa dentro del límite de tamaño usando BFS.

Calcule un mapa de dispositivos para un modelo dado dando prioridad a las GPUs, luego descargue en la CPU y finalmente descargue en el disco, de modo que:
- no superamos la memoria disponible de ninguna de las GPU.
- si se necesita descargar en la CPU, siempre queda espacio en la GPU 0 para volver a colocar la capa descargada en la CPU que tenga el mayor tamaño.
- si se necesita offload a la CPU, no superamos la RAM disponible en la CPU.
- si se necesita descargar en el disco, siempre queda espacio en la CPU para volver a colocar la capa descargada en el disco que tenga el mayor tamaño.

Todo el cálculo se realiza analizando los tamaños y los dtypes de los parámetros del modelo. Como resultado, el modelo puede estar en el dispositivo meta (como lo estaría si se inicializara dentro del administrador de contexto `init_empty_weights`).

#### accelerate.load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

```python
accelerate.load_checkpoint_in_model(model: Module, checkpoint: str | os.PathLike, device_map: dict[str, int | str | torch.device] | None = None, offload_folder: str | os.PathLike | None = None, dtype: str | torch.dtype | None = None, offload_state_dict: bool = False, offload_buffers: bool = False, keep_in_fp32_modules: list[str] | None = None, offload_8bit_bnb: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1830)

**Parámetros:**

model (`torch.nn.Module`) : El modelo en el que queremos cargar un punto de control.

checkpoint (`str` o `os.PathLike`) : El punto de control de la carpeta a cargar. Puede ser: - una ruta a un archivo que contiene un diccionario de estado completo del modelo - una ruta a un archivo `.json` que contiene el índice de un punto de control fragmentado - una ruta a una carpeta que contiene un archivo único `.index.json` y los fragmentos de un punto de control. - una ruta a una carpeta que contiene un archivo único pytorch_model.bin o un archivo model.safetensors.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opcional*) : Un mapa que especifica en qué dispositivo debe ir cada submódulo. No es necesario detallarlo hasta el nombre de cada parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.

offload_folder (`str` o `os.PathLike`, *opcional*) : Si el `device_map` contiene algún valor `"disk"`, la carpeta donde se descargan los pesos.

dtype (`str` o `torch.dtype`, *opcional*) : Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.

offload_state_dict (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, se descargará temporalmente el state dict de la CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de la CPU + el fragmento más grande no cabe.

offload_buffers (`bool`, *opcional*, valor predeterminado `False`) : Si se incluyen o no los buffers en los pesos descargados en el disco.

keep_in_fp32_modules(`List[str]`, *opcional*) : Una lista de los módulos que se mantienen en el tipo de datos `torch.float32`.

offload_8bit_bnb (`bool`, *opcional*) : Si se habilita o no el offload de módulos de 8 bits en cpu/disco.

strict (`bool`, *opcional*, valor predeterminado `False`) : Si se debe aplicar estrictamente que las claves en el state_dict del checkpoint coincidan con las claves del state_dict del modelo.

full_state_dict (`bool`, *opcional*, valor predeterminado `True`) : si se establece en `True`, se reunirán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.

broadcast_from_rank0 (`False`, *opcional*, valor predeterminado `False`) : cuando la opción es `True`, se debe inicializar un `ProcessGroup` distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan.

Una vez cargado en los dispositivos, aún debe llamar a [dispatch_model()](/docs/accelerate/main/es/package_reference/big_modeling#accelerate.dispatch_model) en su modelo para que pueda ejecutarse. Para agrupar la carga del checkpoint y el despacho en una sola llamada, use [load_checkpoint_and_dispatch()](/docs/accelerate/main/es/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

#### accelerate.utils.load_offloaded_weights[[accelerate.utils.load_offloaded_weights]]

```python
accelerate.utils.load_offloaded_weights(model, index, offload_folder)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L897)

**Parámetros:**

model (`torch.nn.Module`) : El modelo en el que se cargarán los pesos.

index (`dict`) : Un diccionario que contiene el nombre del parámetro y sus metadatos para cada parámetro que se descargó del modelo.

offload_folder (`str`) : La carpeta donde se almacenan los pesos descargados.

Carga los pesos desde la carpeta de descarga en el modelo.

#### accelerate.utils.load_state_dict[[accelerate.utils.load_state_dict]]

```python
accelerate.utils.load_state_dict(checkpoint_file, device_map = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1661)

**Parámetros:**

checkpoint_file (`str`) : La ruta del punto de control que se va a cargar.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opcional*) : Un mapa que especifica en qué dispositivo debe ir cada submódulo. No es necesario detallarlo hasta el nombre de cada parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.

Carga un punto de control desde un archivo dado. Si el punto de control está en el formato safetensors y se pasa un mapa de dispositivos, los pesos se pueden cargar rápidamente directamente en la GPU.

#### accelerate.utils.offload_state_dict[[accelerate.utils.offload_state_dict]]

```python
accelerate.utils.offload_state_dict(save_dir: str | os.PathLike, state_dict: dict)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/offload.py#L94)

**Parámetros:**

save_dir (`str` o `os.PathLike`) : El directorio en el que se descargará el state dict.

state_dict (`Dict[str, torch.Tensor]`) : El diccionario de tensores para descargar.

Descarga un state dict en una carpeta dada.

#### accelerate.utils.retie_parameters[[accelerate.utils.retie_parameters]]

```python
accelerate.utils.retie_parameters(model, tied_params)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L609)

**Parámetros:**

model (`torch.nn.Module`) : El modelo en el que se deben volver a vincular los parámetros.

tied_params (`List[List[str]]`) : Un parámetro de mapeo de nombre de parámetro a nombre de parámetro vinculado, tal como se obtiene mediante `find_tied_parameters`.

Vuelve a atar los parámetros atados en un modelo dado si el vínculo se rompió (por ejemplo, al agregar hooks).

#### accelerate.utils.set_module_tensor_to_device[[accelerate.utils.set_module_tensor_to_device]]

```python
accelerate.utils.set_module_tensor_to_device(module: Module, tensor_name: str, device: int | str | torch.device, value: torch.Tensor | None = None, dtype: str | torch.dtype | None = None, fp16_statistics: torch.HalfTensor | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None, non_blocking: bool = False, clear_cache: bool = True)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L210)

**Parámetros:**

module (`torch.nn.Module`) : El módulo en el que reside el tensor que queremos mover.

tensor_name (`str`) : El nombre completo del parámetro/buffer.

device (`int`, `str` o `torch.device`) : El dispositivo en el que se establecerá el tensor.

value (`torch.Tensor`, *opcional*) : El valor del tensor (útil al pasar del dispositivo meta a cualquier otro dispositivo).

dtype (`torch.dtype`, *opcional*) : Si se pasa, el valor del parámetro se convertirá a este `dtype`. De lo contrario, `value` se convertirá al dtype del parámetro existente en el modelo.

fp16_statistics (`torch.HalfTensor`, *opcional*) : La lista de estadísticas de fp16 para establecer en el módulo, utilizada para la serialización de modelos de 8 bits.

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *opcional*, valor predeterminado `None`) : Un mapa de punteros de datos actuales a diccionarios de dispositivos a pesos vinculados ya despachados. Para un dispositivo de ejecución dado, este parámetro es útil para reutilizar el primer puntero disponible de un peso compartido en el dispositivo para todos los demás, en lugar de duplicar la memoria.

non_blocking (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, la transferencia de dispositivo será asíncrona con respecto al host, si es posible.

clear_cache (`bool`, *opcional*, valor predeterminado `True`) : Si se debe o no limpiar la caché del dispositivo después de establecer el tensor en el dispositivo.

Una función auxiliar para establecer un tensor dado (parámetro o buffer) de un módulo en un dispositivo específico (tenga en cuenta que hacer `param.to(device)` crea un nuevo tensor no vinculado al parámetro, por lo que necesitamos esta función).

#### accelerate.utils.get_module_children_bottom_up[[accelerate.utils.get_module_children_bottom_up]]

```python
accelerate.utils.get_module_children_bottom_up(model: Module, return_fqns: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L583)

**Parámetros:**

model (`torch.nn.Module`) : el modelo del que se deben obtener los hijos

**Devuelve:** `list[torch.nn.Module]`

una lista de los módulos hijos de `model` en orden ascendente. El último elemento es el propio `model`.

Recorre el modelo en orden ascendente y devuelve los módulos hijos en ese orden.

## Paralelo[[accelerate.utils.extract_model_from_parallel]]

Estas incluyen utilidades generales que deben usarse al trabajar en paralelo.

#### accelerate.utils.extract_model_from_parallel[[accelerate.utils.extract_model_from_parallel]]

```python
accelerate.utils.extract_model_from_parallel(model, keep_fp32_wrapper: bool = True, keep_torch_compile: bool = True, recursive: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L264)

**Parámetros:**

model (`torch.nn.Module`) : El modelo a extraer.

keep_fp32_wrapper (`bool`, *opcional*) : Si se deben eliminar los hooks de precisión mixta del modelo.

keep_torch_compile (`bool`, *opcional*) : Si se debe desenvolver el modelo compilado.

recursive (`bool`, *opcional*, valor predeterminado `False`) : Si se deben extraer recursivamente todos los casos de `module.module` de `model`, así como desenrollar recursivamente las capas subyacentes, no solo los contenedores distribuidos de nivel superior.

**Devuelve:** `torch.nn.Module`

El modelo extraído.

Extraer un modelo de sus contenedores distribuidos.

#### accelerate.utils.save[[accelerate.utils.save]]

```python
accelerate.utils.save(obj, f, save_on_each_node: bool = False, safe_serialization: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L402)

**Parámetros:**

obj : Los datos a guardar

f : El archivo (o objeto similar a un archivo) que se usará para guardar los datos

save_on_each_node (`bool`, *opcional*, por defecto `False`) : Si se debe guardar solo en el proceso principal global

safe_serialization (`bool`, *opcional*, valor predeterminado `False`) : Si se debe guardar `obj` usando `safetensors` o de la forma tradicional de PyTorch (que usa `pickle`).

Guarde los datos en el disco. Utilice en lugar de `torch.save()`.

#### accelerate.utils.load[[accelerate.utils.load]]

```python
accelerate.utils.load(f, map_location = None, **kwargs)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L452)

**Parámetros:**

f : El archivo (o objeto similar a un archivo) que se usará para cargar los datos

map_location : una función, `torch.device`, una cadena o un diccionario que especifica cómo remapear las ubicaciones de almacenamiento

- ****kwargs** : Argumentos de palabra clave adicionales para pasar a `torch.load()`.

Sustituto compatible de `torch.load()` que permite usar `weights_only` si la versión de `torch` es 2.4.0 o superior. En caso contrario, se ignorará el parámetro.

También se añadirá (y luego se eliminará) una excepción para los arreglos de numpy

#### accelerate.utils.wait_for_everyone[[accelerate.utils.wait_for_everyone]]

```python
accelerate.utils.wait_for_everyone()
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L354)

Introduce un punto de bloqueo en el script, asegurándose de que todos los procesos hayan alcanzado este punto antes de continuar.

Asegúrese de que todos los procesos lleguen a esta instrucción, de lo contrario, uno de sus procesos se quedará colgado para siempre.

## Aleatorio[[accelerate.utils.set_seed]]

Estas utilidades se relacionan con la configuración y sincronización de todos los estados aleatorios.

#### accelerate.utils.set_seed[[accelerate.utils.set_seed]]

```python
accelerate.utils.set_seed(seed: int, device_specific: bool = False, deterministic: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L40)

**Parámetros:**

seed (`int`) : La semilla a establecer.

device_specific (`bool`, *opcional*, por defecto `False`) : Si se debe diferenciar ligeramente la semilla en cada dispositivo con `self.process_index`.

deterministic (`bool`, *opcional*, por defecto `False`) : Si se deben usar algoritmos deterministas cuando estén disponibles. Puede ralentizar el entrenamiento.

Función auxiliar para un comportamiento reproducible que establece la semilla en `random`, `numpy`, `torch`.

#### accelerate.utils.synchronize_rng_state[[accelerate.utils.synchronize_rng_state]]

```python
accelerate.utils.synchronize_rng_state(rng_type: accelerate.utils.dataclasses.RNGType | None = None, generator: torch.Generator | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L81)

#### accelerate.synchronize_rng_states[[accelerate.synchronize_rng_states]]

```python
accelerate.synchronize_rng_states(rng_types: list, generator: torch.Generator | None = None)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L163)

## PyTorch XLA[[accelerate.utils.install_xla]]

Estas incluyen utilidades que resultan útiles al usar PyTorch con XLA.

#### accelerate.utils.install_xla[[accelerate.utils.install_xla]]

```python
accelerate.utils.install_xla(upgrade: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/torch_xla.py#L20)

**Parámetros:**

upgrade (`bool`, *opcional*, valor predeterminado `False`) : Si se debe actualizar `torch` e instalar las ruedas más recientes de `torch_xla`.

Función auxiliar para instalar las ruedas xla adecuadas según la versión de `torch` en Google Colaboratory.

Ejemplo:

```python
>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)
```

## Carga de los pesos del modelo[[accelerate.load_checkpoint_in_model]]

Estos incluyen utilidades que resultan útiles para cargar puntos de control.

#### accelerate.load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

```python
accelerate.load_checkpoint_in_model(model: Module, checkpoint: str | os.PathLike, device_map: dict[str, int | str | torch.device] | None = None, offload_folder: str | os.PathLike | None = None, dtype: str | torch.dtype | None = None, offload_state_dict: bool = False, offload_buffers: bool = False, keep_in_fp32_modules: list[str] | None = None, offload_8bit_bnb: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1830)

**Parámetros:**

model (`torch.nn.Module`) : El modelo en el que queremos cargar un punto de control.

checkpoint (`str` o `os.PathLike`) : El punto de control de la carpeta a cargar. Puede ser: - una ruta a un archivo que contiene un diccionario de estado completo del modelo - una ruta a un archivo `.json` que contiene el índice de un punto de control fragmentado - una ruta a una carpeta que contiene un archivo único `.index.json` y los fragmentos de un punto de control. - una ruta a una carpeta que contiene un archivo único pytorch_model.bin o un archivo model.safetensors.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opcional*) : Un mapa que especifica en qué dispositivo debe ir cada submódulo. No es necesario detallarlo hasta el nombre de cada parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.

offload_folder (`str` o `os.PathLike`, *opcional*) : Si el `device_map` contiene algún valor `"disk"`, la carpeta donde se descargan los pesos.

dtype (`str` o `torch.dtype`, *opcional*) : Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.

offload_state_dict (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, se descargará temporalmente el state dict de la CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de la CPU + el fragmento más grande no cabe.

offload_buffers (`bool`, *opcional*, valor predeterminado `False`) : Si se incluyen o no los buffers en los pesos descargados en el disco.

keep_in_fp32_modules(`List[str]`, *opcional*) : Una lista de los módulos que se mantienen en el tipo de datos `torch.float32`.

offload_8bit_bnb (`bool`, *opcional*) : Si se habilita o no el offload de módulos de 8 bits en cpu/disco.

strict (`bool`, *opcional*, valor predeterminado `False`) : Si se debe aplicar estrictamente que las claves en el state_dict del checkpoint coincidan con las claves del state_dict del modelo.

full_state_dict (`bool`, *opcional*, valor predeterminado `True`) : si se establece en `True`, se reunirán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.

broadcast_from_rank0 (`False`, *opcional*, valor predeterminado `False`) : cuando la opción es `True`, se debe inicializar un `ProcessGroup` distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan.

Una vez cargado en los dispositivos, aún debe llamar a [dispatch_model()](/docs/accelerate/main/es/package_reference/big_modeling#accelerate.dispatch_model) en su modelo para que pueda ejecutarse. Para agrupar la carga del checkpoint y el despacho en una sola llamada, use [load_checkpoint_and_dispatch()](/docs/accelerate/main/es/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

## Cuantización[[accelerate.utils.load_and_quantize_model]]

Estas incluyen utilidades que resultan útiles para cuantizar el modelo.

#### accelerate.utils.load_and_quantize_model[[accelerate.utils.load_and_quantize_model]]

```python
accelerate.utils.load_and_quantize_model(model: Module, bnb_quantization_config: BnbQuantizationConfig, weights_location: str | os.PathLike | None = None, device_map: dict[str, int | str | torch.device] | None = None, no_split_module_classes: list[str] | None = None, max_memory: dict[int | str, int | str] | None = None, offload_folder: str | os.PathLike | None = None, offload_state_dict: bool = False)
```

[Fuente](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/bnb.py#L44)

**Parámetros:**

model (`torch.nn.Module`) : Modelo de entrada. El modelo puede estar ya cargado o en el dispositivo meta

bnb_quantization_config (`BnbQuantizationConfig`) : Los parámetros de cuantización de bitsandbytes

weights_location (`str` o `os.PathLike`) : La carpeta weights_location a cargar. Puede ser: - una ruta a un archivo que contiene un state dict completo del modelo - una ruta a un archivo `.json` que contiene el índice de un checkpoint fragmentado - una ruta a una carpeta que contiene un único archivo `.index.json` y los fragmentos de un checkpoint. - una ruta a una carpeta que contiene un único archivo pytorch_model.bin.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opcional*) : Un mapa que especifica en qué dispositivo debe ir cada submódulo. No es necesario detallarlo hasta el nombre de cada parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.

no_split_module_classes (`List[str]`, *opcional*) : Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible.

offload_folder (`str` o `os.PathLike`, *opcional*) : Si el `device_map` contiene algún valor `"disk"`, la carpeta donde se descargan los pesos.

offload_state_dict (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, se descargará temporalmente el state dict de la CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de la CPU + el fragmento más grande no cabe.

**Devuelve:** `torch.nn.Module`

El modelo cuantizado

Esta función cuantizará el modelo de entrada con la configuración asociada pasada en `bnb_quantization_config`. Si el modelo está en el dispositivo meta, cargaremos y despacharemos los pesos según el `device_map` pasado. Si el modelo ya está cargado, cuantizaremos el modelo y lo colocaremos en la GPU,