# DataLoader、オプティマイザー、スケジューラー

The internal classes Accelerate uses to prepare objects for distributed training when calling [prepare()](/docs/accelerate/main/ja/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/main/src/accelerate/data_loader.py#L1003)

**パラメータ:**

dataloader (`torch.utils.data.dataloader.DataLoader`) : 複数のデバイスに分割して使用するデータローダー。

device (`torch.device`) : 返される`DataLoader`のターゲットデバイス。

num_processes (`int`, *任意*) : 並行して実行されるプロセスの数。[PartialState](/docs/accelerate/main/ja/package_reference/state#accelerate.PartialState)によって与えられた値がデフォルトとして使用されます。

process_index (`int`, *任意*) : 現在のプロセスのインデックス。[PartialState](/docs/accelerate/main/ja/package_reference/state#accelerate.PartialState)によって与えられる値がデフォルトとして使用されます。

split_batches (`bool`, *任意*, デフォルトは `False`) : 生成される `DataLoader` が、元のデータローダーのバッチをデバイス間で分割して出力するか、それとも完全なバッチを出力するか（この場合、`process_index` 番目のバッチから出力を開始し、各イテレーションで `num_processes` バッチずつ進みます）を指定します。別の見方としては、このオプションが `True` に設定されている場合、観測されるバッチサイズは初期の `dataloader` と同じになり、それ以外の場合は初期の `dataloader` のバッチサイズに `num_processes` を掛けた値になります。このオプションを `True` に設定するには、`dataloader` のバッチサイズが `batch_size` の整数倍である必要があります。

put_on_device (`bool`、*任意*、デフォルトは`False`) : バッチを`device`に配置するかどうか（バッチがテンソルのネストされたリスト、タプル、または辞書のいずれかの場合にのみ機能します）。

rng_types (list of `str` or [RNGType](/docs/accelerate/main/ja/package_reference/utilities#accelerate.utils.RNGType)) : 各イテレーションの開始時に同期する乱数生成器のリストです。以下のいずれか、または複数にしてください: - `"torch"`: 基本的な torch の乱数生成器 - `"cuda"`: CUDA 乱数生成器 (GPU のみ) - 登録済みの PyTorch アクセラレーターのデバイス型: そのデバイスの乱数生成器。 - `"xla"`: XLA 乱数生成器 (TPU のみ) - `"generator"`: 基礎となるデータセットがそのタイプの場合、sampler (dataloader に sampler が存在しない場合は batch sampler) または iterable dataset (存在する場合) の `torch.Generator`。

dispatch_batches (`bool`, *任意*) : `True`に設定すると、準備されたdataloaderはメインプロセスでのみ反復され、その後バッチが分割されて各プロセスにブロードキャストされます。基盤となるデータセットが`IterableDataset`の場合は`True`、それ以外の場合は`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/main/ja/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`) : より再現性が高いように、`RandomSampler` の代わりに`SeedableRandomSampler` を使用するかどうか。シャッフルアルゴリズムが異なるため、パフォーマンスが異なる可能性があるというコストは伴いますが、結果が*完全に*同じであることを保証します。各`self.set_epoch` で`set_seed()` と組み合わせて使用してください。

data_seed (`int`、*optional*、デフォルトは`None`) : `use_seedable_sampler`を使用する場合に、基となるジェネレーターで使用するシードです。`None`の場合、ジェネレーターはtorchの現在のデフォルトのシードを使用します。

non_blocking (`bool`、*任意*、デフォルトは`False`) : `True`に設定すると、dataloaderは非ブロッキングなホストからデバイスへの転送を利用します。dataloaderの`pin_memory`が`True`に設定されている場合、これによりデータ転送と計算のオーバーラップを高めることができます。

use_stateful_dataloader (`bool`、*任意*、デフォルトは`False`) : "true に設定すると、Accelerator によって準備された dataloader は [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader) によってサポートされます。これには、StatefulDataLoader をサポートする `torchdata` バージョン 0.8.0 以降のインストールが必要です。"

torch_device_mesh (`torch.distributed.DeviceMesh`、*任意*、デフォルトは`None`) : PyTorchのデバイスメッシュ。

**戻り値:** `torch.utils.data.dataloader.DataLoader`

バッチの一部を生成する新しいデータローダー

PyTorchの`DataLoader`をラップし、プロセスの1つにのみバッチを生成します。

渡された`dataloader`の`drop_last`属性の値に応じて、小さすぎる/すべてのプロセスに存在しない最初のバッチで反復を停止するか、先頭からインデックスを繰り返すかのいずれかになります。

`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/main/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/main/src/accelerate/data_loader.py#L101)

**パラメータ:**

batch_sampler (`torch.utils.data.sampler.BatchSampler`) : 複数のシャードに分割するためのバッチサンプラー。

num_processes (`int`、*optional*、デフォルトは 1) : 並行して実行されるプロセスの数。

process_index (`int`、*任意*、デフォルトは 0) : 現在のプロセスのインデックス。

split_batches (`bool`, *任意*, デフォルトは `False`) : シャードを、バッチを分割して各プロセスにその一部を割り当てることで作成するか、各プロセスで異なる完全なバッチを生成することで作成するかを指定します。2つのプロセスで、サンプラーが `[[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]` を生成します。

even_batches (`bool`、*任意*、デフォルトは`True`) : サンプル数が(元のバッチサイズ / プロセス数)の整数倍でない場合、サンプラーの先頭に戻ってループするかどうか。

PyTorchの`BatchSampler`をラップし、プロセスの1つにのみバッチを生成します。このクラスのインスタンスは、常に`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/main/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`、*optional*、デフォルトは 1) : 並行して実行されるプロセスの数。

process_index (`int`、*任意*、デフォルトは 0) : 現在のプロセスのインデックス。

split_batches (`bool`、*任意*、デフォルトは`False`) : シャードを、バッチを分割して各プロセスにその一部を割り当てる方法で作成するか、各プロセスで異なる完全なバッチを生成する方法で作成するかを指定します。 2つのプロセスで、`[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`をラップし、プロセスの1つに対してのみサンプルを生成します。このクラスのインスタンスは、常に実際のバッチサイズの整数倍のサンプル数を生成します（`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/main/src/accelerate/data_loader.py#L497)

**パラメータ:**

dataset (`torch.utils.data.dataset.Dataset`) : このdataloaderを構築するために使用するデータセット。

device (`torch.device`, *任意*) : 指定した場合、すべてのバッチを配置するデバイス。

rng_types (list of `str` or [RNGType](/docs/accelerate/main/ja/package_reference/utilities#accelerate.utils.RNGType)) : 各イテレーションの開始時に同期する乱数生成器のリストです。以下の1つまたは複数である必要があります:  - `"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`) : 通常の `DataLoader` ではなく、`torchdata` の `StatefulDataLoader` をこのクラスが適応させるかどうか。

- ****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/main/src/accelerate/data_loader.py#L714)

**パラメータ:**

split_batches (`bool`、*任意*、デフォルトは`False`) : 生成される`DataLoader`が、元のデータローダーのバッチをデバイス間で分割して出力するか、それとも完全なバッチを出力するか（その場合、`process_index`番目のバッチから開始し、各イテレーションで`num_processes`バッチずつ進みます）を指定します。別の見方をすると、このオプションが`True`に設定されている場合、観測されるバッチサイズは初期の`dataloader`と同じになり、それ以外の場合は初期の`dataloader`のバッチサイズに`num_processes`を掛けた値になります。このオプションを`True`に設定するには、`dataloader`のバッチサイズが`batch_size`の整数倍である必要があります。

skip_batches (`int`、*任意*、デフォルトは 0) : 反復の開始時にスキップするバッチ数。

use_stateful_dataloader (`bool`, *任意*, デフォルトは `False`) : 通常の `DataLoader` ではなく、`torchdata` の `StatefulDataLoader` をこのクラスが適応させるかどうか。

`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/main/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/main/src/accelerate/optimizer.py#L138)

オプティマイザーを「eval」モードに設定します。`schedule_free` などのオプティマイザーに有用です。

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

```python
train()
```

[ソース](https://github.com/huggingface/accelerate/blob/main/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/main/src/accelerate/scheduler.py#L25)

**パラメータ:**

scheduler (`torch.optim.lr_scheduler._LRScheduler`) : ラップするスケジューラー。

optimizers (1つまたは`torch.optim.Optimizer`のリスト): 使用されるオプティマイザー。

step_with_optimizer (`bool`、*任意*、デフォルトは`True`) : スケジューラーを各オプティマイザーステップでステップさせるかどうか。

split_batches (`bool`、*任意*、デフォルトは`False`) : データローダーがバッチを異なるプロセス間で分割するかどうか（つまり、プロセス数に関係なくバッチサイズが同じになる）または、各プロセスでバッチを作成するかどうか（つまり、バッチサイズは元のバッチサイズにプロセス数を掛けたものになる）を指定します。

学習率スケジューラをラップし、オプティマイザーがトレーニングステップを実行した場合にのみステップを実行するラッパーです。勾配がオーバーフローしてトレーニングステップが実行されなかった場合（混合精度学習時）に、スケジューラが早すぎるペースでステップを進めてしまうのを防ぐのに役立ちます。

勾配蓄積を実行する際、スケジューラの長さをそれに応じて変更する必要はありません。Accelerate は常にスケジューラをステップ実行して、これを考慮します。

