The Accelerator is the main class provided by 🤗 Accelerate. It serves at the main entrypoint for the API. To quickly adapt your script to work on any kind of setup with 🤗 Accelerate just:
accelerator in the rest of this
page) as early as possible in your script..cuda() or .to(device) in your code and let the
accelerator handle device placement for you.loss.backward() in your code by accelerator.backward(loss).This is all that is needed in most cases. For more advanced cases or a nicer experience here are the functions you
should search for and replace by the corresponding methods of your accelerator:
print statements should be replaced by print() to be only printed once per
process.is_local_main_process for statements that should be executed once per server.is_main_process for statements that should be executed once only.torch.save.torch.nn.utils.clip_grad_norm_ and
clipgrad_value() instead of torch.nn.utils.clip_grad_value_.To perform gradient accumulation use accumulate() and specify a gradient_accumulation_steps.
This will also automatically ensure the gradients are synced or unsynced when on multi-device training, check if the step should
actually be performed, and auto-scale the loss:
accelerator = Accelerator(gradient_accumulation_steps=2)
for (input, label) in enumerate(training_dataloader):
with accelerator.accumulate(model):
predictions = model(input)
loss = loss_function(predictions, labels)
accelerator.backward(loss)
optimizer.step()
scheduler.step()
optimizer.zero_grad()Using this with dispatch_batches=True (which is the default for iterable datasets) is currently not supported.
( device_placement: bool = True split_batches: bool = False fp16: bool = None mixed_precision: typing.Union[accelerate.utils.dataclasses.PrecisionType, str] = None gradient_accumulation_steps: int = 1 cpu: bool = False deepspeed_plugin: DeepSpeedPlugin = None fsdp_plugin: FullyShardedDataParallelPlugin = None rng_types: typing.Union[typing.List[typing.Union[str, accelerate.utils.dataclasses.RNGType]], NoneType] = None log_with: typing.Union[typing.List[typing.Union[str, accelerate.utils.dataclasses.LoggerType, accelerate.tracking.GeneralTracker]], NoneType] = None logging_dir: typing.Union[str, os.PathLike, NoneType] = None dispatch_batches: typing.Optional[bool] = None step_scheduler_with_optimizer: bool = True kwargs_handlers: typing.Optional[typing.List[accelerate.utils.dataclasses.KwargsHandler]] = None )
Parameters
bool, optional, defaults to True) —
Whether or not the accelerator should put objects on device (tensors yielded by the dataloader, model,
etc…).
bool, optional, defaults to False) —
Whether or not the accelerator should split the batches yielded by the dataloaders across the devices. If
True the actual batch size used will be the same on any kind of distributed processes, but it must be a
round multiple of the num_processes you are using. If False, actual batch size used will be the one set
in your script multiplied by the number of processes.
str, optional) —
Whether or not to use mixed precision training (fp16 or bfloat16). Choose from ‘no’,‘fp16’,‘bf16’. Will
default to the value in the environment variable MIXED_PRECISION, which will use the default value in the
accelerate config of the current system or the flag passed with the accelerate.launch command. ‘fp16’
requires pytorch 1.6 or higher. ‘bf16’ requires pytorch 1.10 or higher.
int, optional, default to 1) —
The number of steps that should pass before gradients are accumulated. A number > 1 should be combined with
Accelerator.accumulate.
bool, optional) —
Whether or not to force the script to execute on CPU. Will ignore GPU available if set to True and force
the execution on one process only.
DeepSpeedPlugin, optional) —
Tweak your DeepSpeed related args using this argument. This argument is optional and can be configured
directly using accelerate config
FullyShardedDataParallelPlugin, optional) —
Tweak your FSDP related args using this argument. This argument is optional and can be configured directly
using accelerate config
str or RNGType) —
The list of random number generators to synchronize at the beginning of each iteration in your prepared
dataloaders. Should be one or several of:
"torch": the base torch random number generator"cuda": the CUDA random number generator (GPU only)"xla": the XLA random number generator (TPU only)"generator": the torch.Generator of the sampler (or batch sampler if there is no sampler in your
dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.Will default to ["torch"] for PyTorch versions <=1.5.1 and ["generator"] for PyTorch versions >= 1.6.
str, LoggerType or GeneralTracker, optional) —
A list of loggers to be setup for experiment tracking. Should be one or several of:
"all""tensorboard""wandb""comet_ml"
If "all” is selected, will pick up all available trackers in the environment and intialize them. Can also
accept implementations of GeneralTracker for custom trackers, and can be combined with "all".str, os.PathLike, optional) —
A path to a directory for storing logs of locally-compatible loggers.
bool, optional) —
If set to True, the dataloader prepared by the Accelerator is only iterated through on the main process
and then the batches are split and broadcast to each process. Will default to True for DataLoader whose
underlying dataset is an IterableDataset, False otherwise.
bool, *optional, defaults to True) -- Set Trueif the learning rate scheduler is stepped at the same time as the optimizer,False` if only
done under certain circumstances (at the end of each epoch, for instance).
List[KwargHandler], optional) —
A list of KwargHandler to customize how the objects related to distributed training or mixed precision
are created. See kwargs for more information.
Creates an instance of an accelerator for distributed training (on multi-GPU, TPU) or mixed precision training.
Attributes
torch.device) — The device to use.( model )
A context manager that will lightly wrap around and perform gradient accumulation automatically
Will apply automatic mixed-precision inside the block inside this context manager, if it is enabled. Nothing different will happen otherwise.
Use accelerator.backward(loss) in lieu of loss.backward().
Alias for Accelerate.free_memory, releases all references to the internal objects stored and call the
garbage collector. You should call this method between two trainings with different models/optimizers.
Should be used in place of torch.nn.utils.clip_grad_norm_.
Should be used in place of torch.nn.utils.clip_grad_value_.
Runs any special end training behaviors, such as stopping trackers
Will release all references to the internal objects stored and call the garbage collector. You should call this method between two trainings with different models/optimizers.
(
tensor
)
→
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parameters
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor) —
The tensors to gather across all processes.
Returns
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
The gathered tensor(s). Note that the first dimension of the result is num_processes multiplied by the first dimension of the input tensors.
Gather the values in tensor across all processes and concatenate them on the first dimension. Useful to regroup the predictions from all processes when doing evaluation.
Note: This gather happens in all processes.
( project_name: str config: typing.Optional[dict] = None )
Initializes a run for all trackers stored in self.log_with, potentially with starting configurations
( input_dir: str )
Loads the current states of the model, optimizer, scaler, RNG generators, and registered objects.
Lets the local main process go inside a with block.
The other processes will enter the with block after the main process exits.
( values: dict step: typing.Optional[int] = None )
Logs values to all stored trackers in self.trackers.
Lets the main process go first inside a with block.
The other processes will enter the with block after the main process exits.
( model )
A context manager to disable gradient synchronizations across DDP processes by calling
torch.nn.parallel.DistributedDataParallel.no_sync.
If model is not in DDP, this context manager does nothing
( tensor dim = 0 pad_index = 0 pad_first = False )
Parameters
torch.Tensor) —
The data to gather.
int, optional, defaults to 0) —
The dimension on which to pad.
int, optional, defaults to 0) —
The value with which to pad.
bool, optional, defaults to False) —
Whether to pad at the beginning or the end.
Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so they can safely be gathered.
Prepare all objects passed in args for distributed training and mixed precision, then return them in the same
order.
Accepts the following type of objects:
torch.utils.data.DataLoader: PyTorch Dataloadertorch.nn.Module: PyTorch Moduletorch.optim.Optimizer: PyTorch OptimizerUse in replacement of print() to only print once per server.
(
tensor
reduction = 'sum'
)
→
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parameters
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor) —
The tensors to reduce across all processes.
str, optional, defaults to “sum”) —
A reduction type, can be one of ‘sum’, ‘mean’, or ‘none’. If ‘none’, will not perform any operation.
Returns
torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
The reduced tensor(s).
Reduce the values in tensor across all processes based on reduction.
Note: All processes get the reduced value.
Makes note of objects and will save or load them in during save_state or load_state.
These should be utilized when the state is being loaded or saved in the same script. It is not designed to be used in different scripts
Every object must have a load_state_dict and state_dict function to be stored.
Save the object passed to disk once per machine. Use in place of torch.save.
( output_dir: str )
Saves the current states of the model, optimizer, scaler, RNG generators, and registered objects.
( optimizer = None )
Parameters
torch.optim.Optimizer or List[torch.optim.Optimizer], optional) —
The optimizer(s) for which to unscale gradients. If not set, will unscale gradients on all optimizers
that were passed to prepare().
Unscale the gradients in mixed precision training with AMP. This is a noop in all other settings.
Unwraps the model from the additional layer possible added by prepare(). Useful before saving
the model.
Will stop the execution of the current process until every other process has reached that point (so this does nothing when the script is only run in one process). Useful to do before saving a model.