# DataLoaders, Optimizers y Schedulers

Las clases internas que utiliza Accelerate para preparar objetos para el entrenamiento distribuido al llamar a [prepare()](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator.prepare).

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

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

**Parámetros:**

dataloader (`torch.utils.data.dataloader.DataLoader`) : El cargador de datos para dividir entre varios dispositivos.

device (`torch.device`) : El dispositivo de destino para el `DataLoader` devuelto.

num_processes (`int`, *opcional*) : El número de procesos que se ejecutan de forma concurrente. Por defecto, tomará el valor dado por [PartialState](/docs/accelerate/main/es/package_reference/state#accelerate.PartialState).

process_index (`int`, *opcional*) : El índice del proceso actual. Por defecto, tomará el valor dado por [PartialState](/docs/accelerate/main/es/package_reference/state#accelerate.PartialState).

split_batches (`bool`, *opcional*, valor predeterminado `False`) : Si el `DataLoader` resultante debe dividir los lotes del cargador de datos original entre los dispositivos o si debe generar lotes completos (en cuyo caso generará lotes comenzando en el índice `process_index` y avanzando de `num_processes` lotes en cada iteración). Otra forma de verlo es que el tamaño de lote observado será el mismo que el del `dataloader` inicial si esta opción se establece en `True`, y el tamaño de lote del `dataloader` inicial multiplicado por `num_processes` en caso contrario. Establecer esta opción en `True` requiere que el tamaño de lote del `dataloader` sea un múltiplo exacto de `batch_size`.

put_on_device (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben colocar los lotes en `device` (solo funciona si los lotes son listas anidadas, tuplas o diccionarios de tensores).

rng_types (lista de `str` o [RNGType](/docs/accelerate/main/es/package_reference/utilities#accelerate.utils.RNGType)) : La lista de generadores de números aleatorios que se deben sincronizar al principio de cada iteración. Debe ser uno o varios de:  - `"torch"`: el generador de números aleatorios base de torch - `"cuda"`: el generador de números aleatorios de CUDA (solo GPU) - Cualquier tipo de dispositivo de acelerador de PyTorch registrado: su generador de números aleatorios de dispositivo. - `"xla"`: el generador de números aleatorios de XLA (solo TPU) - `"generator"`: el `torch.Generator` del sampler (o del batch sampler si no hay sampler en su dataloader) o del dataset iterable (si existe) si el dataset subyacente es de ese tipo.

dispatch_batches (`bool`, *opcional*) : Si se establece en `True`, el dataloader preparado solo se itera en el proceso principal y luego los lotes se dividen y se difunden a cada proceso. El valor predeterminado será `True` cuando el conjunto de datos subyacente sea un `IterableDataset`, y `False` en caso contrario.

even_batches (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `True`, en los casos en que el tamaño total del lote en todos los procesos no divide exactamente el conjunto de datos, se duplicarán las muestras del inicio del conjunto de datos para que el lote pueda dividirse equitativamente entre todos los trabajadores.

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/es/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*, valor predeterminado `False`) : Si se debe usar `SeedableRandomSampler` en lugar de `RandomSampler` para mejorar la reproducibilidad. Esto conlleva un coste de posibles diferencias de rendimiento debido a los distintos algoritmos de barajado, pero garantiza que los resultados serán exactamente los *mismos*. Debe usarse junto con `set_seed()` en cada `self.set_epoch`

data_seed (`int`, *opcional*, valor predeterminado `None`) : La semilla que se usará para el generador subyacente al utilizar `use_seedable_sampler`. Si es `None`, el generador usará la semilla predeterminada actual de torch.

non_blocking (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, el dataloader utilizará transferencias no bloqueantes de host a dispositivo. Si el dataloader tiene `pin_memory` establecido en `True`, esto ayudará a aumentar la superposición entre la transferencia de datos y los cálculos.

use_stateful_dataloader (`bool`, *opcional*, valor predeterminado `False`) : "Si se establece en true, el dataloader preparado por el Accelerator estará respaldado por [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Esto requiere que esté instalada la versión 0.8.0 o superior de `torchdata` que admita StatefulDataLoader."

torch_device_mesh (`torch.distributed.DeviceMesh`, *opcional*, valor predeterminado `None`) : Malla de dispositivos de PyTorch.

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

Un nuevo cargador de datos que generará la porción de los lotes

Envuelve un `DataLoader` de PyTorch para generar lotes solo para uno de los procesos.

Dependiendo del valor del atributo `drop_last` del `dataloader` pasado, la iteración se detendrá en el primer lote que sea demasiado pequeño / no esté presente en todos los procesos, o bien se repetirá con los índices desde el principio.

Los `BatchSampler` con tamaños de lote variables no están habilitados de forma predeterminada. Para habilitar este comportamiento, establezca `even_batches` igual a `False`

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

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

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

Crea un `torch.utils.data.DataLoader` que omitirá de manera eficiente los primeros `num_batches`. No debe usarse si el dataloader original es un `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)
```

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

**Parámetros:**

batch_sampler (`torch.utils.data.sampler.BatchSampler`) : El batch sampler para dividir en varios fragmentos.

num_processes (`int`, *opcional*, valor predeterminado 1) : El número de procesos que se ejecutan de forma concurrente.

process_index (`int`, *opcional*, valor predeterminado 0) : El índice del proceso actual.

split_batches (`bool`, *opcional*, valor predeterminado `False`) : Si los fragmentos deben crearse dividiendo un lote para dar una parte de él a cada proceso, o generando lotes completos diferentes en cada proceso. Con dos procesos y un muestreador de `[[0, 1, 2, 3], [4, 5, 6, 7]]`, esto resultará en: - el muestreador en el proceso 0 generará `[0, 1, 2, 3]` y el muestreador en el proceso 1 generará `[4, 5, 6, 7]` si este argumento se establece en `False`. - el muestreador en el proceso 0 generará `[0, 1]` y luego `[4, 5]` y el muestreador en el proceso 1 generará `[2, 3]` y luego `[6, 7]` si este argumento se establece en `True`.

even_batches (`bool`, *opcional*, valor predeterminado `True`) : Si se debe volver al principio del muestreador cuando el número de muestras no es un múltiplo exacto de (tamaño del lote original / número de procesos).

Envuelve un `BatchSampler` de PyTorch para generar lotes para uno de los procesos. Las instancias de esta clase siempre generarán un número de lotes que es un múltiplo exacto de `num_processes` y que todos tienen el mismo tamaño. Dependiendo del valor del atributo `drop_last` del lote de muestreo pasado, la iteración se detendrá en el primer lote que sea demasiado pequeño / no esté presente en todos los procesos o se repetirá con los índices desde el principio.

Los `BatchSampler` con tamaños de lote variables no están habilitados de forma predeterminada. Para habilitar este comportamiento, establezca `even_batches` igual a `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)
```

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

**Parámetros:**

dataset (`torch.utils.data.dataset.IterableDataset`) : el batch sampler para dividir en varios shards.

batch_size (`int`, *opcional*, valor predeterminado 1) : El tamaño de los lotes por fragmento (si `split_batches=False`) o el tamaño de los lotes (si `split_batches=True`).

drop_last (`bool`, *opcional*, valor predeterminado `False`) : Si se debe descartar el último lote incompleto o completar los últimos lotes utilizando las muestras del principio.

num_processes (`int`, *opcional*, valor predeterminado 1) : El número de procesos que se ejecutan de forma concurrente.

process_index (`int`, *opcional*, valor predeterminado 0) : El índice del proceso actual.

split_batches (`bool`, *opcional*, valor predeterminado `False`) : Si los fragmentos deben crearse dividiendo un lote para dar una parte de él a cada proceso, o generando lotes completos diferentes en cada proceso. Con dos procesos y un conjunto de datos iterable que genera `[0, 1, 2, 3, 4, 5, 6, 7]`, esto resultará en: - el fragmento en el proceso 0 generará `[0, 1, 2, 3]` y el fragmento en el proceso 1 generará `[4, 5, 6, 7]` si este argumento se establece en `False`. - el fragmento en el proceso 0 generará `[0, 1, 4, 5]` y el muestreador en el proceso 1 generará `[2, 3, 6, 7]` si este argumento se establece en `True`.

Envuelve un `IterableDataset` de PyTorch para generar muestras solo para uno de los procesos. Las instancias de esta clase siempre producirán un número de muestras que es un múltiplo exacto del tamaño real del lote (según el valor de `split_batches`, esto será `batch_size` o `batch_size x num_processes`). Dependiendo del valor del atributo `drop_last` del muestreador de lotes pasado, la iteración se detendrá en el primer lote que sea demasiado pequeño o se repetirá con los índices desde el principio.

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

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

**Parámetros:**

dataset (`torch.utils.data.dataset.Dataset`) : El conjunto de datos que se usará para construir este dataloader.

device (`torch.device`, *opcional*) : Si se pasa, el dispositivo en el que se colocarán todos los lotes.

rng_types (lista de `str` o [RNGType](/docs/accelerate/main/es/package_reference/utilities#accelerate.utils.RNGType)) : La lista de generadores de números aleatorios que se deben sincronizar al principio de cada iteración. Debe ser uno o varios de:  - `"torch"`: el generador de números aleatorios base de torch - `"cuda"`: el generador de números aleatorios de CUDA (solo GPU) - Cualquier tipo de dispositivo de acelerador de PyTorch registrado: su generador de números aleatorios de dispositivo. - `"xla"`: el generador de números aleatorios de XLA (solo TPU) - `"generator"`: un `torch.Generator` opcional

synchronized_generator (`torch.Generator`, *opcional*) : Un generador de números aleatorios para mantener sincronizado entre procesos.

skip_batches (`int`, *opcional*, valor predeterminado 0) : El número de lotes que se omiten al principio.

use_stateful_dataloader (`bool`, *opcional*, por defecto `False`) : Si se debe adaptar `StatefulDataLoader` de `torchdata` en lugar del `DataLoader` regular.

- ****kwargs** (argumentos de palabra clave adicionales, *opcional*) : Todos los demás argumentos de palabra clave para pasar a la inicialización regular de `DataLoader`.

Subclase de `DataLoaderAdapter` que se encargará de la colocación en el dispositivo y de la configuración distribuida actual.

**Attributos disponibles:**

- **total_batch_size** (`int`) -- Tamaño total del lote del dataloader en todos los procesos. Es igual al tamaño de lote original cuando `split_batches=True`; en caso contrario, es el tamaño de lote original * el número total de procesos

- **total_dataset_length** (`int`) -- Longitud total del conjunto de datos interno en todos los procesos.

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

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

**Parámetros:**

split_batches (`bool`, *opcional*, valor predeterminado `False`) : Si el `DataLoader` resultante debe dividir los lotes del cargador de datos original entre los dispositivos o si debe generar lotes completos (en cuyo caso generará lotes comenzando en el índice `process_index` y avanzando de `num_processes` lotes en cada iteración). Otra forma de verlo es que el tamaño de lote observado será el mismo que el del `dataloader` inicial si esta opción se establece en `True`, y el tamaño de lote del `dataloader` inicial multiplicado por `num_processes` en caso contrario. Establecer esta opción en `True` requiere que el tamaño de lote del `dataloader` sea un múltiplo exacto de `batch_size`.

skip_batches (`int`, *opcional*, valor predeterminado 0) : El número de lotes que se omiten al inicio de una iteración.

use_stateful_dataloader (`bool`, *opcional*, por defecto `False`) : Si se debe adaptar `StatefulDataLoader` de `torchdata` en lugar del `DataLoader` regular.

Subclase de `DataLoaderAdapter` que iterará y preprocesará solo en el proceso 0 y luego distribuirá en cada proceso su parte del lote.

**Attributos disponibles:**

- **total_batch_size** (`int`) -- Tamaño total del lote del dataloader en todos los procesos. Es igual al tamaño de lote original cuando `split_batches=True`; en caso contrario, es el tamaño de lote original * el número total de procesos

- **total_dataset_length** (`int`) -- Longitud total del conjunto de datos interno en todos los procesos.

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

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

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

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

**Parámetros:**

optimizer (`torch.optim.optimizer.Optimizer`) : El optimizador que se va a envolver.

device_placement (`bool`, *opcional*, valor predeterminado `True`) : Indica si el optimizador debe gestionar la colocación de dispositivos. Si es así, colocará el diccionario de estado de `optimizer` en el dispositivo correcto.

scaler (`torch.amp.GradScaler` o `torch.cuda.amp.GradScaler`, *opcional*) : El escalador que se utilizará en la función step si se entrena con precisión mixta.

Envoltorio interno de un optimizador de torch.

De forma condicional, se ejecutará `step` y `zero_grad` si las gradiente deben sincronizarse al realizar la acumulación de gradientes.

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

```python
eval()
```

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

Establece el optimizador en modo "eval". Útil para optimizadores como `schedule_free`

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

```python
train()
```

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

Establece el optimizador en modo "train". Útil para optimizadores 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)
```

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

**Parámetros:**

scheduler (`torch.optim.lr_scheduler._LRScheduler`) : El programador que se va a envolver.

optimizers (un `torch.optim.Optimizer` o una lista de `torch.optim.Optimizer`) : Los optimizadores utilizados.

step_with_optimizer (`bool`, *opcional*, valor predeterminado `True`) : Indica si el programador debe avanzar en cada paso del optimizador.

split_batches (`bool`, *opcional*, valor predeterminado `False`) : Indica si los dataloaders dividen un lote entre los diferentes procesos (de modo que el tamaño del lote es el mismo sin importar el número de procesos) o si crean lotes en cada proceso (de modo que el tamaño del lote es el tamaño original del lote multiplicado por el número de procesos).

Un envoltorio para un programador de tasa de aprendizaje que solo avanzará cuando los optimizadores realicen un paso de entrenamiento. Útil para evitar que el programador avance demasiado rápido cuando los gradientes se desbordaron y no hubo un paso de entrenamiento (en entrenamiento de precisión mixta).

Al realizar la acumulación de gradientes, las longitudes del programador de aprendizaje no deben modificarse en consecuencia; Accelerate siempre avanzará el programador para tenerlo en cuenta.

