# Работа с большими моделями

## Диспетчеризация и выгрузка

### init_empty_weights[[accelerate.init_empty_weights]]

#### accelerate.init_empty_weights[[accelerate.init_empty_weights]]

```python
accelerate.init_empty_weights(include_buffers: bool | None = None)
```

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

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

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

Контекстный менеджер, в рамках которого модели инициализируются со всеми параметрами на мета-устройстве, что приводит к созданию пустой модели. Полезно в тех случаях, когда сама инициализация модели исчерпывает доступную оперативную память.

Пример:

```python
import torch.nn as nn
from accelerate import init_empty_weights

# Initialize a model with 100 billions parameters in no time and without using any RAM.
with init_empty_weights():
    tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])
```

Any model created under this context manager has no weights. As such you can't do something like `model.to(some_device)` with it. To load weights inside your empty model, see [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch). Make sure to overwrite the default device_map param for [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch), otherwise dispatch is not called.

### cpu_offload[[accelerate.cpu_offload]]

#### accelerate.cpu_offload[[accelerate.cpu_offload]]

```python
accelerate.cpu_offload(model: Module, execution_device: torch.device | None = None, offload_buffers: bool = False, state_dict: dict[str, torch.Tensor] | None = None, preload_module_classes: list[str] | None = None)
```

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

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

model (`torch.nn.Module`) : модель для выгрузки.

execution_device (`torch.device`, *необязательный*) : Устройство, на котором будет выполняться прямой проход модели (должно быть GPU). По умолчанию используется устройство первого параметра модели.

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

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

### cpu_offload_with_hook[[accelerate.cpu_offload_with_hook]]

#### accelerate.cpu_offload_with_hook[[accelerate.cpu_offload_with_hook]]

```python
accelerate.cpu_offload_with_hook(model: Module, execution_device: int | str | torch.device | None = None, prev_module_hook: accelerate.hooks.UserCpuOffloadHook | None = None)
```

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

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

model (`torch.nn.Module`) : модель для выгрузки.

execution_device(`str`, `int` or `torch.device`, *optional*) : Устройство, на котором должна выполняться модель. По умолчанию используется устройство MPS, если оно доступно, затем устройство 0, если есть ускоритель, и в последнюю очередь — CPU.

prev_module_hook (`UserCpuOffloadHook`, *необязательный*) : хук, возвращённый этой функцией для предыдущей модели в выполняемом вами конвейере. Если передан, его метод offload будет вызван непосредственно перед forward модели, к которой привязан этот хук.

Переносит модель на CPU и возвращает её на устройство выполнения при запуске. Отличие от [cpu_offload()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.cpu_offload) состоит в том, что после forward модель остаётся на устройстве выполнения и переносится обратно только при вызове метода `offload` возвращённого `hook`. Полезно для конвейеров, которые запускают модель в цикле.

Пример:

```py
model_1, hook_1 = cpu_offload_with_hook(model_1, device)
model_2, hook_2 = cpu_offload_with_hook(model_2, device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()
```

### disk_offload[[accelerate.disk_offload]]

#### accelerate.disk_offload[[accelerate.disk_offload]]

```python
accelerate.disk_offload(model: Module, offload_dir: str | os.PathLike, execution_device: torch.device | None = None, offload_buffers: bool = False, preload_module_classes: list[str] | None = None)
```

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

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

model (`torch.nn.Module`) : модель для выгрузки.

offload_dir (`str` или `os.PathLike`) : Папка, в которую выгружаются веса модели (или где они уже выгружены).

execution_device (`torch.device`, *необязательный*) : Устройство, на котором будет выполняться прямой проход модели (должно быть GPU). По умолчанию используется устройство первого параметра модели.

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

Включает полный offload модели на диск. В результате все параметры модели будут offload-ированы в виде memory-mapped массива в указанную папку. Во время forward pass параметры будут извлекаться из этой папки и помещаться на устройство выполнения, переданное в качестве аргумента, по мере необходимости, а затем снова offload-ироваться.

### dispatch_model[[accelerate.dispatch_model]]

#### accelerate.dispatch_model[[accelerate.dispatch_model]]

```python
accelerate.dispatch_model(model: Module, device_map: dict[str, str | int | torch.device], main_device: torch.device | None = None, state_dict: dict[str, torch.Tensor] | None = None, offload_dir: str | os.PathLike | None = None, offload_index: dict[str, str] | None = None, offload_buffers: bool = False, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, force_hooks: bool = False)
```

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

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

model (`torch.nn.Module`) : модель для диспетчеризации.

device_map (`Dict[str, Union[str, int, torch.device]]`) : Словарь, сопоставляющий имена модулей в `state_dict` моделей с устройствами, на которые они должны быть размещены. Обратите внимание, что значение `"disk"` принимается, даже если оно не является корректным для `torch.device`.

main_device (`str`, `int` или `torch.device`, *необязательный*) : Основное устройство выполнения. По умолчанию используется первое устройство из `device_map`, отличное от `"cpu"` или `"disk"`.

state_dict (`Dict[str, torch.Tensor]`, *необязательный*) : Словарь состояний (state dict) той части модели, которая будет храниться на CPU.

offload_dir (`str` или `os.PathLike`) : Папка, в которую выгружаются веса модели (или где они уже выгружены).

offload_index (`Dict`, *необязательный*) : Словарь, сопоставляющий имена весов с их информацией (`dtype`/ `shape` или имя файла safetensors). По умолчанию используется индекс, сохранённый в `save_folder`.

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

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

Размещает модель в соответствии с заданной картой устройств. Слои модели могут распределяться по GPU, выгружаться на CPU или даже на диск.

### load_checkpoint_and_dispatch[[accelerate.load_checkpoint_and_dispatch]]

#### accelerate.load_checkpoint_and_dispatch[[accelerate.load_checkpoint_and_dispatch]]

```python
accelerate.load_checkpoint_and_dispatch(model: Module, checkpoint: str | os.PathLike, device_map: str | dict[str, int | str | torch.device] | None = None, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, offload_folder: str | os.PathLike | None = None, offload_buffers: bool = False, dtype: str | torch.dtype | None = None, offload_state_dict: bool | None = None, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, force_hooks: 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/big_modeling.py#L500)

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

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

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

device_map (`Dict[str, Union[int, str, torch.device]]`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не обязательно указывать имена каждого параметра/буфера: как только имя модуля указано, все его подмодули будут отправлены на то же устройство. Чтобы Accelerate автоматически вычислила наиболее оптимизированную `device_map`, установите `device_map="auto"`. Подробнее о каждом варианте см. [здесь](../concept_guides/big_model_inference#designing-a-device-map). По умолчанию None, что означает, что [dispatch_model()](/docs/accelerate/v1.16.0/ru/package_reference/big_modeling#accelerate.dispatch_model) не будет вызвана.

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

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

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

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

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

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

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

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 по одному на другие ранги. Остальные ранги получают тензоры и, при необходимости, разбивают их на фрагменты в соответствии с локальными фрагментами в модели.

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

Пример:

```python
>>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoConfig, AutoModelForCausalLM

>>> # Download the Weights
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")

>>> # Create a model and initialize it with empty weights
>>> config = AutoConfig.from_pretrained(checkpoint)
>>> with init_empty_weights():
...     model = AutoModelForCausalLM.from_config(config)

>>> # Load the checkpoint and dispatch it to the right devices
>>> model = load_checkpoint_and_dispatch(
...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]
... )
```

### load_checkpoint_in_model[[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).

### infer_auto_device_map[[accelerate.infer_auto_device_map]]

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

## Хуки

### ModelHook[[accelerate.hooks.ModelHook]]

#### accelerate.hooks.ModelHook[[accelerate.hooks.ModelHook]]

```python
accelerate.hooks.ModelHook()
```

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

Хук, содержащий обратные вызовы, которые выполняются непосредственно перед и после метода forward модели. Отличие от существующих хуков PyTorch состоит в том, что они получают в качестве аргумента kwargs.

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

#### detach_hook[[accelerate.hooks.ModelHook.detach_hook]]

```python
detach_hook(module)
```

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

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

module (`torch.nn.Module`) : модуль, отключённый от этого хука.

Выполняется при отключении хука от модуля.

#### init_hook[[accelerate.hooks.ModelHook.init_hook]]

```python
init_hook(module)
```

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

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

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

Выполняется при подключении хука к модулю.

#### post_forward[[accelerate.hooks.ModelHook.post_forward]]

```python
post_forward(module, output)
```

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

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

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

output (`Any`) : Выход модуля.

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

Обработанный `output`.

Выполняется сразу после метода forward модели.

#### pre_forward[[accelerate.hooks.ModelHook.pre_forward]]

```python
pre_forward(module, *args, **kwargs)
```

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

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

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

args (`Tuple[Any]`) : Позиционные аргументы, переданные в модуль.

kwargs (`Dict[Str, Any]`) : Ключевые аргументы, передаваемые модулю.

**Возвращает:** `Tuple[Tuple[Any], Dict[Str, Any]]`

Кортеж с обработанными `args` и `kwargs`.

Выполняется непосредственно перед методом forward модели.

### AlignDevicesHook[[accelerate.hooks.AlignDevicesHook]]

#### accelerate.hooks.AlignDevicesHook[[accelerate.hooks.AlignDevicesHook]]

```python
accelerate.hooks.AlignDevicesHook(execution_device: int | str | torch.device | None = None, offload: bool = False, io_same_device: bool = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, place_submodules: bool = False, skip_keys: str | list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

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

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

execution_device (`torch.device`, *необязательный*) : Устройство, на котором должны быть размещены входные данные и веса модели перед прямым проходом.

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

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

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

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

place_submodules (`bool`, *необязательный*, по умолчанию `False`) : Размещать ли подмодули на `execution_device` во время события `init_hook`.

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

### SequentialHook[[accelerate.hooks.SequentialHook]]

#### accelerate.hooks.SequentialHook[[accelerate.hooks.SequentialHook]]

```python
accelerate.hooks.SequentialHook(*hooks)
```

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

Хук, который может содержать несколько хуков и перебирает их при каждом событии.

### LayerwiseCastingHook[[accelerate.hooks.LayerwiseCastingHook]]

#### accelerate.hooks.LayerwiseCastingHook[[accelerate.hooks.LayerwiseCastingHook]]

```python
accelerate.hooks.LayerwiseCastingHook(storage_dtype: dtype, compute_dtype: dtype, non_blocking: bool)
```

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

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

## Добавление хуков

### add_hook_to_module[[accelerate.hooks.add_hook_to_module]]

#### accelerate.hooks.add_hook_to_module[[accelerate.hooks.add_hook_to_module]]

```python
accelerate.hooks.add_hook_to_module(module: Module, hook: ModelHook, append: bool = False)
```

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

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

module (`torch.nn.Module`) : модуль, к которому нужно подключить хук.

hook (`ModelHook`) : хук для подключения.

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

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

Тот же модуль, с подключённым хуком (модуль изменяется на месте, поэтому результат можно игнорировать).

Добавляет хук к указанному модулю. Это переопределяет метод `forward` модуля, чтобы включить в него хук. Чтобы отменить это поведение и восстановить исходный метод `forward`, используйте `remove_hook_from_module`.

Если модуль уже содержит хук, он будет заменён новым хуком, переданным по умолчанию. Чтобы объединить два хука в цепочку, передайте `append=True`, тогда текущий и новый хуки будут объединены в экземпляр класса `SequentialHook`.

### attach_execution_device_hook[[accelerate.hooks.attach_execution_device_hook]]

#### accelerate.hooks.attach_execution_device_hook[[accelerate.hooks.attach_execution_device_hook]]

```python
accelerate.hooks.attach_execution_device_hook(module: Module, execution_device: int | str | torch.device, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

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

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

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

execution_device (`int`, `str` или `torch.device`) : Устройство, на котором должны быть размещены входные данные и веса модели перед прямой передачей.

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

Рекурсивно подключает `AlignDevicesHook` ко всем подмодулям указанной модели, чтобы убедиться, что у них настроено правильное устройство выполнения

### attach_align_device_hook[[accelerate.hooks.attach_align_device_hook]]

#### accelerate.hooks.attach_align_device_hook[[accelerate.hooks.attach_align_device_hook]]

```python
accelerate.hooks.attach_align_device_hook(module: Module, execution_device: torch.device | None = None, offload: bool = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, module_name: str = '', skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

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

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

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

execution_device (`torch.device`, *необязательный*) : Устройство, на котором должны быть размещены входные данные и веса модели перед прямым проходом.

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

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

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

module_name (`str`, *необязательный*, по умолчанию `""`) : Имя модуля.

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

Рекурсивно подключает `AlignDevicesHook` ко всем подмодулям заданной модели, которые имеют прямые параметры и/или буферы.

### attach_align_device_hook_on_blocks[[accelerate.hooks.attach_align_device_hook_on_blocks]]

#### accelerate.hooks.attach_align_device_hook_on_blocks[[accelerate.hooks.attach_align_device_hook_on_blocks]]

```python
accelerate.hooks.attach_align_device_hook_on_blocks(module: Module, execution_device: torch.device | dict[str, torch.device] | None = None, offload: bool | dict[str, bool] = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, module_name: str = '', skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

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

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

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

execution_device (`torch.device` или `Dict[str, torch.device]`, *необязательный*) : Устройство, на котором должны размещаться входные данные и веса модели перед прямым проходом. Может быть одним устройством для всего модуля или словарем, сопоставляющим имя модуля с устройством.

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

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

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

module_name (`str`, *необязательный*, по умолчанию `""`) : Имя модуля.

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

preload_module_classes (`List[str]`, *необязательный*) : Список классов, экземпляры которых должны загружать все свои веса (в том числе в подмодулях) в начале прямого прохода. Это следует использовать только для классов, у которых есть зарегистрированные, но не вызываемые напрямую во время прямого прохода подмодули, например, если зарегистрирован линейный слой `dense`, но во время прямого прохода `dense.weight` и `dense.bias` используются в некоторых операциях вместо прямого вызова `dense`.

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

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

### attach_layerwise_casting_hooks[[accelerate.big_modeling.attach_layerwise_casting_hooks]]

#### accelerate.big_modeling.attach_layerwise_casting_hooks[[accelerate.big_modeling.attach_layerwise_casting_hooks]]

```python
accelerate.big_modeling.attach_layerwise_casting_hooks(module: Module, storage_dtype: dtype, compute_dtype: dtype, skip_modules_pattern: str | tuple[str, ...] | None = None, skip_modules_classes: tuple[type[torch.nn.Module], ...] | None = None, non_blocking: bool = False)
```

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

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

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

storage_dtype (`torch.dtype`) : тип данных, к которому модуль приводится до/после прямого прохода для хранения.

compute_dtype (`torch.dtype`) : тип данных, к которому модуль приводится во время прямого прохода для вычислений.

skip_modules_pattern (`tuple[str, ...]`, по умолчанию `None`) : Список шаблонов для сопоставления с именами модулей, которые нужно пропустить в процессе послойного приведения типов. Если установлено значение `None` при `skip_modules_classes`, равном `None`, послойное приведение типов применяется непосредственно к модулю, а не к его внутренним подмодулям.

skip_modules_classes (`tuple[type[torch.nn.Module], ...]`, по умолчанию `None`) : Список классов модулей, которые нужно пропустить при послойном приведении типов.

non_blocking (`bool`, по умолчанию `False`) : Если `True`, операции приведения весов выполняются без блокировки.

Применяет послойное приведение типов к заданному модулю. Ожидаемый модуль — это PyTorch `nn.Module`. Это полезно для снижения требований к памяти, если не требуется полное квантование модели. Параметры модели можно хранить, например, в формате `torch.float8_e4m3fn` и приводить к более высокой точности, такой как `torch.bfloat16`, во время прямого прохода, а затем возвращать обратно в `torch.float8_e4m3fn`, чтобы обеспечить экономию памяти.

Пример:

```python
>>> from accelerate.hooks import attach_layerwise_casting_hooks
>>> from transformers import AutoModelForCausalLM
>>> import torch

>>> # Model
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)

>>> # Attach hooks and perform inference
>>> attach_layerwise_casting_hooks(model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
>>> with torch.no_grad():
...     model(...)
```

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

```py
>>> attach_layerwise_casting_hooks(
...     model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16, skip_modules_pattern=["norm"]
... )
```

## Удаление хуков

### remove_hook_from_module[[accelerate.hooks.remove_hook_from_module]]

#### accelerate.hooks.remove_hook_from_module[[accelerate.hooks.remove_hook_from_module]]

```python
accelerate.hooks.remove_hook_from_module(module: Module, recurse = False)
```

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

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

module (`torch.nn.Module`) : модуль, к которому нужно подключить хук.

recurse (`bool`, **необязательный**) : Указывает, следует ли удалять хуки рекурсивно

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

Тот же модуль, с отключённым хуком (модуль изменяется на месте, поэтому результат можно игнорировать).

Удаляет любой хук, привязанный к модулю с помощью `add_hook_to_module`.

### remove_hook_from_submodules[[accelerate.hooks.remove_hook_from_submodules]]

#### accelerate.hooks.remove_hook_from_submodules[[accelerate.hooks.remove_hook_from_submodules]]

```python
accelerate.hooks.remove_hook_from_submodules(module: Module)
```

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

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

module (`torch.nn.Module`) : модуль, с которого необходимо удалить все хуки.

Рекурсивно удаляет все хуки, привязанные к подмодулям указанной модели.

## Утилиты

### has_offloaded_params[[accelerate.utils.has_offloaded_params]]

#### accelerate.utils.has_offloaded_params[[accelerate.utils.has_offloaded_params]]

```python
accelerate.utils.has_offloaded_params(module: Module)
```

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

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

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

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

`True`, если у модуля есть хук offload и offloading включён, `False` в противном случае.

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

### align_module_device[[accelerate.utils.align_module_device]]

#### accelerate.utils.align_module_device[[accelerate.utils.align_module_device]]

```python
accelerate.utils.align_module_device(module: Module, execution_device: torch.device | None = None)
```

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

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

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

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

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

