# DataLoaders, оптимизаторы и планировщики

Внутренние классы, которые Accelerate использует для подготовки объектов к распределённому обучению при вызове [prepare()](/docs/accelerate/v1.16.0/ru/package_reference/accelerator#accelerate.Accelerator.prepare).

## Утилиты DataLoader[[accelerate.data_loader.prepare_data_loader]]

#### accelerate.data_loader.prepare_data_loader[[accelerate.data_loader.prepare_data_loader]]

```python
accelerate.data_loader.prepare_data_loader(dataloader: DataLoader, device: torch.device | None = None, num_processes: int | None = None, process_index: int | None = None, split_batches: bool = False, put_on_device: bool = False, rng_types: list[str | accelerate.utils.dataclasses.RNGType] | None = None, dispatch_batches: bool | None = None, even_batches: bool = True, slice_fn_for_dispatch: typing.Callable | None = None, use_seedable_sampler: bool = False, data_seed: int | None = None, non_blocking: bool = False, use_stateful_dataloader: bool = False, torch_device_mesh = None)
```

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

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

dataloader (`torch.utils.data.dataloader.DataLoader`) : загрузчик данных, который нужно распределить по нескольким устройствам.

device (`torch.device`) : целевое устройство для возвращаемого `DataLoader`.

num_processes (`int`, *необязательный*) : Количество процессов, выполняемых одновременно. По умолчанию используется значение, заданное в [PartialState](/docs/accelerate/v1.16.0/ru/package_reference/state#accelerate.PartialState).

process_index (`int`, *необязательный*) : Индекс текущего процесса. По умолчанию используется значение, заданное [PartialState](/docs/accelerate/v1.16.0/ru/package_reference/state#accelerate.PartialState).

split_batches (`bool`, *необязательный*, по умолчанию `False`) : следует ли результирующему `DataLoader` распределять батчи исходного загрузчика данных по устройствам или выдавать полные батчи (в этом случае он будет выдавать батчи, начиная с `process_index`-го, и продвигаясь на `num_processes` батчей на каждой итерации).  Другой способ взглянуть на это: наблюдаемый размер батча будет таким же, как у исходного `dataloader`, если этот параметр установлен в `True`, а в противном случае размер батча исходного `dataloader` будет умножен на `num_processes`.  Установка этого параметра в `True` требует, чтобы размер батча `dataloader` был кратен `batch_size`.

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

rng_types (список `str` или [RNGType](/docs/accelerate/v1.16.0/ru/package_reference/utilities#accelerate.utils.RNGType)) : Список генераторов случайных чисел, которые необходимо синхронизировать в начале каждой итерации. Должен содержать один или несколько из следующих вариантов:  - `"torch"`: базовый генератор случайных чисел torch - `"cuda"`: генератор случайных чисел CUDA (только для GPU) - Любой зарегистрированный тип устройства ускорителя PyTorch: его генератор случайных чисел для устройства. - `"xla"`: генератор случайных чисел XLA (только для TPU) - `"generator"`: `torch.Generator` сэмплера (или батч-сэмплера, если в вашем загрузчике данных нет сэмплера) или итерируемого набора данных (если он существует), если базовый набор данных имеет соответствующий тип.

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

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

slice_fn_for_dispatch (`Callable`, *optional*`) : If passed, this function will be used to slice tensors across `num_processes`. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/ru/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when `dispatch_batches` is set to `True` and will be ignored otherwise.

use_seedable_sampler (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли `SeedableRandomSampler` вместо `RandomSampler` для лучшей воспроизводимости. Это может привести к различиям в производительности из-за разных алгоритмов перемешивания, но гарантирует, что результаты будут *полностью* одинаковыми. Следует использовать в паре с `set_seed()` при каждом вызове `self.set_epoch`

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

non_blocking (`bool`, *необязательный*, по умолчанию `False`) : Если установлено в `True`, загрузчик данных будет использовать неблокирующие передачи данных с хоста на устройство. Если для загрузчика данных параметр `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."

torch_device_mesh (`torch.distributed.DeviceMesh`, *необязательный*, по умолчанию `None`) : сетка устройств PyTorch.

**Возвращает:** `torch.utils.data.dataloader.DataLoader`

Новый загрузчик данных, который будет возвращать часть батчей

Оборачивает `DataLoader` PyTorch для генерации батчей только для одного из процессов.

В зависимости от значения атрибута `drop_last` переданного `dataloader`, итерация либо остановится на первой слишком малой / отсутствующей на всех процессах партии, либо начнёт заново с начала индексов.

`BatchSampler` с изменяемым размером батча по умолчанию не поддерживаются. Чтобы включить такое поведение, установите `even_batches` равным `False`

#### accelerate.skip_first_batches[[accelerate.skip_first_batches]]

```python
accelerate.skip_first_batches(dataloader, num_batches = 0)
```

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

Создаёт `torch.utils.data.DataLoader`, который эффективно пропускает первые `num_batches`. Не следует использовать, если исходный dataloader является `StatefulDataLoader`.

## BatchSamplerShard[[accelerate.data_loader.BatchSamplerShard]]

#### accelerate.data_loader.BatchSamplerShard[[accelerate.data_loader.BatchSamplerShard]]

```python
accelerate.data_loader.BatchSamplerShard(batch_sampler: BatchSampler, num_processes: int = 1, process_index: int = 0, split_batches: bool = False, even_batches: bool = True)
```

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

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

batch_sampler (`torch.utils.data.sampler.BatchSampler`) : батч-сэмплер для разбиения на несколько шардов.

num_processes (`int`, *необязательный*, по умолчанию 1) : Количество процессов, выполняемых одновременно.

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

split_batches (`bool`, *необязательный*, по умолчанию `False`) : Определяет, следует ли создавать фрагменты, разбивая батч и передавая его часть на каждый процесс, или выдавать на каждом процессе разные полные батчи.  При двух процессах и сэмплере `[[0, 1, 2, 3], [4, 5, 6, 7]]` это приведет к следующему:  - сэмплер на процессе 0 будет выдавать `[0, 1, 2, 3]`, а сэмплер на процессе 1 — `[4, 5, 6, 7]`, если этот аргумент установлен в `False`. - сэмплер на процессе 0 будет выдавать `[0, 1]`, затем `[4, 5]`, а сэмплер на процессе 1 — `[2, 3]`, затем `[6, 7]`, если этот аргумент установлен в `True`.

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

Обёртка для `BatchSampler` из PyTorch, генерирующая батчи только для одного из процессов. Экземпляры этого класса всегда возвращают количество батчей, кратное `num_processes`, причём все батчи имеют одинаковый размер. В зависимости от значения атрибута `drop_last` переданного батч-сэмплера, итерация либо останавливается на первом батче, который оказался бы слишком маленьким или отсутствовал бы на всех процессах, либо продолжается с повторным использованием индексов с начала.

`BatchSampler` с изменяемым размером батча по умолчанию не поддерживаются. Чтобы включить такое поведение, установите `even_batches` равным `False`

## IterableDatasetShard[[accelerate.data_loader.IterableDatasetShard]]

#### accelerate.data_loader.IterableDatasetShard[[accelerate.data_loader.IterableDatasetShard]]

```python
accelerate.data_loader.IterableDatasetShard(dataset: IterableDataset, batch_size: int = 1, drop_last: bool = False, num_processes: int = 1, process_index: int = 0, split_batches: bool = False)
```

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

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

dataset (`torch.utils.data.dataset.IterableDataset`) : батч-сэмплер для разбиения на несколько шардов.

batch_size (`int`, *необязательный*, по умолчанию 1) : Размер батчей на шард (если `split_batches=False`) или размер батчей (если `split_batches=True`).

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

num_processes (`int`, *необязательный*, по умолчанию 1) : Количество процессов, выполняемых одновременно.

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

split_batches (`bool`, *необязательный*, по умолчанию `False`) : Определяет, следует ли создавать шарды путем разбиения батча на части, по одной на каждый процесс, или путем выдачи разных полных батчей на каждом процессе.  При наличии двух процессов и итерируемого датасета, выдающего `[0, 1, 2, 3, 4, 5, 6, 7]`, результат будет следующим:  - если этот аргумент установлен в `False`, шард на процессе 0 будет выдавать `[0, 1, 2, 3]`, а шард на процессе 1 — `[4, 5, 6, 7]`. - если этот аргумент установлен в `True`, шард на процессе 0 будет выдавать `[0, 1, 4, 5]`, а сэмплер на процессе 1 — `[2, 3, 6, 7]`.

Обёртка для PyTorch `IterableDataset`, генерирующая примеры только для одного из процессов. Экземпляры этого класса всегда возвращают количество примеров, кратное фактическому размеру батча (в зависимости от значения `split_batches` это либо `batch_size`, либо `batch_size x num_processes`). В зависимости от значения атрибута `drop_last` переданного батч-сэмплера, итерация либо останавливается на первом батче, который оказался слишком маленьким, либо продолжается с повторным использованием индексов с начала.

## DataLoaderShard[[accelerate.data_loader.DataLoaderShard]]

#### accelerate.data_loader.DataLoaderShard[[accelerate.data_loader.DataLoaderShard]]

```python
accelerate.data_loader.DataLoaderShard(dataset, device = None, rng_types = None, synchronized_generator = None, skip_batches = 0, use_stateful_dataloader = False, _drop_last: bool = False, _non_blocking: bool = False, torch_device_mesh = None, iteration = 0, **kwargs)
```

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

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

dataset (`torch.utils.data.dataset.Dataset`) : набор данных, используемый для создания этого загрузчика данных.

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

rng_types (список `str` или [RNGType](/docs/accelerate/v1.16.0/ru/package_reference/utilities#accelerate.utils.RNGType)) : Список генераторов случайных чисел, которые необходимо синхронизировать в начале каждой итерации. Должен содержать один или несколько из:  - `"torch"`: базовый генератор случайных чисел torch - `"cuda"`: генератор случайных чисел CUDA (только для GPU) - Любой зарегистрированный тип устройства ускорителя PyTorch: его генератор случайных чисел для устройства. - `"xla"`: генератор случайных чисел XLA (только для TPU) - `"generator"`: необязательный `torch.Generator`

synchronized_generator (`torch.Generator`, *необязательный*) : генератор случайных чисел для синхронизации между процессами.

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

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

- ****kwargs** (дополнительные именованные аргументы, *необязательные*) : Все остальные именованные аргументы для передачи в стандартную инициализацию `DataLoader`.

Подкласс `DataLoaderAdapter`, который управляет размещением на устройствах и текущей конфигурацией распределённых вычислений.

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

- **total_batch_size** (`int`) -- Общий размер батча для dataloader во всех процессах. Равен исходному размеру батча, если `split_batches=True`; в противном случае — исходный размер батча, умноженный на общее количество процессов

- **total_dataset_length** (`int`) -- Общая длина внутреннего набора данных во всех процессах.

## DataLoaderDispatcher[[accelerate.data_loader.DataLoaderDispatcher]]

#### accelerate.data_loader.DataLoaderDispatcher[[accelerate.data_loader.DataLoaderDispatcher]]

```python
accelerate.data_loader.DataLoaderDispatcher(dataset, split_batches: bool = False, skip_batches = 0, use_stateful_dataloader = False, _drop_last: bool = False, _non_blocking: bool = False, slice_fn = None, torch_device_mesh = None, iteration = 0, **kwargs)
```

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

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

split_batches (`bool`, *необязательный*, по умолчанию `False`) : следует ли результирующему `DataLoader` распределять батчи исходного загрузчика данных по устройствам или выдавать полные батчи (в этом случае он будет выдавать батчи, начиная с `process_index`-го, и продвигаясь на `num_processes` батчей на каждой итерации). Другой способ взглянуть на это: наблюдаемый размер батча будет таким же, как у исходного `dataloader`, если этот параметр установлен в `True`, а в противном случае размер батча исходного `dataloader` будет умножен на `num_processes`. Установка этого параметра в `True` требует, чтобы размер батча `dataloader` был кратен `batch_size`.

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

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

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

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

- **total_batch_size** (`int`) -- Общий размер батча для dataloader во всех процессах. Равен исходному размеру батча, если `split_batches=True`; в противном случае — исходный размер батча, умноженный на общее количество процессов

- **total_dataset_length** (`int`) -- Общая длина внутреннего набора данных во всех процессах.

## AcceleratedOptimizer[[accelerate.optimizer.AcceleratedOptimizer]]

#### accelerate.optimizer.AcceleratedOptimizer[[accelerate.optimizer.AcceleratedOptimizer]]

```python
accelerate.optimizer.AcceleratedOptimizer(optimizer, device_placement = True, scaler = None)
```

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

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

optimizer (`torch.optim.optimizer.Optimizer`) : Оптимизатор, который нужно обернуть.

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

scaler (`torch.amp.GradScaler` или `torch.cuda.amp.GradScaler`, *необязательный*) : Масштабатор, используемый в функции step при обучении с смешанной точностью.

Внутренняя обёртка вокруг оптимизатора torch.

Условное выполнение `step` и `zero_grad`, если при накоплении градиентов требуется их синхронизация.

#### eval[[accelerate.optimizer.AcceleratedOptimizer.eval]]

```python
eval()
```

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

Устанавливает оптимизатор в режим "eval". Полезно для оптимизаторов, таких как `schedule_free`

#### train[[accelerate.optimizer.AcceleratedOptimizer.train]]

```python
train()
```

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

Устанавливает оптимизатор в режим «train». Полезно для оптимизаторов, таких как `schedule_free`

## AcceleratedScheduler[[accelerate.scheduler.AcceleratedScheduler]]

#### accelerate.scheduler.AcceleratedScheduler[[accelerate.scheduler.AcceleratedScheduler]]

```python
accelerate.scheduler.AcceleratedScheduler(scheduler, optimizers, step_with_optimizer: bool = True, split_batches: bool = False)
```

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

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

scheduler (`torch.optim.lr_scheduler._LRScheduler`) : планировщик, который нужно обернуть.

optimizers (один или список `torch.optim.Optimizer`) : Используемые оптимизаторы.

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

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

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

При использовании градиентной аккумуляции длины планировщика не следует изменять соответственно: Accelerate всегда выполняет шаг планировщика, чтобы учесть это.

