# Классы с состоянием

Ниже приведены варианты реализации [singleton class](https://en.wikipedia.org/wiki/Singleton_pattern) в том смысле, что все экземпляры разделяют одно и то же состояние, которое инициализируется при первом создании экземпляра.

Эти классы неизменяемы и хранят информацию о конкретных конфигурациях или состояниях.

## PartialState[[accelerate.PartialState]]

#### accelerate.PartialState[[accelerate.PartialState]]

```python
accelerate.PartialState(cpu: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L121)

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

cpu (`bool`, *необязательный*) : Указывает, следует ли принудительно выполнять скрипт на CPU. Если установлено значение `True`, все доступные ускорители будут проигнорированы, а выполнение будет принудительно перенаправлено на CPU.

kwargs (дополнительные аргументы ключ-значение, *необязательные*) : Дополнительные аргументы ключ-значение для передачи в соответствующую функцию `init_process_group`. Допустимые `kwargs` описаны в [utils.InitProcessGroupKwargs](/docs/accelerate/main/ru/package_reference/kwargs#accelerate.InitProcessGroupKwargs). Подробные примеры использования приведены в разделе с примерами.

Одноэлементный класс, содержащий информацию о текущей среде обучения и функции для управления процессами. Предназначен для случаев, когда требуется только управление процессами и состояния выполнения на устройствах. Не *требует* инициализации из `Accelerator`.

**Доступные атрибуты:**

- **device** (`torch.device`) -- Устройство, которое будет использоваться.
- **distributed_type** ([DistributedType](/docs/accelerate/main/ru/package_reference/utilities#accelerate.DistributedType)) — тип используемой распределённой среды.
- **local_process_index** (`int`) — индекс текущего процесса на текущем сервере.
- **mixed_precision** (`str`) -- Использует ли текущий скрипт смешанную точность и, если да, какой тип смешанной точности применяется. (Выберите из 'no','fp16','bf16 or 'fp8').
- **num_processes** (`int`) -- Количество процессов, запущенных параллельно в данный момент.
- **process_index** (`int`) — индекс текущего процесса.
- **is_last_process** (`bool`) -- Является ли текущий процесс последним.
- **is_main_process** (`bool`) -- Является ли текущий процесс основным.
- **is_local_main_process** (`bool`) -- Является ли текущий процесс основным на локальном узле.
- **debug** (`bool`) — Указывает, выполняется ли текущий скрипт в режиме отладки.

Пример:
```python
from accelerate.utils import InitProcessGroupKwargs

# To include `InitProcessGroupKwargs`, init then call `.to_kwargs()`
kwargs = InitProcessGroupKwargs(...).to_kwargs()
state = PartialState(**kwargs)
```

#### destroy_process_group[[accelerate.PartialState.destroy_process_group]]

```python
destroy_process_group(group = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L806)

Уничтожает группу процессов. Если группа не указана, уничтожается группа процессов по умолчанию.

#### local_main_process_first[[accelerate.PartialState.local_main_process_first]]

```python
local_main_process_first()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L536)

Позволяет локальному основному процессу войти в блок with.

Остальные процессы войдут в блок with после завершения основного процесса.

Пример:

```python
>>> from accelerate.state import PartialState

>>> state = PartialState()
>>> with state.local_main_process_first():
...     # This will be printed first by local process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {state.local_process_index}")
```

#### main_process_first[[accelerate.PartialState.main_process_first]]

```python
main_process_first()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L515)

Позволяет основному процессу выполняться первым внутри блока with.

Остальные процессы войдут в блок with после завершения основного процесса.

Пример:

```python
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.main_process_first():
...     # This will be printed first by process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.process_index}")
```

#### on_last_process[[accelerate.PartialState.on_last_process]]

```python
on_last_process(function: Callable[..., Any])
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L618)

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

function (`Callable`) : функция для декорирования.

Декоратор, который выполняет декорируемую функцию только на последнем процессе.

Пример:
```python
# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()

@state.on_last_process
def print_something():
    print(f"Printed on process {state.process_index}")

print_something()
"Printed on process 3"
```

#### on_local_main_process[[accelerate.PartialState.on_local_main_process]]

```python
on_local_main_process(function: Callable[..., Any] | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L587)

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

function (`Callable`) : функция для декорирования.

Декоратор, который выполняет декорируемую функцию только на локальном главном процессе.

Пример:
```python
# Assume we have 2 servers with 4 processes each.
from accelerate.state import PartialState

state = PartialState()

@state.on_local_main_process
def print_something():
    print("This will be printed by process 0 only on each server.")

print_something()
# On server 1:
"This will be printed by process 0 only"
# On server 2:
"This will be printed by process 0 only"
```

#### on_local_process[[accelerate.PartialState.on_local_process]]

```python
on_local_process(function: Callable[..., Any] | None = None, local_process_index: int | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L679)

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

function (`Callable`, *необязательный*) : Функция для декорирования.

local_process_index (`int`, *optional*) : Индекс локального процесса, на котором следует выполнить функцию.

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

Пример:
```python
# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()

@accelerator.on_local_process(local_process_index=2)
def print_something():
    print(f"Printed on process {accelerator.local_process_index}")

print_something()
# On server 1:
"Printed on process 2"
# On server 2:
"Printed on process 2"
```

#### on_main_process[[accelerate.PartialState.on_main_process]]

```python
on_main_process(function: Callable[..., Any] | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L557)

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

function (`Callable`) : функция для декорирования.

Декоратор, который выполняет декорируемую функцию только в основном процессе.

Пример:

```python
>>> from accelerate.state import PartialState

>>> state = PartialState()

>>> @state.on_main_process
... def print_something():
...     print("This will be printed by process 0 only.")

>>> print_something()
"This will be printed by process 0 only"
```

#### on_process[[accelerate.PartialState.on_process]]

```python
on_process(function: Callable[..., Any] | None = None, process_index: int | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L646)

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

function (`Callable`, `optional`) : Функция для декорирования.

process_index (`int`, `optional`) : Индекс процесса, на котором следует выполнить функцию.

Декоратор, который выполняет декорируемую функцию только на процессе с указанным индексом.

Пример:
```python
# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()

@state.on_process(process_index=2)
def print_something():
    print(f"Printed on process {state.process_index}")

print_something()
"Printed on process 2"
```

#### set_device[[accelerate.PartialState.set_device]]

```python
set_device()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L778)

Устанавливает устройство в `self.device` в соответствии с текущей распределённой средой.

#### split_between_processes[[accelerate.PartialState.split_between_processes]]

```python
split_between_processes(inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L423)

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

inputs (`list`, `tuple`, `torch.Tensor`, `dict` из `list`/`tuple`/`torch.Tensor` или `datasets.Dataset`) : Вводные данные для распределения между процессами.

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

Разбивает `input` между `self.num_processes` быстро, после чего может использоваться на соответствующем процессе. Полезно при распределённом выводе, например, с разными промптами.

Обратите внимание, что при использовании `dict` все ключи должны содержать одинаковое количество элементов.

Пример:

```python
# Assume there are two processes
from accelerate import PartialState

state = PartialState()
with state.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]
```

#### wait_for_everyone[[accelerate.PartialState.wait_for_everyone]]

```python
wait_for_everyone()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L371)

Останавливает выполнение текущего процесса, пока все остальные процессы не достигнут этой точки (поэтому при запуске скрипта в одном процессе этот метод ничего не делает). Полезно вызывать перед сохранением модели.

Пример:

```python
>>> # Assuming two GPU processes
>>> import time
>>> from accelerate.state import PartialState

>>> state = PartialState()
>>> if state.is_main_process:
...     time.sleep(2)
>>> else:
...     print("I'm waiting for the main process to finish its sleep...")
>>> state.wait_for_everyone()
>>> # Should print on every process at the same time
>>> print("Everyone is here")
```

## AcceleratorState[[accelerate.state.AcceleratorState]]

#### accelerate.state.AcceleratorState[[accelerate.state.AcceleratorState]]

```python
accelerate.state.AcceleratorState(mixed_precision: str | None = None, cpu: bool = False, dynamo_plugin = None, deepspeed_plugin = None, fsdp_plugin = None, torch_tp_plugin = None, megatron_lm_plugin = None, parallelism_config = None, _from_accelerator: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L829)

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

**Доступные атрибуты:**

- **device** (`torch.device`) -- Устройство, которое будет использоваться.
- **distributed_type** ([DistributedType](/docs/accelerate/main/ru/package_reference/utilities#accelerate.DistributedType)) — тип используемой распределённой среды.
- **parallelism_config** (`ParallelismConfig`) -- Конфигурация параллелизма для текущей среды обучения. Используется для настройки распределённой среды обучения.
- **initialized** (`bool`) -- Указывает, была ли инициализирована `AcceleratorState` из `Accelerator`.
- **local_process_index** (`int`) — индекс текущего процесса на текущем сервере.
- **mixed_precision** (`str`) -- Использует ли текущий скрипт смешанную точность и, если да, какой тип смешанной точности применяется. (Выберите из 'no','fp16','bf16 or 'fp8').
- **num_processes** (`int`) -- Количество процессов, запущенных параллельно в данный момент.
- **process_index** (`int`) — индекс текущего процесса.
- **is_last_process** (`bool`) -- Является ли текущий процесс последним.
- **is_main_process** (`bool`) -- Является ли текущий процесс основным.
- **is_local_main_process** (`bool`) -- Является ли текущий процесс основным на локальном узле.
- **debug** (`bool`) — Указывает, выполняется ли текущий скрипт в режиме отладки.

#### destroy_process_group[[accelerate.state.AcceleratorState.destroy_process_group]]

```python
destroy_process_group(group = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1043)

Уничтожает группу процессов. Если группа не указана, уничтожается группа процессов по умолчанию.

Если `self.fork_launched` равно `True`, а `group` равно `None`, ничего не происходит.

#### get_deepspeed_plugin[[accelerate.state.AcceleratorState.get_deepspeed_plugin]]

```python
get_deepspeed_plugin(name: str)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1160)

Возвращает DeepSpeedPlugin с указанным plugin_key.

#### local_main_process_first[[accelerate.state.AcceleratorState.local_main_process_first]]

```python
local_main_process_first()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1136)

Позволяет локальному основному процессу войти в блок with.

Остальные процессы войдут в блок with после завершения основного процесса.

#### main_process_first[[accelerate.state.AcceleratorState.main_process_first]]

```python
main_process_first()
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1126)

Позволяет основному процессу выполняться первым внутри блока with.

Остальные процессы войдут в блок with после завершения основного процесса.

#### select_deepspeed_plugin[[accelerate.state.AcceleratorState.select_deepspeed_plugin]]

```python
select_deepspeed_plugin(name: str | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1167)

Activates the DeepSpeedPlugin with the given `name`, and will disable all other plugins.

#### split_between_processes[[accelerate.state.AcceleratorState.split_between_processes]]

```python
split_between_processes(inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1084)

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

inputs (`list`, `tuple`, `torch.Tensor` или `dict` из `list`/`tuple`/`torch.Tensor`) : Вводные данные для распределения между процессами.

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

Разбивает `input` между `self.num_processes` быстро, после чего может использоваться на соответствующем процессе. Полезно при распределённом выводе, например, с разными промптами.

Обратите внимание, что при использовании `dict` все ключи должны содержать одинаковое количество элементов.

Пример:

```python
# Assume there are two processes
from accelerate.state import AcceleratorState

state = AcceleratorState()
with state.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]
```

## GradientState[[accelerate.state.GradientState]]

#### accelerate.state.GradientState[[accelerate.state.GradientState]]

```python
accelerate.state.GradientState(gradient_accumulation_plugin: GradientAccumulationPlugin | None = None)
```

[Источник](https://github.com/huggingface/accelerate/blob/main/src/accelerate/state.py#L1193)

Одноэлементный класс, содержащий информацию, связанную с синхронизацией градиентов для накопления градиентов

**Доступные атрибуты:**

- **end_of_dataloader** (`bool`) -- Достижен ли конец текущего загрузчика данных
- **remainder** (`int`) — количество дополнительных образцов, добавленных при дополнении (padding) загрузчика данных
- **sync_gradients** (`bool`) — нужно ли синхронизировать градиенты между всеми устройствами
- **active_dataloader** (`Optional[DataLoader]`) -- Загрузчик данных, по которому в данный момент выполняется итерация
- **dataloader_references** (`List[Optional[DataLoader]]`) -- Список ссылок на итерируемые загрузчики данных
- **num_steps** (`int`) -- Количество шагов для накопления
- **adjust_scheduler** (`bool`) — Нужно ли корректировать планировщик с учётом накопления градиентов
- **sync_with_dataloader** (`bool`) — следует ли синхронизировать градиенты в конце итерации загрузчика данных и сбрасывать общее количество шагов
- **is_xla_gradients_synced** (`bool`) -- Указывает, были ли синхронизированы градиенты XLA. Инициализируется значением false. После редукции градиентов перед шагом оптимизатора этот флаг устанавливается в true. Впоследствии, после каждого шага, флаг сбрасывается в false. FSDP всегда синхронизирует градиенты, поэтому is_xla_gradients_synced всегда равно true.

