# Вспомогательные функции и классы

Ниже перечислены различные вспомогательные функции, которые предоставляет 🤗 Accelerate, сгруппированные по сценариям использования.

## Константы

Константы, используемые в 🤗 Accelerate для справки

Ниже приведены константы, используемые при обращении к [Accelerator.save_state()](/docs/accelerate/v1.16.0/ru/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`

Ниже приведены константы, используемые при обращении к [Accelerator.save_model()](/docs/accelerate/v1.16.0/ru/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"`

## Классы данных

Это базовые dataclasses, используемые во всех модулях 🤗 Accelerate, которые можно передавать в качестве параметров.

### Автономный[[accelerate.utils.ComputeEnvironment]]

Это независимые dataclass, используемые для проверок, например, типа используемой распределённой системы

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L595)

Представляет тип вычислительной среды.

Значения:

- **LOCAL_MACHINE** -- оборудование частного/собственного кластера.
- **AMAZON_SAGEMAKER** -- Amazon SageMaker в качестве вычислительной среды.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L524)

Представляет тип распределённой среды.

Значения:

- **NO** -- не распределённая среда, а только один процесс.
- **MULTI_CPU** -- Распределено на нескольких CPU-узлах.
- **MULTI_GPU** -- Распределено по нескольким GPU.
- **MULTI_MLU** -- Распределённый режим на нескольких MLU.
- **MULTI_SDAA** -- Распределено по нескольким SDAAs.
- **MULTI_MUSA** -- Распределённый режим на нескольких устройствах MUSA.
- **MULTI_NPU** -- Распределённый режим на нескольких NPU.
- **MULTI_XPU** -- Распределённый режим на нескольких XPU.
- **MULTI_HPU** -- Распределённый режим на нескольких HPU.
- **MULTI_NEURON** -- Распределено по нескольким ядрам Neuron.
- **DEEPSPEED** -- Использование DeepSpeed.
- **FSDP** -- Использование полностью шардированной параллелизации данных (FSDP).
- **XLA** -- Использование TorchXLA.
- **MEGATRON_LM** -- Использование Megatron-LM.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L610)

Представляет динамо-бэкенд (см. https://pytorch.org/docs/stable/torch.compiler.html).

Значения:

- **НЕТ** -- Не используйте torch dynamo.
- **EAGER** — использует PyTorch для выполнения извлечённого GraphModule. Это очень полезно при отладке проблем TorchDynamo.
- **AOT_EAGER** -- Использует AotAutograd без компилятора, то есть применяет PyTorch eager для извлечённых AotAutograd графов прямой и обратной передачи. Это полезно для отладки, но вряд ли даст ускорение.
- **INDUCTOR** -- Использует бэкенд TorchInductor с AotAutograd и cudagraphs, опираясь на сгенерированные ядра Triton. [Подробнее](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- nvFuser с AotAutograd/TorchScript. [Подробнее](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- nvFuser с PrimTorch. [Подробнее](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** — cudagraphs с AotAutograd. [Подробнее](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Использует Torchscript optimize_for_inference. Только для инференса. [Подробнее](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- Использует Nvidia TensorRT для оптимизации инференса. Только инференс. [Подробнее](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- Использует ONNXRT для вывода на CPU/GPU. Только вывод. [Подробнее](https://onnxruntime.ai/)
- **TENSORRT** -- Использует ONNXRT для запуска TensorRT с целью оптимизации вывода. [Подробнее](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- Использует Pytorch/XLA с оптимизацией TorchDynamo, для обучения. [Подробнее](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- Использует Pytorch/XLA с оптимизацией TorchDynamo для инференса. [Подробнее](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Использует Apache TVM для оптимизации вывода. [Подробнее](https://tvm.apache.org/)
- **HPU_BACKEND** -- Использует HPU-бэкенд для оптимизации инференса.
- **NEURON** -- Использует бэкенд AWS Neuron для Trainium/Inferentia.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L665)

Представляет тип поддерживаемого трекера экспериментов

Значения:

- **ALL** -- все доступные в среде поддерживаемые трекеры
- **TENSORBOARD** — TensorBoard в качестве трекера экспериментов
- **WANDB** -- wandb в качестве трекера экспериментов
- **TRACKIO** -- trackio в качестве трекера экспериментов
- **COMETML** -- comet_ml в качестве трекера экспериментов
- **MLFLOW** -- mlflow в качестве трекера экспериментов
- **CLEARML** — clearml в качестве трекера экспериментов
- **DVCLIVE** -- dvclive в качестве трекера экспериментов
- **SWANLAB** — swanlab в качестве трекера экспериментов

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L693)

Представляет тип точности, используемый для значений с плавающей запятой

Значения:

- **НЕТ** -- использование полной точности (FP32)
- **FP16** -- использование половинной точности
- **BF16** -- использование точности brain floating point

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L709)

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L563)

Представляет тип распределённой среды.

Значения:

- **NO** -- не распределённая среда, а только один процесс.
- **DATA_PARALLEL** -- использование распределённого параллелизма данных в sagemaker.
- **MODEL_PARALLEL** -- использование распределённого параллелизма моделей sagemaker.

### Kwargs[[accelerate.AutocastKwargs]]

Это настраиваемые аргументы для конкретных взаимодействий в экосистеме PyTorch, которые Accelerate обрабатывает «под капотом».

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L104)

Используйте этот объект в вашем [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator), чтобы настроить поведение `torch.autocast`. Подробную информацию о каждом аргументе см. в документации этого [контекстного менеджера](https://pytorch.org/docs/stable/amp.html#torch.autocast).

Пример:

```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>)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L146)

Используйте этот объект в вашем [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator), чтобы настроить способ обёртывания вашей модели в `torch.nn.parallel.DistributedDataParallel`. Подробную информацию о каждом аргументе см. в документации этого [обёртывающего класса](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html).

Пример:

```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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L224)

Используйте этот объект в вашем [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator), чтобы настроить поведение смешанной точности, в частности, способ создания используемого `torch.amp.GradScaler` или `torch.cuda.amp.GradScaler`. Подробную информацию о каждом аргументе см. в документации этого [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler).

Пример:

```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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L249)

Используйте этот объект в вашем [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator) для настройки инициализации распределённых процессов. Подробную информацию о каждом аргументе см. в документации этого [метода](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group).

Примечание: если `timeout` установлено в `None`, значение по умолчанию будет определяться на основе параметра `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()
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L59)

Внутренний миксин, реализующий метод `to_kwargs()` для dataclass.

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

```python
to_kwargs()
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L67)

Возвращает словарь, содержащий атрибуты со значениями, отличными от значений по умолчанию для этого класса.

## Плагины[[accelerate.DeepSpeedPlugin]]

Это плагины, которые можно передать объекту [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator). Хотя они описаны в других разделах документации, для удобства все они перечислены здесь:

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1042)

**Параметры:**

hf_ds_config (`Any`, по умолчанию `None`) : Путь к файлу конфигурации DeepSpeed или словарь или объект класса `accelerate.utils.deepspeed.HfDeepSpeedConfig`.

gradient_accumulation_steps (`int`, по умолчанию `None`) : Количество шагов для накопления градиентов перед обновлением состояний оптимизатора. Если не задано, будет использовано значение из `Accelerator` напрямую.

gradient_clipping (`float`, по умолчанию `None`) : Включает обрезание градиентов с указанным значением.

zero_stage (`int`, по умолчанию `None`) : Возможные значения: 0, 1, 2, 3. Значение по умолчанию берётся из переменной окружения.

is_train_batch_min (`bool`, по умолчанию `True`) : если указаны оба загрузчика данных — для обучения и оценки, — этот параметр определяет `train_batch_size`.

offload_optimizer_device (`str`, по умолчанию `None`) : Возможные значения: none|cpu|nvme. Применимо только для ZeRO Stages 2 и 3.

offload_param_device (`str`, по умолчанию `None`) : Возможные значения: none|cpu|nvme. Применимо только для ZeRO Stage 3.

offload_optimizer_nvme_path (`str`, по умолчанию `None`) : Возможные значения: /nvme|/local_nvme. Применимо только для ZeRO Stage 3.

offload_param_nvme_path (`str`, по умолчанию `None`) : Возможные значения: /nvme|/local_nvme. Применимо только для ZeRO Stage 3.

zero3_init_flag (`bool`, по умолчанию `None`) : Флаг, указывающий, следует ли сохранять модель в 16-битном формате. Применимо только для ZeRO Stage-3.

zero3_save_16bit_model (`bool`, по умолчанию `None`) : Флаг, указывающий, следует ли сохранять модель в 16-битном формате. Применимо только для ZeRO Stage-3.

transformer_moe_cls_names (`str`, по умолчанию `None`) : Список через запятую имён классов слоёв MoE в Transformers (с учётом регистра). Например, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention`, `JetMoEBlock` и т. д.

Этот плагин используется для интеграции DeepSpeed.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1278)

Обработайте конфигурацию DeepSpeed с значениями из kwargs.

#### выбрать[[accelerate.DeepSpeedPlugin.select]]

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1433)

Устанавливает HfDeepSpeedWeakref для использования текущей конфигурации плагина 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1465)

**Параметры:**

fsdp_version (`int`, по умолчанию `1`) : Версия FSDP для использования. По умолчанию 1. Если установлено значение 2, загрузчик ожидает, что конфигурация будет преобразована в формат FSDP2.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, по умолчанию `'FULL_SHARD'`) : Стратегия шардирования. Должна быть либо `str`, либо экземпляром `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`. Устарела, рекомендуется использовать `reshard_after_forward`.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, по умолчанию `'FULL_SHARD'` для `fsdp_version=1` и `True` для `fsdp_version=2`) : Стратегия шардирования. Должна быть bool, если `fsdp_version` установлено в 2, иначе `str` или экземпляр `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, по умолчанию `'NO_PREFETCH'`) : Стратегия предварительной загрузки в обратном направлении. Должно быть либо `str`, либо экземпляром `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, по умолчанию `None`) : Конфигурация для включения обучения с смешанной точностью с использованием FullyShardedDataParallel. Если передается `dict`, он должен содержать следующие ключи: `param_dtype`, `reduce_dtype` и `buffer_dtype`. Если `fsdp_version` установлен в 2, может быть передан экземпляр `torch.distributed.fsdp.MixedPrecisionPolicy`. Если передается `str`, он должен быть одним из следующих значений: fp8, fp16, bf16, fp32, и используется для установки `param_dtype`, `reduce_dtype` и `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]`, по умолчанию `False`) : следует ли выгружать параметры на CPU. Значением может быть `bool` или экземпляр `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` или `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy`, если `fsdp_version` установлен в 2.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, по умолчанию `None`) : Список модулей, которые следует игнорировать при обёртке с помощью FSDP. При передаче строки модули сопоставляются по имени с использованием regex fullmatch. Если `fsdp_version` установлен в значение 2, модули преобразуются в параметры и используются.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, по умолчанию `'FULL_STATE_DICT'`) : Тип state dict для использования. Если передана строка, она должна быть одной из `full_state_dict`, `local_state_dict` или `sharded_state_dict`.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, по умолчанию `None`) : Конфигурация state dict для использования. Если не передана, определяется на основе `state_dict_type`.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, по умолчанию `None`) : Конфигурация state dict для оптимизатора. Если не передана, определяется на основе `state_dict_type`.

limit_all_gathers (`bool`, по умолчанию `True`) : Указывает, следует ли FSDP явно синхронизировать CPU-поток, чтобы предотвратить слишком большое количество незавершённых all-gather операций. Этот параметр влияет только на стратегии с шардированием, которые планируют all-gather операции. Включение этой опции может помочь снизить количество повторных попыток выделения памяти CUDA.

use_orig_params (`bool`, по умолчанию `False`) : Использовать ли исходные параметры для оптимизатора.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, по умолчанию `None`) : `Callable[torch.nn.Module] -> None`, определяющий, как модули, находящиеся на meta-устройстве, должны быть инициализированы на фактическом устройстве. Применимо только тогда, когда `sync_module_states` равно `True`. По умолчанию это `lambda`, вызывающая `to_empty` для модуля.

sync_module_states (`bool`, по умолчанию `False`) : Следует ли каждому индивидуально обернутому модулю FSDP транслировать параметры модуля с ранга 0, чтобы гарантировать их идентичность на всех рангах после инициализации. По умолчанию `False`, если только `cpu_ram_efficient_loading` не равно `True`, в этом случае параметр принудительно включается.

forward_prefetch (`bool`, по умолчанию `False`) : Указывает, следует ли FSDP явно выполнять предварительную загрузку (prefetch) следующего all-gather во время выполнения прямого прохода. Используйте только со статическими графами.

activation_checkpointing (`bool`, по умолчанию `False`) : Техника для снижения потребления памяти путём очистки активаций определённых слоёв и их повторного вычисления во время обратного прохода. По сути, это позволяет сэкономить память за счёт дополнительного времени вычислений.

cpu_ram_efficient_loading (`bool`, по умолчанию `None`) : Если True, только первый процесс загружает контрольную точку предобученной модели, а все остальные процессы имеют пустые веса. Применимо только для Transformers. При использовании этого параметра `sync_module_states` должен быть `True`.

transformer_cls_names_to_wrap (`Optional[List[str]]`, по умолчанию `None`) : список имён классов слоёв трансформера для обёртки. Применимо только тогда, когда `auto_wrap_policy` равно `transformer_based_wrap`.

min_num_params (`Optional[int]`, по умолчанию `None`) : минимальное количество параметров, которое должен иметь модуль, чтобы быть обернутым. Применимо только тогда, когда `auto_wrap_policy` равно `size_based_wrap`.

Это плагин используется для включения полностью шардированного параллелизма данных.

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

```python
set_auto_wrap_policy(model)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1941)

Создаёт `auto_wrap_policy` на основе переданной политики и возможности использования `transformer_cls_to_wrap` для `model`.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1981)

Устанавливает политику смешанной точности для FSDP

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1896)

Установите конфигурацию state dict на основе `StateDictType`.

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

```python
validate_mixed_precision_policy()
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2029)

Проверяет политику смешанной точности, абстрагированную так, чтобы не импортировать зависимости, если они не нужны.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L901)

**Параметры:**

num_steps (`int`) : Количество шагов для накопления градиентов.

adjust_scheduler (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли корректировать шаги планировщика с учётом количества накапливаемых шагов. Должно быть `True`, если используемый планировщик не был настроен для накопления градиентов.

sync_with_dataloader (`bool`, *необязательный*, по умолчанию `True`) : Синхронизировать ли установку градиентов в конце загрузчика данных.

sync_each_batch (`bool`, *необязательный*) : Синхронизировать ли установку градиентов для каждой партии данных. Установка значения `True` может снизить требования к памяти при использовании накопления градиентов в распределённом обучении, но за счёт скорости.

Плагин для настройки поведения накопления градиентов. В [Accelerator](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator) можно передать только один из параметров: `gradient_accumulation_plugin` или `gradient_accumulation_steps`. Передача обоих параметров приводит к ошибке.

Пример:

```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[int] = 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2211)

**Параметры:**

tp_degree (`int`, по умолчанию `None`) : степень параллелизма тензоров.

pp_degree (`int`, по умолчанию `None`) : Степень параллелизма конвейера.

num_micro_batches (`int`, по умолчанию `None`) : Количество микробатчей.

gradient_clipping (`float`, по умолчанию `None`) : Значение обрезки градиентов на основе глобальной L2-нормы (0 для отключения).

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`) : Если указаны оба загрузчика данных для tran и eval, этот параметр определяет `micro_batch_size`.

train_iters (`int`, по умолчанию `None`) : Общее количество образцов для обучения во всех тренировочных прогонах. Обратите внимание, что при использовании `MegatronLMDummyScheduler` необходимо указать либо train-iters, либо train-samples.

train_samples (`int`, по умолчанию `None`) : Общее количество образцов для обучения во всех тренировочных прогонах. Обратите внимание, что при использовании `MegatronLMDummyScheduler` необходимо указать либо train-iters, либо train-samples.

weight_decay_incr_style (`str`, по умолчанию `'constant'`) : функция приращения весового затухания. choices=["constant", "linear", "cosine"].

start_weight_decay (`float`, по умолчанию `None`) : Начальный коэффициент затухания весов для L2-регуляризации.

end_weight_decay (`float`, по умолчанию `None`) : Коэффициент весового затухания в конце обучения для L2-регуляризации.

lr_decay_style (`str`, по умолчанию `'linear'`) : Функция затухания скорости обучения. choices=['constant', 'linear', 'cosine'].

lr_decay_iters (`int`, по умолчанию `None`) : Количество итераций для затухания скорости обучения. Если значение равно None, по умолчанию используется `train_iters`.

lr_decay_samples (`int`, по умолчанию `None`) : Количество образцов для затухания скорости обучения. Если значение равно None, по умолчанию используется `train_samples`.

lr_warmup_iters (`int`, по умолчанию `None`) : Количество итераций для линейного повышения скорости обучения.

lr_warmup_samples (`int`, по умолчанию `None`) : Количество образцов, на протяжении которых линейно выполняется разгон скорости обучения.

lr_warmup_fraction (`float`, по умолчанию `None`) : Доля lr-warmup-(итераций/образцов), в течение которой линейно выполняется прогрев скорости обучения.

min_lr (`float`, по умолчанию `0`) : Минимальное значение для скорости обучения. Планировщик обрезает значения ниже этого порога.

consumed_samples (`List`, по умолчанию `None`) : Количество выборок, потребляемых в том же порядке, что и у загрузчиков данных, переданных в вызов `accelerator.prepare`.

no_wd_decay_cond (`Optional`, по умолчанию `None`) : Условие для отключения weight decay.

scale_lr_cond (`Optional`, по умолчанию `None`) : Условие для масштабирования скорости обучения.

lr_mult (`float`, по умолчанию `1.0`) : Множитель скорости обучения.

megatron_dataset_flag (`bool`, по умолчанию `False`) : Указывает, следует ли формат набора данных формату Indexed/Cached/MemoryMapped от Megatron-LM.

seq_length (`int`, по умолчанию `None`) : Максимальная длина последовательности для обработки.

encoder_seq_length (`int`, по умолчанию `None`) : Максимальная длина последовательности для обработки энкодером.

decoder_seq_length (`int`, по умолчанию `None`) : Максимальная длина последовательности для обработки декодером.

tensorboard_dir (`str`, по умолчанию `None`) : Путь для сохранения журналов tensorboard.

set_all_logging_options (`bool`, по умолчанию `False`) : Устанавливать ли все параметры журналирования.

eval_iters (`int`, по умолчанию `100`) : Количество итераций для выполнения оценки валидации/теста.

eval_interval (`int`, по умолчанию `1000`) : Интервал между запусками оценки на валидационном наборе данных.

return_logits (`bool`, по умолчанию `False`) : Возвращать ли логиты из модели.

custom_train_step_class (`Optional`, по умолчанию `None`) : Пользовательский класс шага обучения.

custom_train_step_kwargs (`Optional`, по умолчанию `None`) : Пользовательские аргументы для шага обучения.

custom_model_provider_function (`Optional`, по умолчанию `None`) : Пользовательская функция-провайдер модели.

custom_prepare_model_function (`Optional`, по умолчанию `None`) : Пользовательская функция подготовки модели.

custom_megatron_datasets_provider_function (`Optional`, по умолчанию `None`) : Пользовательская функция-провайдер датасетов train_valid_test для megatron.

custom_get_batch_function (`Optional`, по умолчанию `None`) : Пользовательская функция получения батча.

custom_loss_function (`Optional`, по умолчанию `None`) : Пользовательская функция потерь.

other_megatron_args (`Optional`, по умолчанию `None`) : Другие аргументы Megatron-LM. См. документацию Megatron-LM.

Плагин для Megatron-LM, обеспечивающий тензорное, конвейерное, последовательное и данные параллелизм. Также позволяет использовать выборочный пересчет активаций и оптимизированные слиянные ядра.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L953)

**Параметры:**

backend (`DynamoBackend`, по умолчанию `None`) : корректный бэкенд Dynamo. Подробнее см. https://pytorch.org/docs/stable/torch.compiler.html

mode (`str`, по умолчанию `None`) : Возможные значения: 'default', 'reduce-overhead' или 'max-autotune'.

fullgraph (`bool`, по умолчанию `None`) : Допустимо ли разбивать модель на несколько подграфов.

dynamic (`bool`, по умолчанию `None`) : Использовать ли динамическую форму для трассировки.

options (`Any`, по умолчанию `None`) : Словарь с параметрами для передачи в backend.

disable (`bool`, по умолчанию `False`) : превращает torch.compile() в no-op для тестирования

use_regional_compilation (`bool`, по умолчанию `None`) : Используйте этот параметр для сокращения времени компиляции при холодном запуске torch.compile(), нацеливаясь на повторяющиеся блоки одного класса и компилируя их последовательно, чтобы попадать в кэш компилятора. Например, в `GPT2LMHeadModel` повторяющимся блоком/классом является `GPT2Block`, к которому можно обратиться как `model.transformer.h[0]`. Остальная часть модели (например, model.lm_head) компилируется отдельно.

Это плагин используется для компиляции модели с PyTorch 2.0

## Конфигурации[[accelerate.utils.BnbQuantizationConfig]]

Это классы, которые можно настроить и передать в соответствующую интеграцию

#### 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[str] = None, keep_in_fp32_modules: list[str] = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2950)

**Параметры:**

load_in_8bit (`bool`, по умолчанию `False`) : Включает 8-битное квантование.

llm_int8_threshold (`float`, по умолчанию `6.0`) : Значение порога для outliner. Актуально только при `load_in_8bit=True`.

load_in_4bit (`bool`, по умолчанию `False`) : Включает 4-битовое квантование.

bnb_4bit_quant_type (`str`, по умолчанию `fp4`) : Задаёт тип данных квантования в слоях `bnb.nn.Linear4Bit`. Варианты: {'fp4','np4'}.

bnb_4bit_use_double_quant (`bool`, по умолчанию `False`) : Включает вложенное квантование, при котором константы квантования из первого этапа квантования квантуются повторно.

bnb_4bit_compute_dtype (`bool`, по умолчанию `fp16`) : Этот параметр задает тип вычислений, который может отличаться от типа входных данных. Например, входные данные могут быть fp32, но для ускорения вычислений можно установить bf16. Доступные варианты: {'fp32','fp16','bf16'}.

torch_dtype (`torch.dtype`, по умолчанию `None`) : Этот параметр задаёт dtype для оставшихся не квантованных слоёв. Библиотека `bitsandbytes` рекомендует устанавливать значение `torch.float16` для 8-битной модели и использовать тот же dtype, что и dtype вычислений, для 4-битной модели.

skip_modules (`List[str]`, по умолчанию `None`) : Явный список модулей, которые не квантуются. Тип данных этих модулей будет `torch_dtype`.

keep_in_fp32_modules (`List`, по умолчанию `None`) : Явный список модулей, которые мы не квантуем. Мы оставляем их в `torch.float32`.

Плагин для включения квантования BitsAndBytes в 4-битном и 8-битном форматах

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L743)

**Параметры:**

split_batches (`bool`, по умолчанию `False`) : Указывает, следует ли ускорителю распределять батчи, возвращаемые загрузчиками данных, между устройствами. Если `True`, фактический размер батча будет одинаковым для любого типа распределённых процессов, но он должен быть кратным `num_processes`, которые вы используете. Если `False`, фактический размер батча будет равен значению, заданному в вашем скрипте, умноженному на количество процессов.

dispatch_batches (`bool`, по умолчанию `None`) : Если установлено в `True`, dataloader, подготовленный Accelerator, итерируется только в основном процессе, после чего батчи разделяются и транслируются каждому процессу. По умолчанию будет `True` для `DataLoader`, чьим базовым датасетом является `IterableDataset`, в противном случае — `False`.

even_batches (`bool`, по умолчанию `True`) : Если установлено в `True`, то в случаях, когда общий размер батча во всех процессах не делится на размер набора данных без остатка, образцы в начале набора данных будут продублированы, чтобы батч можно было разделить поровну между всеми воркерами.

use_seedable_sampler (`bool`, по умолчанию `False`) : Использовать ли полностью воспроизводимый случайный сэмплер (`data_loader.SeedableRandomSampler`). Гарантирует полную воспроизводимость результатов обучения с использованием другой техники выборки. Хотя результаты при разных значениях seed могут отличаться, в среднем различия пренебрежимо малы при сравнении нескольких разных seed. Для наилучших результатов также следует использовать [set_seed()](/docs/accelerate/v1.16.0/ru/package_reference/utilities#accelerate.utils.set_seed).

data_seed (`int`, по умолчанию `None`) : Значение seed для базового генератора при использовании `use_seedable_sampler`. Если `None`, генератор будет использовать текущий seed по умолчанию из torch.

non_blocking (`bool`, по умолчанию `False`) : Если установлено в `True`, загрузчик данных, подготовленный Accelerator, будет использовать неблокирующие передачи с хоста на устройство, что позволяет лучше перекрывать коммуникацию загрузчика данных и вычисления. Рекомендуется, чтобы у подготовленного загрузчика данных `pin_memory` было установлено в `True` для корректной работы.

use_stateful_dataloader (`bool`, по умолчанию `False`) : Если установлено в `True`, dataloader, подготовленный Accelerator, будет использовать [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Для этого требуется установка версии `torchdata` 0.8.0 или выше, поддерживающей StatefulDataLoader.

Конфигурация для элементов, связанных с загрузчиком данных, при вызове `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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L838)

**Параметры:**

project_dir (`str`, по умолчанию `None`) : Путь к каталогу для хранения данных.

logging_dir (`str`, по умолчанию `None`) : Путь к каталогу для хранения журналов локально-совместимых логгеров. Если значение равно None, по умолчанию используется `project_dir`.

automatic_checkpoint_naming (`bool`, по умолчанию `False`) : Нужно ли автоматически присваивать итеративные имена сохраняемым состояниям.

total_limit (`int`, по умолчанию `None`) : Максимальное количество сохраняемых состояний, которое следует хранить.

iteration (`int`, по умолчанию `0`) : Текущая итерация сохранения.

save_on_each_node (`bool`, по умолчанию `False`) : При распределённом обучении на нескольких узлах указывает, следует ли сохранять модели и контрольные точки на каждом узле или только на главном.

Конфигурация объекта Accelerator в соответствии с потребностями внутреннего проекта.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L890)

Устанавливает `self.project_dir` и `self.logging_dir` в соответствующие значения.

## Переменные окружения

Это переменные окружения, которые можно включить для различных сценариев использования

* `ACCELERATE_DEBUG_MODE` (`str`): Запуск accelerate в режиме отладки. Подробнее — [здесь](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors).

## Манипуляции с данными и операции[[accelerate.utils.broadcast]]

К ним относятся операции с данными, которые имитируют те же самые операции `torch`, но могут использоваться в распределённых процессах.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L583)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : Данные для сбора.

from_process (`int`, *необязательный*, по умолчанию 0) : Процесс, от которого отправляются данные

**Возвращает:**

Та же структура данных, что и `tensor`, но со всеми тензорами, рассредоточенными на соответствующем устройстве.

Рекурсивно распространить тензор по всем устройствам в вложенном списке/кортеже/словаре тензоров.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L658)

**Параметры:**

object_list (list of picklable objects) : Список объектов для широковещательной передачи. Этот список будет изменён на месте.

from_process (`int`, *необязательный*, по умолчанию 0) : Процесс, от которого отправляются данные.

**Возвращает:**

Тот же самый список, содержащий объекты из процесса 0.

Broadcast списка объектов, поддерживающих сериализацию, из одного процесса в остальные.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L702)

**Параметры:**

data (вложенный список/кортеж/словарь списков тензоров `torch.Tensor`) : данные для конкатенации.

dim (`int`, *optional*, по умолчанию 0) : Размерность, по которой выполняется конкатенация.

**Возвращает:**

Та же структура данных, что и `data`, но со всеми тензорами, объединёнными в один.

Рекурсивно конкатенирует тензоры в вложенном списке/кортеже/словаре списков тензоров с одинаковой формой. Если имеется только одна партия данных, она возвращается без изменений.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L922)

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L872)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : данные для преобразования из FP16/BF16 в FP32.

**Возвращает:**

Та же структура данных, что и у `tensor`, но все тензоры, которые были с точностью FP16/BF16, преобразованы в FP32.

Рекурсивно преобразует элементы вложенных списков/кортежей/словарей тензоров с точностью FP16/BF16 в FP32.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L414)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : Данные для сбора.

**Возвращает:**

Та же структура данных, что и у `tensor`, но со всеми тензорами, перемещёнными на соответствующее устройство.

Рекурсивно собрать тензор из вложенного списка/кортежа/словаря тензоров со всех устройств.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L495)

**Параметры:**

object (вложенный список/кортеж/словарь объектов, поддерживающих сериализацию) : данные для сбора.

**Возвращает:**

Та же структура данных, что и `object`, со всеми объектами, отправленными на каждое устройство.

Рекурсивно собирает объект из вложенного списка/кортежа/словаря объектов со всех устройств.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L2089)

**Параметры:**

distributed_type (`DistributedType`, *необязательный*, по умолчанию None) : Тип распределённой среды.

kwargs : Дополнительные аргументы для используемого конструктора `GradScaler`.

Универсальный вспомогательный метод, который инициализирует правильную реализацию `GradScaler` в зависимости от окружения и возвращает её.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L2047)

**Параметры:**

native_amp (`bool`, *необязательный*, по умолчанию False) : Включено ли смешанное прецизионное вычисление.

Возвращает менеджер контекста для автоматического приведения к смешанной точности

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L270)

**Параметры:**

data (вложенный список/кортеж/словарь `torch.Tensor`) : данные, из которых выполняется преобразование в обычные числа.

**Возвращает:**

Та же структура данных, что и `data`, но со списками чисел вместо `torch.Tensor`.

Рекурсивно находит тензоры во вложенном списке/кортеже/словаре и преобразует их в список чисел.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L732)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : Данные для сбора.

dim (`int`, *optional*, по умолчанию 0) : Размерность, по которой выполняется добавление отступов.

pad_index (`int`, *необязательный*, по умолчанию 0) : Значение, используемое для дополнения.

pad_first (`bool`, *необязательный*, по умолчанию `False`) : Указывает, нужно ли добавлять заполнители в начале или в конце.

Рекурсивно дополните тензоры в вложенном списке/кортеже/словаре тензоров со всех устройств до одинакового размера, чтобы их можно было безопасно собрать.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L85)

**Параметры:**

func (`callable`) : функция, которую нужно применить рекурсивно.

data (вложенный список/кортеж/словарь объектов, принимаемых `test_type`) : данные, на которые нужно применить `func`

- ***args** : Позиционные аргументы, которые будут переданы в `func` при применении к распакованным данным.

test_type (`Callable[[Any], bool]`, *необязательный*, по умолчанию `is_torch_tensor`) : Предикат, определяющий, следует ли применять `func` к данному объекту-листу.

error_on_other_type (`bool`, *необязательный*, по умолчанию `False`) : следует ли возвращать ошибку, если после распаковки `data` получается объект, для которого `test_type` возвращает `False`. Если `False`, функция оставит такие объекты без изменений.

- ****kwargs** (дополнительные именованные аргументы, *необязательный*) : Именованные аргументы, которые будут переданы в `func` при применении к распакованным данным.

**Возвращает:**

Та же структура данных, что и `data`, с применением `func` к каждому объекту, для которого `test_type` возвращает `True`.

Рекурсивно применяет функцию к структуре данных, представляющей собой вложенный список/кортеж/словарь заданного базового типа.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L828)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : данные для сведения.

reduction (`str`, *необязательный*, по умолчанию `"mean"`) : Метод агрегации. Может принимать значения "mean", "sum", "max" или "none"

scale (`float`, *необязательный*) : Значение масштабирования по умолчанию, применяемое после reduce, действует только на XLA.

**Возвращает:**

Та же структура данных, что и `data`, но со всеми тензорами, приведёнными к скалярам.

Рекурсивно сводит тензоры в вложенном списке/кортеже/словаре списков тензоров по всем процессам, вычисляя среднее значение с помощью заданной операции.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L136)

**Параметры:**

tensor (вложенный список/кортеж/словарь `torch.Tensor`) : данные для отправки на указанное устройство.

device (`torch.device`) : Устройство, на которое нужно отправить данные.

non_blocking (`bool`, *необязательный*, по умолчанию `False`) : Если `True`, передача на устройство выполняется асинхронно, что позволяет перекрывать перемещение данных с вычислениями. Действует только в том случае, если устройство это поддерживает (например, CUDA).

skip_keys (`str` или `List[str]`, *необязательный*) : Ключ или список ключей в словаре `tensor`, значения которых не следует отправлять на указанное `device`. Записи с этими ключами остаются на исходном устройстве.

**Возвращает:**

Та же структура данных, что и у `tensor`, но со всеми тензорами, перемещёнными на соответствующее устройство.

Рекурсивно отправляет элементы вложенного списка/кортежа/словаря тензоров на указанное устройство.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L682)

**Параметры:**

data (вложенный список/кортеж/словарь `torch.Tensor`) : данные для нарезки.

tensor_slice (`slice`) : Срез, который нужно взять.

**Возвращает:**

Та же структура данных, что и `data`, но со всеми срезами тензоров.

Рекурсивно извлекает срез из вложенного списка/кортежа/словаря тензоров.

## Проверки окружения[[accelerate.utils.is_bf16_available]]

Эти функции проверяют состояние текущей рабочей среды, включая информацию о самой операционной системе, о том, что она поддерживает, и установлены ли определённые зависимости.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/imports.py#L157)

Проверяет, поддерживается ли bf16, с возможностью игнорирования TPU

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/imports.py#L325)

Проверяет, доступно ли устройство MPS. Минимальная требуемая версия — 1.12.

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

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

Проверяет, установлен ли `torch_npu` и, при необходимости, присутствует ли NPU в окружении

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/versions.py#L46)

**Параметры:**

operation (`str`) : строковое представление оператора, например `">"` или `"<="`

version (`str`) : Строковая версия PyTorch

Сравнивает текущую версию PyTorch с заданной эталонной с помощью операции.

#### 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)
```

Проверьте, доступен ли `torch_xla`. Чтобы обучать нативную задачу pytorch в среде, где установлен torch xla, установите USE_TORCH_XLA в false.

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

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

Проверяет, доступна ли ускорение XPU через стандартный PyTorch (>=2.7) и, возможно, присутствует ли XPU в окружении

## Управление окружением[[accelerate.utils.patch_environment]]

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L380)

Контекстный менеджер, который добавляет каждый переданный аргумент с ключом в `os.environ` и удаляет их при выходе.

Преобразует значения в `kwargs` в строки и переводит все ключи в верхний регистр.

Пример:

```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()
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L345)

Контекстный менеджер, который временно очищает переменные окружения.

При выходе из этого контекста предыдущие переменные окружения будут восстановлены.

Пример:

```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')
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/commands/config/default.py#L27)

**Параметры:**

mixed_precision (`str`, *необязательный*, по умолчанию "no") : Режим смешанной точности. Должно быть одним из "no", "fp16" или "bf16"

save_location (`str`, *необязательный*, по умолчанию `default_json_config_file`) : Необязательное пользовательское место сохранения. Должно передаваться в `--config_file` при использовании `accelerate launch`. По умолчанию файл находится в каталоге кэша huggingface (`~/.cache/huggingface`), но это можно изменить, задав переменную окружения `HF_HOME`, после чего используется путь `accelerate/default_config.yaml`.

Создаёт и сохраняет базовый конфигурационный файл кластера для использования на локальной машине, потенциально оснащённой несколькими GPU. Если машина работает только на CPU, будет настроен и CPU.

При первой настройке 🤗 Accelerate вместо запуска `accelerate config` в качестве альтернативы для быстрой конфигурации можно использовать [~utils.write_basic_config].

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

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

**Параметры:**

local_process_index (int) : Индекс текущего процесса на текущем сервере.

verbose (bool, *optional*) : Выводить ли новое распределение CPU-ядер для каждого процесса. Если `ACCELERATE_DEBUG_MODE` включен, значение по умолчанию — True.

Назначает текущий процесс на конкретный NUMA-узел. Наиболее эффективно, когда на каждом узле имеется как минимум 2 CPU.

Этот результат кэшируется между вызовами. Если вы хотите переопределить его, используйте `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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L262)

**Параметры:**

local_process_index (int) : Индекс текущего процесса на текущем сервере.

verbose (bool, *optional*) : Выводить ли в лог назначение каждого CPU. Если `ACCELERATE_DEBUG_MODE` включен, значение по умолчанию — True.

Переопределяет любую установленную NUMA-аффинность для текущего процесса. Это очень ресурсоёмкая операция, требующая пересчёта аффинности, которую необходимо установить; в идеале следует использовать `utils.environment.set_numa_affinity`.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L417)

Декоратор для очистки переменных окружения accelerate, установленных декорируемым классом или функцией.

В некоторых обстоятельствах вызов определённых классов или функций может привести к установке переменных окружения accelerate, которые затем не очищаются. В качестве примера, при вызове:

TrainingArguments(fp16=True, ...)

Будет установлена следующая переменная окружения:

ACCELERATE_MIXED_PRECISION=fp16

Это может повлиять на последующий код, так как переменная окружения имеет приоритет над TrainingArguments(fp16=False). Это особенно важно для модульного тестирования, где мы хотим избежать побочных эффектов отдельных тестов друг на друга. Используйте этот декоратор для функции модульного теста или всего класса, чтобы гарантировать, что после каждого теста переменные окружения будут очищены. Это работает как для unittest.TestCase, так и для обычных классов (pytest); также работает при декорировании родительского класса.

## Память[[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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/memory.py#L94)

**Параметры:**

function (`callable`, *необязательный*) : функция для обёртки

starting_batch_size (`int`, *необязательный*) : Размер батча, который нужно попытаться уместить в памяти

reduce_batch_size_fn (`callable`, *необязательный*) : функция для определения нового размера батча после ошибки нехватки памяти. Если не указана, размер батча умножается на 0.9 при каждой неудаче. Функция не принимает аргументов и должна возвращать новый (уменьшенный) размер батча в виде `int`.

Базовый декоратор, который пытается выполнить `function`. Если возникает исключение, связанное с нехваткой памяти или CUDNN, размер батча умножается на 0.9 и передаётся в `function`

`function` должен принимать параметр `batch_size` в качестве первого аргумента.

Пример:

```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)
```

## Моделирование[[accelerate.utils.calculate_maximum_sizes]]

Эти утилиты связаны с взаимодействием с моделями PyTorch

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1048)

Вычисляет общий размер модели и её самого крупного слоя

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L675)

Вычислите размер каждого подмодуля заданной модели.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L286)

**Параметры:**

model (`torch.nn.Module`) : модель, из которой выполняется извлечение.

keep_fp32_wrapper (`bool`, *необязательный*) : Указывает, следует ли удалять хуки смешанной точности из модели.

keep_torch_compile (`bool`, *необязательный*) : Нужно ли развернуть скомпилированную модель.

recursive (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли рекурсивно извлекать все случаи `module.module` из `model`, а также рекурсивно разворачивать дочерние подслои, а не только распределённые контейнеры верхнего уровня.

**Возвращает:** `torch.nn.Module`

Извлеченная модель.

Извлечение модели из её распределённых контейнеров.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L916)

**Параметры:**

model (`torch.nn.Module`) : модель для анализа.

max_memory (`Dict`, *необязательный*) : Словарь с идентификаторами устройств и максимальным объемом памяти. Если не задано, по умолчанию используется максимально доступная память. Пример: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *необязательный*) : Список имён классов слоёв, которые никогда не должны разделяться между устройствами (например, любой слой, имеющий остаточное соединение).

dtype (`str` или `torch.dtype`, *необязательный*) : Если указано, веса будут преобразованы в этот тип при загрузке.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *необязательный*) : Если указано, специальные dtypes, которые следует учитывать для некоторых конкретных весов (перекрывает dtype, используемый по умолчанию для всех весов).

low_zero (`bool`, *необязательный*) : Минимизирует количество весов на GPU 0, что удобно, когда она используется для других операций (например, для функции generate из Transformers).

Вычислите словарь `max_memory` для [infer_auto_device_map()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.infer_auto_device_map), который сбалансирует использование каждого доступного GPU.

Все вычисления выполняются на основе анализа размеров и dtypes параметров модели. В результате модель может находиться на meta-устройстве (как если бы она была инициализирована внутри контекстного менеджера `init_empty_weights`).

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

```python
accelerate.utils.get_max_layer_size(modules: list[tuple[str, torch.nn.Module]], module_sizes: dict[str, int], no_split_module_classes: list[str])
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L729)

**Параметры:**

modules (`List[Tuple[str, torch.nn.Module]]`) : Список именованных модулей, для которых требуется определить максимальный размер слоя.

module_sizes (`Dict[str, int]`) : Словарь, сопоставляющий каждому имени слоя его размер (сформированный с помощью `compute_module_sizes`).

no_split_module_classes (`List[str]`) : список имён классов для слоёв, которые не следует разделять.

**Возвращает:** `Tuple[int, List[str]]`

Максимальный размер слоя со списком имён слоёв, реализующих этот максимальный размер.

Вспомогательная функция, которая просматривает список именованных модулей и возвращает максимальный размер, используемый одним полным слоем. Определение слоя:
- модуль без прямых дочерних элементов (только параметры и буферы)
- модуль, имя класса которого входит в список `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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1278)

**Параметры:**

model (`torch.nn.Module`) : модель для анализа.

max_memory (`Dict`, *необязательный*) : Словарь с идентификаторами устройств и максимальным объемом памяти. Если не задано, по умолчанию используется максимально доступная память. Пример: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *необязательный*) : Список имён классов слоёв, которые никогда не должны разделяться между устройствами (например, любой слой, имеющий остаточное соединение).

dtype (`str` или `torch.dtype`, *необязательный*) : Если указано, веса будут преобразованы в этот тип при загрузке.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *необязательный*) : Если указано, специальные dtypes, которые следует учитывать для некоторых конкретных весов (перекрывает dtype, используемый по умолчанию для всех весов).

verbose (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли выводить отладочные сообщения при построении device_map функцией.

clean_result (`bool`, *необязательный*, по умолчанию `True`) : Упрощает итоговый device_map, объединяя все подмодули, размещаемые на одном и том же устройстве.

offload_buffers (`bool`, *необязательный*, по умолчанию `False`) : В слоях, выгружаемых на CPU или на диск, выгружать ли буферы наряду с параметрами.

fallback_allocation (`bool`, *необязательный*, по умолчанию `False`) : Если обычное выделение памяти не удаётся, попытаться выделить модуль, который помещается в заданный лимит размера, используя BFS.

Вычислите карту устройств для заданной модели, отдавая приоритет GPU, затем выгружая на CPU и, наконец, на диск, так чтобы:
- мы не превышаем доступную память ни на одном из GPU.
- Если требуется offload на CPU, на GPU 0 всегда остаётся место, чтобы вернуть обратно слой с наибольшим размером, который был offloaded на CPU.
- если требуется offload на CPU, мы не превышаем доступный объём ОЗУ на CPU.
- Если требуется offload на диск, на CPU всегда остаётся место для возвращения слоя, offload'нутого на диск, с наибольшим размером.

Все вычисления выполняются на основе анализа размеров и dtypes параметров модели. В результате модель может находиться на meta-устройстве (как если бы она была инициализирована внутри контекстного менеджера `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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1786)

**Параметры:**

model (`torch.nn.Module`) : модель, в которую мы хотим загрузить контрольную точку.

checkpoint (`str` или `os.PathLike`) : Папка контрольной точки для загрузки. Она может быть: - путём к файлу, содержащему полный state dict модели - путём к файлу `.json`, содержащему индекс для шардированной контрольной точки - путём к папке, содержащей уникальный файл `.index.json` и шарды контрольной точки. - путём к папке, содержащей уникальный файл pytorch_model.bin или model.safetensors.

device_map (`Dict[str, Union[int, str, torch.device]]`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать точные имена каждого параметра/буфера: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.

offload_folder (`str` или `os.PathLike`, *необязательный*) : Если `device_map` содержит значение `"disk"`, то это папка, куда будут выгружаться веса.

dtype (`str` или `torch.dtype`, *необязательный*) : Если указано, веса будут преобразованы в этот тип при загрузке.

offload_state_dict (`bool`, *необязательный*, по умолчанию `False`) : Если `True`, состояние CPU state dict будет временно выгружаться на диск, чтобы избежать нехватки оперативной памяти CPU, если вес CPU state dict и крупнейшего шарда не помещаются в неё.

offload_buffers (`bool`, *необязательный*, по умолчанию `False`) : Включать ли буферы в веса, выгружаемые на диск.

keep_in_fp32_modules(`List[str]`, *необязательный*) : Список модулей, которые мы сохраняем в типе данных `torch.float32`.

offload_8bit_bnb (`bool`, *необязательный*) : Включать ли offload 8-битных модулей на cpu/disk.

strict (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли строго требовать, чтобы ключи в state_dict контрольной точки совпадали с ключами state_dict модели.

full_state_dict (`bool`, *необязательный*, по умолчанию `True`) : если установлено значение `True`, все тензоры в загруженном state_dict будут собраны. В загруженном state_dict не будет ShardedTensor и DTensor.

broadcast_from_rank0 (`False`, *необязательный*, по умолчанию `False`) : если параметр установлен в `True`, необходимо инициализировать распределённую `ProcessGroup`. rank0 должен получить полный state_dict и последовательно рассылать тензоры из state_dict по одному на другие ранги. Остальные ранги получают тензоры и, при необходимости, разбивают их на фрагменты в соответствии с локальными фрагментами в модели.

Загружает (возможно, разбитый на части) контрольный пункт внутри модели, при необходимости отправляя веса на указанное устройство по мере их загрузки.

Once loaded across devices, you still need to call [dispatch_model()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.dispatch_model) on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ru/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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L875)

**Параметры:**

model (`torch.nn.Module`) : модель, в которую будут загружены веса.

index (`dict`) : Словарь, содержащий имя параметра и его метаданные для каждого параметра, выгруженного из модели.

offload_folder (`str`) : Папка, в которой хранятся выгруженные веса.

Загружает веса из папки offload в модель.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1620)

**Параметры:**

checkpoint_file (`str`) : Путь к контрольной точке для загрузки.

device_map (`Dict[str, Union[int, str, torch.device]]`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать точные имена каждого параметра/буфера: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.

Загрузить контрольную точку из указанного файла. Если контрольная точка в формате safetensors и передана карта устройств, веса можно быстро загрузить непосредственно на 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[str, torch.Tensor])
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/offload.py#L94)

**Параметры:**

save_dir (`str` или `os.PathLike`) : Каталог, в который выгружается state dict.

state_dict (`Dict[str, torch.Tensor]`) : Словарь тензоров для выгрузки.

Разместите state dict в указанной папке.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L633)

**Параметры:**

model (`torch.nn.Module`) : модель, в которой необходимо перепривязать параметры.

tied_params (`List[List[str]]`) : Параметр отображения имени параметра в имя связанного параметра, полученный с помощью `find_tied_parameters`.

Повторно связывает связанные параметры в указанной модели, если связь была нарушена (например, при добавлении хуков).

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L226)

**Параметры:**

module (`torch.nn.Module`) : модуль, в котором находится тензор, который мы хотим переместить.

tensor_name (`str`) : Полное имя параметра/буфера.

device (`int`, `str` или `torch.device`) : Устройство, на котором следует разместить тензор.

value (`torch.Tensor`, *необязательный*) : значение тензора (полезно при переходе с meta-устройства на любое другое устройство).

dtype (`torch.dtype`, *необязательный*) : Если передано, значение параметра будет приведено к этому `dtype`. В противном случае `value` будет приведено к типу данных существующего параметра в модели.

fp16_statistics (`torch.HalfTensor`, *optional*) : Список статистики fp16 для установки на модуль, используется для сериализации модели 8 бит.

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *optional*, по умолчанию `None`) : Соответствие текущих указателей данных словарям устройств с уже распределёнными связанными весами. Для данного устройства выполнения этот параметр полезен для повторного использования первого доступного указателя общего веса на устройстве для всех остальных, вместо дублирования памяти.

non_blocking (`bool`, *необязательный*, по умолчанию `False`) : Если `True`, передача на устройство будет выполняться асинхронно относительно хоста, если это возможно.

clear_cache (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли очищать кэш устройства после установки тензора на устройство.

Вспомогательная функция для перемещения заданного тензора (параметра или буфера) модуля на конкретное устройство (обратите внимание, что выполнение `param.to(device)` создает новый тензор, не связанный с параметром, поэтому эта функция необходима).

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L605)

**Параметры:**

model (`torch.nn.Module`) : модель, для которой нужно получить дочерние модули

**Возвращает:** `list[torch.nn.Module]`

список дочерних модулей `model` в порядке снизу вверх. Последний элемент — это сама `model`.

Обходите модель в порядке снизу вверх и возвращайте дочерние модули в этом порядке.

## Параллельно[[accelerate.utils.extract_model_from_parallel]]

К ним относятся общие утилиты, которые следует использовать при работе в параллельном режиме.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L286)

**Параметры:**

model (`torch.nn.Module`) : модель, из которой выполняется извлечение.

keep_fp32_wrapper (`bool`, *необязательный*) : Указывает, следует ли удалять хуки смешанной точности из модели.

keep_torch_compile (`bool`, *необязательный*) : Нужно ли развернуть скомпилированную модель.

recursive (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли рекурсивно извлекать все случаи `module.module` из `model`, а также рекурсивно разворачивать дочерние подслои, а не только распределённые контейнеры верхнего уровня.

**Возвращает:** `torch.nn.Module`

Извлеченная модель.

Извлечение модели из её распределённых контейнеров.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L424)

**Параметры:**

obj : данные для сохранения

f : файл (или объект, похожий на файл), используемый для сохранения данных

save_on_each_node (`bool`, *необязательный*, по умолчанию `False`) : Сохранять ли данные только на глобальном главном процессе

safe_serialization (`bool`, *необязательный*, по умолчанию `False`) : Сохранять ли `obj` с помощью `safetensors` или традиционным способом PyTorch (с использованием `pickle`).

Сохраните данные на диск. Используйте вместо `torch.save()`.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L474)

**Параметры:**

f : файл (или объект, похожий на файл), используемый для загрузки данных

map_location : функция, `torch.device`, строка или словарь, определяющие способ переназначения мест хранения данных

- ****kwargs** : Дополнительные именованные аргументы для передачи в `torch.load()`.

Совместимая замена `torch.load()`, позволяющая использовать `weights_only`, если версия `torch` равна 2.4.0 или выше. В противном случае этот аргумент игнорируется.

Также будет добавлено (а затем удалено) исключение для массивов numpy

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L376)

Вводит точку блокировки в скрипте, гарантируя, что все процессы достигли этой точки перед продолжением выполнения.

Убедитесь, что все процессы дойдут до этой инструкции, иначе один из ваших процессов будет зависать навсегда.

## Случайный[[accelerate.utils.set_seed]]

Эти утилиты связаны с установкой и синхронизацией всех случайных состояний.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L34)

**Параметры:**

seed (`int`) : Значение, задающее начальное состояние генератора случайных чисел.

device_specific (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли слегка изменять seed на каждом устройстве с помощью `self.process_index`.

deterministic (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли детерминированные алгоритмы, если они доступны. Может замедлить обучение.

Вспомогательная функция для воспроизводимого поведения: устанавливает seed в `random`, `numpy`, `torch`.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L63)

Синхронизировать встроенный ГСЧ или ГСЧ текущего ускорителя, идентифицированный по типу устройства.

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

```python
accelerate.synchronize_rng_states(rng_types: list[str | accelerate.utils.dataclasses.RNGType], generator: torch.Generator | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L127)

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

К ним относятся утилиты, полезные при использовании PyTorch с XLA.

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

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

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/torch_xla.py#L20)

**Параметры:**

upgrade (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли обновить `torch` и установить последние колёса `torch_xla`.

Вспомогательная функция для установки соответствующих xla-колёс в зависимости от версии `torch` в Google Colaboratory.

Пример:

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

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

## Загрузка весов модели[[accelerate.load_checkpoint_in_model]]

Сюда входят утилиты, полезные для загрузки контрольных точек.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1786)

**Параметры:**

model (`torch.nn.Module`) : модель, в которую мы хотим загрузить контрольную точку.

checkpoint (`str` или `os.PathLike`) : Папка контрольной точки для загрузки. Она может быть: - путём к файлу, содержащему полный state dict модели - путём к файлу `.json`, содержащему индекс для шардированной контрольной точки - путём к папке, содержащей уникальный файл `.index.json` и шарды контрольной точки. - путём к папке, содержащей уникальный файл pytorch_model.bin или model.safetensors.

device_map (`Dict[str, Union[int, str, torch.device]]`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать точные имена каждого параметра/буфера: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.

offload_folder (`str` или `os.PathLike`, *необязательный*) : Если `device_map` содержит значение `"disk"`, то это папка, куда будут выгружаться веса.

dtype (`str` или `torch.dtype`, *необязательный*) : Если указано, веса будут преобразованы в этот тип при загрузке.

offload_state_dict (`bool`, *необязательный*, по умолчанию `False`) : Если `True`, состояние CPU state dict будет временно выгружаться на диск, чтобы избежать нехватки оперативной памяти CPU, если вес CPU state dict и крупнейшего шарда не помещаются в неё.

offload_buffers (`bool`, *необязательный*, по умолчанию `False`) : Включать ли буферы в веса, выгружаемые на диск.

keep_in_fp32_modules(`List[str]`, *необязательный*) : Список модулей, которые мы сохраняем в типе данных `torch.float32`.

offload_8bit_bnb (`bool`, *необязательный*) : Включать ли offload 8-битных модулей на cpu/disk.

strict (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли строго требовать, чтобы ключи в state_dict контрольной точки совпадали с ключами state_dict модели.

full_state_dict (`bool`, *необязательный*, по умолчанию `True`) : если установлено значение `True`, все тензоры в загруженном state_dict будут собраны. В загруженном state_dict не будет ShardedTensor и DTensor.

broadcast_from_rank0 (`False`, *необязательный*, по умолчанию `False`) : если параметр установлен в `True`, необходимо инициализировать распределённую `ProcessGroup`. rank0 должен получить полный state_dict и последовательно рассылать тензоры из state_dict по одному на другие ранги. Остальные ранги получают тензоры и, при необходимости, разбивают их на фрагменты в соответствии с локальными фрагментами в модели.

Загружает (возможно, разбитый на части) контрольный пункт внутри модели, при необходимости отправляя веса на указанное устройство по мере их загрузки.

Once loaded across devices, you still need to call [dispatch_model()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.dispatch_model) on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

## Квантование[[accelerate.utils.load_and_quantize_model]]

Сюда входят утилиты, полезные для квантования модели.

#### 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)
```

[Источник](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/bnb.py#L44)

**Параметры:**

model (`torch.nn.Module`) : входная модель. Модель может быть уже загружена или находиться на мета-устройстве

bnb_quantization_config (`BnbQuantizationConfig`) : параметры квантования bitsandbytes

weights_location (`str` или `os.PathLike`) : Папка weights_location для загрузки. Она может быть: - путём к файлу, содержащему полный state dict модели - путём к файлу `.json`, содержащему индекс для шардированного чекпоинта - путём к папке, содержащей уникальный файл `.index.json` и шарды чекпоинта. - путём к папке, содержащей уникальный файл pytorch_model.bin.

device_map (`Dict[str, Union[int, str, torch.device]]`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать точные имена каждого параметра/буфера: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.

no_split_module_classes (`List[str]`, *необязательный*) : Список имён классов слоёв, которые никогда не должны разделяться между устройствами (например, любой слой, имеющий остаточное соединение).

max_memory (`Dict`, *необязательный*) : Словарь, сопоставляющий идентификатор устройства с максимальным объемом памяти. Если не задано, по умолчанию используется максимально доступная память.

offload_folder (`str` или `os.PathLike`, *необязательный*) : Если `device_map` содержит значение `"disk"`, то это папка, куда будут выгружаться веса.

offload_state_dict (`bool`, *необязательный*, по умолчанию `False`) : Если `True`, состояние CPU state dict будет временно выгружаться на диск, чтобы избежать нехватки оперативной памяти CPU, если вес CPU state dict и крупнейшего шарда не помещаются в неё.

**Возвращает:** `torch.nn.Module`

Квантованная модель

Эта функция выполняет квантование входной модели с использованием связанной конфигурации, переданной в `bnb_quantization_config`. Если модель находится на meta-устройстве, веса будут загружены и распределены в соответствии с переданным `device_map`. Если модель уже загружена, мы выполним её квантование и разместим модель на GPU,

