# DataLoaders, Otimizadores e Agendadores

As classes internas que o Accelerate usa para preparar objetos para treinamento distribuído ao chamar [prepare()](/docs/accelerate/main/pt/package_reference/accelerator#accelerate.Accelerator.prepare).

## Utilitários do 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)
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L1003)

**Parâmetros:**

dataloader (`torch.utils.data.dataloader.DataLoader`) : O carregador de dados a ser dividido entre vários dispositivos.

device (`torch.device`) : O dispositivo de destino para o `DataLoader` retornado.

num_processes (`int`, *opcional*) : O número de processos executados simultaneamente. O valor padrão será o fornecido por [PartialState](/docs/accelerate/main/pt/package_reference/state#accelerate.PartialState).

process_index (`int`, *opcional*) : O índice do processo atual. O valor padrão será o fornecido por [PartialState](/docs/accelerate/main/pt/package_reference/state#accelerate.PartialState).

split_batches (`bool`, *opcional*, padrão `False`) : Se o `DataLoader` resultante deve dividir os lotes do carregador de dados original entre os dispositivos ou fornecer lotes completos (nesse caso, ele fornecerá lotes começando no índice `process_index` e avançando de `num_processes` lotes a cada iteração). Outra forma de ver isso é que o tamanho do lote observado será o mesmo do `dataloader` inicial se esta opção for definida como `True`, caso contrário, será o tamanho do lote do `dataloader` inicial multiplicado por `num_processes`. Definir esta opção como `True` exige que o tamanho do lote do `dataloader` seja um múltiplo exato de `batch_size`.

put_on_device (`bool`, *opcional*, padrão `False`) : Indica se os lotes devem ser colocados no `device` (funciona apenas se os lotes forem listas aninhadas, tuplas ou dicionários de tensores).

rng_types (lista de `str` ou [RNGType](/docs/accelerate/main/pt/package_reference/utilities#accelerate.utils.RNGType)) : A lista de geradores de números aleatórios a serem sincronizados no início de cada iteração. Deve ser um ou vários dos seguintes:  - `"torch"`: o gerador de números aleatórios base do torch - `"cuda"`: o gerador de números aleatórios do CUDA (somente GPU) - Qualquer tipo de dispositivo de acelerador registrado do PyTorch: seu gerador de números aleatórios de dispositivo. - `"xla"`: o gerador de números aleatórios do XLA (somente TPU) - `"generator"`: o `torch.Generator` do sampler (ou do batch sampler, se não houver sampler no seu dataloader) ou do dataset iterável (se existir), caso o dataset subjacente seja desse tipo.

dispatch_batches (`bool`, *opcional*) : Se definido como `True`, o dataloader preparado é iterado apenas no processo principal e, em seguida, os lotes são divididos e transmitidos para cada processo. O valor padrão será `True` quando o conjunto de dados subjacente for um `IterableDataset`, `False` caso contrário.

even_batches (`bool`, *opcional*, padrão `True`) : Se definido como `True`, em casos em que o tamanho total do lote em todos os processos não divide exatamente o conjunto de dados, as amostras no início do conjunto de dados serão duplicadas para que o lote possa ser dividido igualmente entre todos os workers.

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/pt/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`, *opcional*, padrão `False`) : Se deve usar o `SeedableRandomSampler` em vez de um `RandomSampler` para melhor reprodutibilidade. Isso pode resultar em desempenhos diferentes devido a algoritmos de embaralhamento distintos, mas garante que os resultados sejam exatamente os *mesmos*. Deve ser usado em conjunto com `set_seed()` a cada `self.set_epoch`

data_seed (`int`, *opcional*, padrão `None`) : A semente a ser usada para o gerador subjacente ao utilizar `use_seedable_sampler`. Se `None`, o gerador usará a semente padrão atual do torch.

non_blocking (`bool`, *opcional*, padrão `False`) : Se definido como `True`, o dataloader utilizará transferências não bloqueantes de host para dispositivo. Se o dataloader tiver `pin_memory` definido como `True`, isso ajudará a aumentar a sobreposição entre a transferência de dados e os cálculos.

use_stateful_dataloader (`bool`, *opcional*, padrão `False`) : "Se definido como true, o dataloader preparado pelo Accelerator será baseado em [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Isso requer a instalação da versão 0.8.0 ou superior do `torchdata` que suporte StatefulDataLoader."

torch_device_mesh (`torch.distributed.DeviceMesh`, *opcional*, padrão `None`) : malha de dispositivos do PyTorch.

**Retorna:** `torch.utils.data.dataloader.DataLoader`

Um novo carregador de dados que retornará a porção dos lotes

Envolve um `DataLoader` do PyTorch para gerar lotes apenas para um dos processos.

Dependendo do valor do atributo `drop_last` do `dataloader` passado, a iteração será interrompida no primeiro lote que seria pequeno demais / não estivesse presente em todos os processos, ou será reiniciada com os índices do início.

`BatchSampler`s com tamanhos de lote variáveis não são habilitados por padrão. Para habilitar esse comportamento, defina `even_batches` como `False`

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

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

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L1379)

Cria um `torch.utils.data.DataLoader` que ignorará eficientemente as primeiras `num_batches`. Não deve ser usado se o dataloader original for um `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)
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L101)

**Parâmetros:**

batch_sampler (`torch.utils.data.sampler.BatchSampler`) : O batch sampler para dividir em vários shards.

num_processes (`int`, *opcional*, padrão 1) : O número de processos executados simultaneamente.

process_index (`int`, *opcional*, padrão 0) : O índice do processo atual.

split_batches (`bool`, *opcional*, padrão `False`) : Se os shards devem ser criados dividindo um lote para dar uma parte dele em cada processo, ou gerando lotes completos diferentes em cada processo. Em dois processos com um sampler de `[[0, 1, 2, 3], [4, 5, 6, 7]]`, isso resultará em: - o sampler no processo 0 gerando `[0, 1, 2, 3]` e o sampler no processo 1 gerando `[4, 5, 6, 7]` se este argumento for definido como `False`. - o sampler no processo 0 gerando `[0, 1]` e depois `[4, 5]` e o sampler no processo 1 gerando `[2, 3]` e depois `[6, 7]` se este argumento for definido como `True`.

even_batches (`bool`, *opcional*, padrão `True`) : Se deve ou não recomeçar do início do sampler quando o número de amostras não for um múltiplo exato de (tamanho original do lote / número de processos).

Envolve um `BatchSampler` do PyTorch para gerar lotes para apenas um dos processos. As instâncias desta classe sempre retornarão um número de lotes que é um múltiplo exato de `num_processes` e que todos têm o mesmo tamanho. Dependendo do valor do atributo `drop_last` do lote sampler passado, a iteração será interrompida no primeiro lote que seria pequeno demais / não existiria em todos os processos, ou será repetida com os índices a partir do início.

`BatchSampler`s com tamanhos de lote variáveis não são habilitados por padrão. Para habilitar esse comportamento, defina `even_batches` como `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)
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L265)

**Parâmetros:**

dataset (`torch.utils.data.dataset.IterableDataset`) : O batch sampler para dividir em vários shards.

batch_size (`int`, *opcional*, padrão 1) : O tamanho dos lotes por shard (se `split_batches=False`) ou o tamanho dos lotes (se `split_batches=True`).

drop_last (`bool`, *opcional*, padrão `False`) : Se deve descartar o último lote incompleto ou completar os últimos lotes usando as amostras do início.

num_processes (`int`, *opcional*, padrão 1) : O número de processos executados simultaneamente.

process_index (`int`, *opcional*, padrão 0) : O índice do processo atual.

split_batches (`bool`, *opcional*, padrão `False`) : Se os shards devem ser criados dividindo um lote para dar uma parte dele em cada processo, ou gerando lotes completos diferentes em cada processo. Em dois processos com um dataset iterável que gera `[0, 1, 2, 3, 4, 5, 6, 7]`, isso resultará em: - o shard no processo 0 gerando `[0, 1, 2, 3]` e o shard no processo 1 gerando `[4, 5, 6, 7]` se este argumento for definido como `False`. - o shard no processo 0 gerando `[0, 1, 4, 5]` e o sampler no processo 1 gerando `[2, 3, 6, 7]` se este argumento for definido como `True`.

Envolve um `IterableDataset` do PyTorch para gerar amostras para apenas um dos processos. As instâncias desta classe sempre retornarão um número de amostras que é um múltiplo exato do tamanho real do lote (dependendo do valor de `split_batches`, isso será `batch_size` ou `batch_size x num_processes`). Dependendo do valor do atributo `drop_last` do batch sampler passado, a iteração será interrompida no primeiro lote que seria pequeno demais ou repetirá com os índices a partir do início.

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

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L497)

**Parâmetros:**

dataset (`torch.utils.data.dataset.Dataset`) : O conjunto de dados a ser usado para construir este dataloader.

device (`torch.device`, *opcional*) : Se fornecido, o dispositivo em que todos os lotes serão colocados.

rng_types (lista de `str` ou [RNGType](/docs/accelerate/main/pt/package_reference/utilities#accelerate.utils.RNGType)) : A lista de geradores de números aleatórios a serem sincronizados no início de cada iteração. Deve ser um ou vários dos seguintes:  - `"torch"`: o gerador de números aleatórios base do torch - `"cuda"`: o gerador de números aleatórios do CUDA (somente GPU) - Qualquer tipo de dispositivo de acelerador registrado do PyTorch: seu gerador de números aleatórios de dispositivo. - `"xla"`: o gerador de números aleatórios do XLA (somente TPU) - `"generator"`: um `torch.Generator` opcional

synchronized_generator (`torch.Generator`, *opcional*) : Um gerador de números aleatórios para manter sincronizado entre processos.

skip_batches (`int`, *opcional*, padrão 0) : O número de lotes a serem ignorados no início.

use_stateful_dataloader (`bool`, *opcional*, padrão `False`) : Se esta classe deve adaptar o `StatefulDataLoader` do `torchdata` em vez do `DataLoader` regular.

- ****kwargs** (argumentos de palavra-chave adicionais, *opcional*) : Todos os outros argumentos de palavra-chave para passar à inicialização regular do `DataLoader`.

Subclasse de `DataLoaderAdapter` que lidará com a colocação de dispositivos e a configuração distribuída atual.

**Atributos disponíveis:**

- **total_batch_size** (`int`) -- Tamanho total do lote do dataloader em todos os processos. Igual ao tamanho original do lote quando `split_batches=True`; caso contrário, o tamanho original do lote * o número total de processos

- **total_dataset_length** (`int`) -- Comprimento total do dataset interno em todos os processos.

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

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/data_loader.py#L714)

**Parâmetros:**

split_batches (`bool`, *opcional*, padrão `False`) : Se o `DataLoader` resultante deve dividir os lotes do carregador de dados original entre os dispositivos ou fornecer lotes completos (nesse caso, ele fornecerá lotes começando no índice `process_index` e avançando de `num_processes` lotes a cada iteração). Outra forma de ver isso é que o tamanho do lote observado será o mesmo do `dataloader` inicial se esta opção for definida como `True`, caso contrário, será o tamanho do lote do `dataloader` inicial multiplicado por `num_processes`. Definir esta opção como `True` exige que o tamanho do lote do `dataloader` seja um múltiplo exato de `batch_size`.

skip_batches (`int`, *opcional*, padrão 0) : O número de lotes a serem ignorados no início de uma iteração.

use_stateful_dataloader (`bool`, *opcional*, padrão `False`) : Se esta classe deve adaptar o `StatefulDataLoader` do `torchdata` em vez do `DataLoader` regular.

Subclasse de `DataLoaderAdapter` que itera e pré-processa apenas no processo 0 e, em seguida, distribui a cada processo sua parte do lote.

**Atributos disponíveis:**

- **total_batch_size** (`int`) -- Tamanho total do lote do dataloader em todos os processos. Igual ao tamanho original do lote quando `split_batches=True`; caso contrário, o tamanho original do lote * o número total de processos

- **total_dataset_length** (`int`) -- Comprimento total do dataset interno em todos os processos.

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

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

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

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/optimizer.py#L38)

**Parâmetros:**

optimizer (`torch.optim.optimizer.Optimizer`) : O otimizador a ser encapsulado.

device_placement (`bool`, *opcional*, padrão `True`) : Se o otimizador deve ou não lidar com a colocação de dispositivos. Se sim, ele colocará o dicionário de estado de `optimizer` no dispositivo correto.

scaler (`torch.amp.GradScaler` ou `torch.cuda.amp.GradScaler`, *opcional*) : O scaler a ser usado na função de passo ao treinar com precisão mista.

Wrapper interno em torno de um otimizador do torch.

Condicionalmente, executará `step` e `zero_grad` se os gradientes devem ser sincronizados ao realizar a acumulação de gradientes.

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

```python
eval()
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/optimizer.py#L138)

Define o otimizador para o modo "eval". Útil para otimizadores como `schedule_free`

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

```python
train()
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/optimizer.py#L124)

Define o otimizador no modo "train". Útil para otimizadores como `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)
```

[Fonte](https://github.com/huggingface/accelerate/blob/main/src/accelerate/scheduler.py#L25)

**Parâmetros:**

scheduler (`torch.optim.lr_scheduler._LRScheduler`) : O scheduler a ser envolvido.

optimizers (um ou uma lista de `torch.optim.Optimizer`) : Os otimizadores usados.

step_with_optimizer (`bool`, *opcional*, padrão `True`) : Se o agendador deve ou não ser avançado a cada passo do otimizador.

split_batches (`bool`, *opcional*, padrão `False`) : Se os dataloaders dividem um lote entre os diferentes processos (de modo que o tamanho do lote é o mesmo, independentemente do número de processos) ou criam lotes em cada processo (de modo que o tamanho do lote é o tamanho original do lote multiplicado pelo número de processos).

Um wrapper em torno de um agendador de taxa de aprendizado que só avança quando o(s) otimizador(es) dão um passo de treinamento. Útil para evitar que o agendador avance rápido demais quando os gradientes estouraram e não houve um passo de treinamento (em treinamento de precisão mista)

Ao executar o agendamento de acúmulo de gradientes, os comprimentos não devem ser alterados de acordo, pois o Accelerate sempre avança o agendador para levar isso em conta.

