Remove whitespace

README.md

@@ -50,4 +50,9 @@ To:
 ```
 Then remove all import statements (as we only care about the content).
 
+Strip all blank spaces/whitespace:
+```regex
+^(?:[\t ]*(?:\r?\n|\r))+
+```
+
 **WARNING**: It is known that this will seperate out the `_inner()` in the source code and use it as a seperate function losing the context. Trying out with this issue for now. 

src/accelerator.py

@@ -1,11 +1,7 @@
-
 logger = get_logger(__name__)
-
-
 class Accelerator:
     """
     Creates an instance of an accelerator for distributed training (on multi-GPU, TPU) or mixed precision training.
-
     Args:
         device_placement (`bool`, *optional*, defaults to `True`):
             Whether or not the accelerator should put objects on device (tensors yielded by the dataloader, model,
@@ -39,17 +35,14 @@ class Accelerator:
         rng_types (list of `str` or [`~utils.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.
         log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):
             A list of loggers to be setup for experiment tracking. Should be one or several of:
-
             - `"all"`
             - `"tensorboard"`
             - `"wandb"`
@@ -80,9 +73,7 @@ class Accelerator:
         gradient_accumulation_plugin (`GradientAccumulationPlugin`, *optional*):
             A configuration for how gradient accumulation should be handled, if more tweaking than just the
             `gradient_accumulation_steps` is needed.
-
     **Available attributes:**
-
         - **device** (`torch.device`) -- The device to use.
         - **distributed_type** ([`~utils.DistributedType`]) -- The distributed training configuration.
         - **local_process_index** (`int`) -- The process index on the current machine.
@@ -130,9 +121,7 @@ class Accelerator:
                 raise ValueError(
                     f"Unknown mixed_precision mode: {mixed_precision}. Choose between {PrecisionType.list()}"
                 )
-
         dynamo_plugin = TorchDynamoPlugin() if dynamo_backend is None else TorchDynamoPlugin(backend=dynamo_backend)
-
         if deepspeed_plugin is None:  # init from env variables
             deepspeed_plugin = (
                 DeepSpeedPlugin() if os.environ.get("ACCELERATE_USE_DEEPSPEED", "false") == "true" else None
@@ -147,19 +136,16 @@ class Accelerator:
                 raise ImportError("DeepSpeed is not installed => run `pip install deepspeed` or build it from source.")
             if compare_versions("deepspeed", "<", "0.9.3"):
                 raise ImportError("DeepSpeed version must be >= 0.9.3. Please update DeepSpeed.")
-
             mixed_precision = (
                 os.environ.get("ACCELERATE_MIXED_PRECISION", "no") if mixed_precision is None else mixed_precision
             )
             deepspeed_plugin.set_mixed_precision(mixed_precision)
             deepspeed_plugin.set_deepspeed_weakref()
-
         if os.environ.get("ACCELERATE_USE_FSDP", "false") == "true" or isinstance(
             fsdp_plugin, FullyShardedDataParallelPlugin
         ):
             if is_torch_version("<", FSDP_PYTORCH_VERSION):
                 raise ValueError(f"FSDP requires PyTorch >= {FSDP_PYTORCH_VERSION}")
-
         if fsdp_plugin is None:  # init from env variables
             fsdp_plugin = (
                 FullyShardedDataParallelPlugin() if os.environ.get("ACCELERATE_USE_FSDP", "false") == "true" else None
@@ -168,7 +154,6 @@ class Accelerator:
             if not isinstance(fsdp_plugin, FullyShardedDataParallelPlugin):
                 raise TypeError("`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.")
             os.environ["ACCELERATE_USE_FSDP"] = "true"  # use FSDP if plugin is provided
-
         if megatron_lm_plugin is None:  # init from env variables
             megatron_lm_plugin = (
                 MegatronLMPlugin() if os.environ.get("ACCELERATE_USE_MEGATRON_LM", "false") == "true" else None
@@ -177,11 +162,9 @@ class Accelerator:
             if not isinstance(megatron_lm_plugin, MegatronLMPlugin):
                 raise TypeError("`megatron_lm_plugin` must be a MegatronLMPlugin object.")
             os.environ["ACCELERATE_USE_MEGATRON_LM"] = "true"  # use MegatronLM if plugin is provided
-
         if megatron_lm_plugin:
             if not is_megatron_lm_available():
                 raise ImportError("Megatron is not installed. please build it from source.")
-
         # Kwargs handlers
         self.ddp_handler = None
         self.scaler_handler = None
@@ -220,7 +203,6 @@ class Accelerator:
                         self.autocast_handler = handler
         if self.fp8_recipe_handler is None and mixed_precision == "fp8":
             self.fp8_recipe_handler = FP8RecipeKwargs()
-
         kwargs = self.init_handler.to_kwargs() if self.init_handler is not None else {}
         self.state = AcceleratorState(
             mixed_precision=mixed_precision,
@@ -232,19 +214,16 @@ class Accelerator:
             _from_accelerator=True,
             **kwargs,
         )
-
         trackers = filter_trackers(log_with, self.logging_dir)
         if len(trackers) < 1 and log_with is not None:
             warnings.warn(f"`log_with={log_with}` was passed but no supported trackers are currently installed.")
         self.log_with = trackers
-
         if (
             (mixed_precision != "bf16")
             and getattr(self.state, "downcast_bfloat", False)
             and (self.state.distributedType != DistributedType.TPU)
         ):
             raise ValueError("Can only use `downcast_bf16` when using `mixed_precision='bf16'` and on a TPU")
-
         if gradient_accumulation_plugin is not None:
             if gradient_accumulation_steps != 1:
                 raise ValueError(
@@ -263,13 +242,11 @@ class Accelerator:
                 raise ValueError(
                     "Gradient accumulation is not supported on TPU. Please set `gradient_accumulation_steps` to 1 and don't pass in a `GradientAccumulationPlugin` object."
                 )
-
         self.device_placement = device_placement
         self.split_batches = split_batches
         self.dispatch_batches = dispatch_batches
         self.even_batches = even_batches
         self.step_scheduler_with_optimizer = step_scheduler_with_optimizer
-
         # Mixed precision attributes
         self.scaler = None
         self.native_amp = False
@@ -285,13 +262,11 @@ class Accelerator:
             kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}
             if self.distributed_type == DistributedType.FSDP:
                 from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler
-
                 self.scaler = ShardedGradScaler(**kwargs)
             elif is_npu_available():
                 self.scaler = torch.npu.amp.GradScaler(**kwargs)
             else:
                 self.scaler = torch.cuda.amp.GradScaler(**kwargs)
-
         elif self.state.mixed_precision == "bf16" and self.distributed_type not in (
             DistributedType.DEEPSPEED,
             DistributedType.MEGATRON_LM,
@@ -302,80 +277,62 @@ class Accelerator:
                 self.native_amp = is_bf16_available(True)
             if mixed_precision == "bf16" and not self.native_amp and not is_tpu_available():
                 raise ValueError(err.format(mode="bf16", requirement="PyTorch >= 1.10 and a supported device."))
-
         # Start of internal step tracking
         self.step = 0
-
         # Internal references to the training objects
         self._optimizers = []
         self._models = []
         self._schedulers = []
         self._dataloaders = []
         self._custom_objects = []
-
         # Hooks
         self._load_model_state_pre_hook = OrderedDict()
         self._save_model_state_pre_hook = OrderedDict()
-
         # RNG Types
         self.rng_types = rng_types
         if self.rng_types is None:
             self.rng_types = ["generator"]
-
         # Set a flag tensor for early stopping and other breakpoints
         self.flag_tensor = None
-
         check_os_kernel()
-
     @property
     def use_distributed(self):
         """
         Whether the Accelerator is configured for distributed training
         """
         return self.state.use_distributed
-
     @property
     def distributed_type(self):
         return self.state.distributed_type
-
     @property
     def num_processes(self):
         return self.state.num_processes
-
     @property
     def process_index(self):
         return self.state.process_index
-
     @property
     def local_process_index(self):
         return self.state.local_process_index
-
     @property
     def device(self):
         return self.state.device
-
     @property
     def project_dir(self):
         return self.project_configuration.project_dir
-
     @property
     def logging_dir(self):
         return self.project_configuration.logging_dir
-
     @property
     def save_iteration(self):
         return self.project_configuration.iteration
-
     @property
     def is_main_process(self):
         """True for one process only."""
         return self.state.is_main_process
-
     @property
     def is_local_main_process(self):
         """True for one process per server."""
         return self.state.is_local_main_process
-
     @property
     def use_fp16(self):
         warnings.warn(
@@ -384,23 +341,18 @@ class Accelerator:
             FutureWarning,
         )
         return self.mixed_precision != "no"
-
     @property
     def is_last_process(self):
         return self.process_index == self.num_processes - 1
-
     @property
     def mixed_precision(self):
         return self.state.mixed_precision
-
     @contextmanager
     def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False):
         """
         Splits `input` between `self.num_processes` quickly and can be then used on that process. Useful when doing
         distributed inference, such as with different prompts.
-
         Note that when using a `dict`, all keys need to have the same number of elements.
-
         Args:
             inputs (`list`, `tuple`, `torch.Tensor`, or `dict` of `list`/`tuple`/`torch.Tensor`):
                 The input to split between processes.
@@ -409,13 +361,10 @@ class Accelerator:
                 number of elements. Useful when trying to perform actions such as `Accelerator.gather()` on the outputs
                 or passing in less inputs than there are processes. If so, just remember to drop the padded elements
                 afterwards.
-
         Example:
-
         ```python
         # Assume there are two processes
         from accelerate import Accelerator
-
         accelerator = Accelerator()
         with accelerator.split_between_processes(["A", "B", "C"]) as inputs:
             print(inputs)
@@ -423,7 +372,6 @@ class Accelerator:
         ["A", "B"]
         # Process 1
         ["C"]
-
         with accelerator.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
             print(inputs)
         # Process 0
@@ -434,28 +382,19 @@ class Accelerator:
         """
         with PartialState().split_between_processes(inputs, apply_padding=apply_padding) as inputs:
             yield inputs
-
     def on_main_process(self, function: Callable[..., Any] = None):
         """
         A decorator that will run the decorated function on the main process only. Can also be called using the
         `PartialState` class.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
-
-
         >>> @accelerator.on_main_process
         ... def print_something():
         ...     print("This will be printed by process 0 only.")
-
-
         >>> print_something()
         "This will be printed by process 0 only"
         ```
@@ -468,33 +407,23 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-
         def _inner(*args, **kwargs):
             return PartialState().on_main_process(function)(*args, **kwargs)
-
         return _inner
-
     def on_local_main_process(self, function: Callable[..., Any] = None):
         """
         A decorator that will run the decorated function on the local main process only. Can also be called using the
         `PartialState` class.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
         ```python
         # Assume we have 2 servers with 4 processes each.
         from accelerate import Accelerator
-
         accelerator = Accelerator()
-
-
         @accelerator.on_local_main_process
         def print_something():
             print("This will be printed by process 0 only on each server.")
-
-
         print_something()
         # On server 1:
         "This will be printed by process 0 only"
@@ -510,33 +439,23 @@ class Accelerator:
                 raise ValueError(
                     "The `on_local_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-
         def _inner(*args, **kwargs):
             return PartialState().on_local_main_process(function)(*args, **kwargs)
-
         return _inner
-
     def on_last_process(self, function: Callable[..., Any]):
         """
         A decorator that will run the decorated function on the last process only. Can also be called using the
         `PartialState` class.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
         ```python
         # Assume we have 4 processes.
         from accelerate import Accelerator
-
         accelerator = Accelerator()
-
-
         @accelerator.on_last_process
         def print_something():
             print(f"Printed on process {accelerator.process_index}")
-
-
         print_something()
         "Printed on process 3"
         ```
@@ -549,36 +468,26 @@ class Accelerator:
                 raise ValueError(
                     "The `on_last_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-
         def _inner(*args, **kwargs):
             return PartialState().on_last_process(function)(*args, **kwargs)
-
         return _inner
-
     def on_process(self, function: Callable[..., Any] = None, process_index: int = None):
         """
         A decorator that will run the decorated function on a given process index only. Can also be called using the
         `PartialState` class.
-
         Args:
             function (`Callable`, `optional`):
                 The function to decorate.
             process_index (`int`, `optional`):
                 The index of the process on which to run the function.
-
         Example:
         ```python
         # Assume we have 4 processes.
         from accelerate import Accelerator
-
         accelerator = Accelerator()
-
-
         @accelerator.on_process(process_index=2)
         def print_something():
             print(f"Printed on process {accelerator.process_index}")
-
-
         print_something()
         "Printed on process 2"
         ```
@@ -594,36 +503,26 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-
         def _inner(*args, **kwargs):
             return PartialState().on_process(function, process_index)(*args, **kwargs)
-
         return _inner
-
     def on_local_process(self, function: Callable[..., Any] = None, local_process_index: int = None):
         """
         A decorator that will run the decorated function on a given local process index only. Can also be called using
         the `PartialState` class.
-
         Args:
             function (`Callable`, *optional*):
                 The function to decorate.
             local_process_index (`int`, *optional*):
                 The index of the local process on which to run the function.
-
         Example:
         ```python
         # Assume we have 2 servers with 4 processes each.
         from accelerate import Accelerator
-
         accelerator = Accelerator()
-
-
         @accelerator.on_local_process(local_process_index=2)
         def print_something():
             print(f"Printed on process {accelerator.local_process_index}")
-
-
         print_something()
         # On server 1:
         "Printed on process 2"
@@ -642,24 +541,17 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-
         def _inner(*args, **kwargs):
             return PartialState().on_local_process(function, local_process_index)(*args, **kwargs)
-
         return _inner
-
     @contextmanager
     def main_process_first(self):
         """
         Lets the main process go first inside a with block.
-
         The other processes will enter the with block after the main process exits.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> with accelerator.main_process_first():
         ...     # This will be printed first by process 0 then in a seemingly
@@ -669,19 +561,14 @@ class Accelerator:
         """
         with self.state.main_process_first():
             yield
-
     @contextmanager
     def local_main_process_first(self):
         """
         Lets the local main process go inside a with block.
-
         The other processes will enter the with block after the main process exits.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> with accelerator.local_main_process_first():
         ...     # This will be printed first by local process 0 then in a seemingly
@@ -691,29 +578,22 @@ class Accelerator:
         """
         with self.state.local_main_process_first():
             yield
-
     @contextmanager
     def no_sync(self, 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
-
         Args:
             model (`torch.nn.Module`):
                 PyTorch Module that was prepared with `Accelerator.prepare`
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
         >>> input_a = next(iter(dataloader))
         >>> input_b = next(iter(dataloader))
-
         >>> with accelerator.no_sync():
         ...     outputs = model(input_a)
         ...     loss = loss_func(outputs)
@@ -729,30 +609,22 @@ class Accelerator:
         context = contextlib.nullcontext
         if self.use_distributed:
             context = getattr(model, "no_sync", context)
-
         with context():
             yield
-
     @staticmethod
     @contextmanager
     def trigger_sync_in_backward(model):
         """Trigger the sync of the gradients in the next backward pass of the model after multiple forward passes under
         `Accelerator.no_sync` (only applicable in multi-GPU scenarios).
-
                 If the script is not launched in distributed mode, this context manager does nothing.
-
                 Args:
                     model (`torch.nn.Module`):
                         The model for which to trigger the gradient synchronization.
-
                 Example:
-
                 ```python
                 >>> from accelerate import Accelerator
-
                 >>> accelerator = Accelerator()
                 >>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
-
                 >>> with accelerator.no_sync():
                 ...     loss_a = loss_func(model(input_a))  # first forward pass
                 ...     loss_b = loss_func(model(input_b))  # second forward pass
@@ -766,10 +638,8 @@ class Accelerator:
         if not isinstance(model, torch.nn.parallel.DistributedDataParallel):
             yield
             return
-
         old_require_backward_grad_sync = model.require_backward_grad_sync
         old_require_forward_param_sync = model.require_forward_param_sync
-
         # EXPERIMENTAL: This will force grad sync during `backward()`, but it is unknown if it breaks other DDP features.
         # https://github.com/pytorch/pytorch/blob/e1502c0cdbfd17548c612f25d5a65b1e4b86224d/torch/nn/parallel/distributed.py#L1453-L1466
         model.require_backward_grad_sync = True
@@ -781,7 +651,6 @@ class Accelerator:
         finally:
             model.require_backward_grad_sync = old_require_backward_grad_sync
             model.require_forward_param_sync = old_require_forward_param_sync
-
     def _do_sync(self):
         "Sets the right `sync_gradients` context and either resets or increases `self.step`"
         if self.gradient_state.sync_with_dataloader and self.gradient_state.end_of_dataloader:
@@ -790,41 +659,31 @@ class Accelerator:
         else:
             self.step += 1
             self.gradient_state._set_sync_gradients((self.step % self.gradient_state.num_steps) == 0)
-
     @property
     def sync_gradients(self):
         return self.gradient_state.sync_gradients
-
     @sync_gradients.setter
     def sync_gradients(self, sync_gradients):
         self.gradient_state.sync_gradients = sync_gradients
-
     @property
     def gradient_accumulation_steps(self):
         return self.gradient_state.num_steps
-
     @gradient_accumulation_steps.setter
     def gradient_accumulation_steps(self, gradient_accumulation_steps):
         self.gradient_state.plugin_kwargs.update({"num_steps": gradient_accumulation_steps})
-
     @contextmanager
     def accumulate(self, *models):
         """
         A context manager that will lightly wrap around and perform gradient accumulation automatically
-
         Args:
             *models (list of `torch.nn.Module`):
                 PyTorch Modules that were prepared with `Accelerator.prepare`. Models passed to `accumulate()` will
                 skip gradient syncing during backward pass in distributed training
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(gradient_accumulation_steps=1)
         >>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
-
         >>> for input, output in dataloader:
         ...     with accelerator.accumulate(model):
         ...         outputs = model(input)
@@ -840,14 +699,12 @@ class Accelerator:
             for m in models:
                 cm_stack.enter_context(contextlib.nullcontext() if self.sync_gradients else self.no_sync(m))
             yield
-
     @contextmanager
     def join_uneven_inputs(self, joinables, even_batches=None):
         """
         A context manager that facilitates distributed training or evaluation on uneven inputs, which acts as a wrapper
         around `torch.distributed.algorithms.join`. This is useful when the total batch size does not evenly divide the
         length of the dataset.
-
         Args:
             joinables (`list[torch.distributed.algorithms.Joinable]`):
                 A list of models or optimizers that subclass `torch.distributed.algorithms.Joinable`. Most commonly, a
@@ -855,28 +712,18 @@ class Accelerator:
             even_batches (`bool`, *optional*)
                 If set, this will override the value of `even_batches` set in the `Accelerator`. If it is not provided,
                 the default `Accelerator` value wil be used.
-
         <Tip warning={true}>
-
         `join_uneven_inputs` is only supported for Distributed Data Parallel training on multiple GPUs. For any other
         configuration, this method will have no effect.
-
         </Tip>
-
         <Tip warning={true}>
-
         Overidding `even_batches` will not affect iterable-style data loaders.
-
         </Tip>
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(even_batches=True)
         >>> ddp_model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)
-
         >>> with accelerator.join_uneven_inputs([ddp_model], even_batches=False):
         ...     for input, output in dataloader:
         ...         outputs = model(input)
@@ -888,7 +735,6 @@ class Accelerator:
         """
         if self.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU):
             dl_even_batches_values = []
-
             if even_batches is not None:
                 iterable_dl_seen = False
                 # override value in batch sampler for map-style datasets
@@ -898,14 +744,12 @@ class Accelerator:
                         continue
                     dl_even_batches_values.append((dl_idx, dl.batch_sampler.even_batches))
                     dl.batch_sampler.even_batches = even_batches
-
                 if iterable_dl_seen:
                     warnings.warn(
                         "Overridding even_batches is only supported for map-style datasets, yet some dataloaders given were iterable"
                     )
             else:
                 even_batches = self.even_batches
-
             enable_join = False if even_batches else True
             try:
                 with Join(joinables, enable=enable_join, throw_on_early_termination=False):
@@ -920,25 +764,19 @@ class Accelerator:
                 warnings.warn(
                     "Joining uneven inputs is only supported for multi-GPU training, as a result `join_uneven_inputs` will have no effect."
                 )
-
             with contextlib.nullcontext(joinables):
                 yield
-
     def print(self, *args, **kwargs):
         """
         Drop in replacement of `print()` to only print once per server.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> accelerator.print("Hello world!")
         ```
         """
         self.state.print(*args, **kwargs)
-
     def _prepare_one(self, obj, first_pass=False, device_placement=None):
         # First pass of preparation: DataLoader, model, optimizer
         if first_pass:
@@ -955,44 +793,32 @@ class Accelerator:
             return scheduler
         # Return the unprocessed object if previous criteria was not met
         return obj
-
     def prepare(self, *args, device_placement=None):
         """
         Prepare all objects passed in `args` for distributed training and mixed precision, then return them in the same
         order.
-
         Args:
             *args (list of objects):
                 Any of the following type of objects:
-
                 - `torch.utils.data.DataLoader`: PyTorch Dataloader
                 - `torch.nn.Module`: PyTorch Module
                 - `torch.optim.Optimizer`: PyTorch Optimizer
                 - `torch.optim.lr_scheduler.LRScheduler`: PyTorch LR Scheduler
-
             device_placement (`list[bool]`, *optional*):
                 Used to customize whether automatic device placement should be performed for each object passed. Needs
                 to be a list of the same length as `args`. Not compatible with DeepSpeed or FSDP.
-
         <Tip>
-
           You don't need to prepare a model if you only use it for inference without any kind of mixed precision
-
         </Tip>
-
         Examples:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume a model, optimizer, data_loader and scheduler are defined
         >>> model, optimizer, data_loader, scheduler = accelerator.prepare(model, optimizer, data_loader, scheduler)
         ```
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume a model, optimizer, data_loader and scheduler are defined
         >>> device_placement = [True, True, False, False]
@@ -1010,7 +836,6 @@ class Accelerator:
             raise ValueError(
                 f"`device_placement` should be a list with {len(args)} elements (the number of objects passed)."
             )
-
         for obj in args:
             # TODO: Look at enabling native TP training directly with a proper config
             if (
@@ -1023,7 +848,6 @@ class Accelerator:
                     "You can't train a model that has been loaded with `device_map='auto'` in any distributed mode."
                     " Please rerun your script specifying `--num_processes=1` or by launching with `python {{myscript.py}}`."
                 )
-
         if self.distributed_type == DistributedType.DEEPSPEED:
             model_count = 0
             for obj in args:
@@ -1033,7 +857,6 @@ class Accelerator:
                 raise AssertionError(
                     "You can't use same `Accelerator()` instance with multiple models when using DeepSpeed"
                 )
-
         # On TPUs, putting the model on the XLA device will create new parameters, so the corresponding optimizer will
         # have parameters disconnected from the model (so no training :-( ).
         # If the model and optimizer have parameters on different devices we raise an error.
@@ -1047,13 +870,11 @@ class Accelerator:
                     "the flag default value for `device_placement` in your `Accelerator` to let it handle that "
                     "part for you."
                 )
-
         # If we're dealing with device placement, this deals with that by...
         tpu_should_fix_optimizer = self.device_placement and self.distributed_type == DistributedType.TPU
         if tpu_should_fix_optimizer or (self.mixed_precision == "fp8" and self.fp8_recipe_handler.backend == "TE"):
             # 1. grabbing old model parameters
             old_named_params = self._get_named_parameters(*args)
-
         if self.distributed_type in [DistributedType.MULTI_CPU, DistributedType.MULTI_XPU, DistributedType.NO]:
             if self.device.type == "cpu" and self.state.use_ipex:
                 args = self._prepare_ipex(*args)
@@ -1072,7 +893,6 @@ class Accelerator:
                 self._prepare_one(obj, first_pass=True, device_placement=d) for obj, d in zip(args, device_placement)
             )
             result = tuple(self._prepare_one(obj, device_placement=d) for obj, d in zip(result, device_placement))
-
         if tpu_should_fix_optimizer or (self.mixed_precision == "fp8" and self.fp8_recipe_handler.backend == "TE"):
             # 2. grabbing new model parameters
             new_named_params = self._get_named_parameters(*result)
@@ -1082,21 +902,17 @@ class Accelerator:
             for obj in result:
                 if isinstance(obj, torch.optim.Optimizer):
                     obj._switch_parameters(mapping)
-
         for item in result:
             if any(
                 item in container
                 for container in (self._dataloaders, self._models, self._optimizers, self._schedulers)
             ):
                 setattr(item, "_is_accelerate_prepared", True)
-
         return result if len(result) > 1 else result[0]
-
     def prepare_model(self, model: torch.nn.Module, device_placement: bool = None, evaluation_mode: bool = False):
         """
         Prepares a PyTorch model for training in any distributed setup. It is recommended to use
         [`Accelerator.prepare`] instead.
-
         Args:
             model (`torch.nn.Module`):
                 A PyTorch model to prepare. You don't need to prepare a model if it is used only for inference without
@@ -1106,12 +922,9 @@ class Accelerator:
             evaluation_mode (`bool`, *optional*, defaults to `False`):
                 Whether or not to set the model for evaluation only, by just applying mixed precision and
                 `torch.compile` (if configured in the `Accelerator` object).
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume a model is defined
         >>> model = accelerator.prepare_model(model)
@@ -1120,7 +933,6 @@ class Accelerator:
         if device_placement is None:
             device_placement = self.device_placement and self.distributed_type != DistributedType.FSDP
         self._models.append(model)
-
         # TODO: Look at enabling native TP training directly with a proper config
         if (
             self.verify_device_map(model)
@@ -1131,7 +943,6 @@ class Accelerator:
                 "You can't train a model that has been loaded with `device_map='auto'` in any distributed mode."
                 " Please rerun your script specifying `--num_processes=1` or by launching with `python {{myscript.py}}`."
             )
-
         if self.native_amp:
             model._original_forward = model.forward
             model_forward_func = model.forward.__func__ if hasattr(model.forward, "__func__") else model.forward
@@ -1148,13 +959,11 @@ class Accelerator:
                     convert_model(model)
                 model._converted_to_transformer_engine = True
             model._original_forward = model.forward
-
             kwargs = self.fp8_recipe_handler.to_kwargs() if self.fp8_recipe_handler is not None else {}
             if "fp8_format" in kwargs:
                 kwargs["fp8_format"] = getattr(te_recipe.Format, kwargs["fp8_format"])
             fp8_recipe = te_recipe.DelayedScaling(**kwargs)
             model.forward = fp8_autocast(enabled=True, fp8_recipe=fp8_recipe)(model.forward)
-
         if (getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False)) and getattr(
             model, "hf_device_map", False
         ):
@@ -1167,7 +976,6 @@ class Accelerator:
                 )
             current_device = list(model_devices)[0]
             current_device_index = current_device.index if isinstance(current_device, torch.device) else current_device
-
             if torch.device(current_device_index) != self.device:
                 # if on the first device (GPU 0) we don't care
                 if (self.device.index is not None) or (current_device_index != 0):
@@ -1175,7 +983,6 @@ class Accelerator:
                         "You can't train a model that has been loaded in 8-bit precision on a different device than the one "
                         "you're training on. Make sure you loaded the model on the correct device using for example `device_map={'':torch.cuda.current_device() or device_map={'':torch.xpu.current_device()}"
                     )
-
             if "cpu" in model_devices or "disk" in model_devices:
                 raise ValueError(
                     "You can't train a model that has been loaded in 8-bit precision with CPU or disk offload."
@@ -1195,13 +1002,11 @@ class Accelerator:
                         device_ids, output_device = [self.local_process_index], self.local_process_index
                     else:
                         device_ids, output_device = None, None
-
                     model = torch.nn.parallel.DistributedDataParallel(
                         model, device_ids=device_ids, output_device=output_device, **kwargs
                     )
             elif self.distributed_type == DistributedType.FSDP:
                 from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
-
                 # Check if the model is already a FSDP model due to `Manual Wrapping` and if so,
                 # don't wrap it again
                 # In case the model is already compiled using PyTorch 2.0 and the wrapped model in it
@@ -1209,7 +1014,6 @@ class Accelerator:
                 is_type_fsdp = isinstance(model, FSDP) or (
                     is_compiled_module(model) and isinstance(model._orig_mod, FSDP)
                 )
-
                 if not is_type_fsdp:
                     self.state.fsdp_plugin.set_auto_wrap_policy(model)
                     fsdp_plugin = self.state.fsdp_plugin
@@ -1234,7 +1038,6 @@ class Accelerator:
                             apply_activation_checkpointing,
                             checkpoint_wrapper,
                         )
-
                         apply_activation_checkpointing(
                             model,
                             checkpoint_wrapper_fn=functools.partial(
@@ -1258,18 +1061,14 @@ class Accelerator:
                 raise ValueError("Using `torch.compile` requires PyTorch 2.0 or higher.")
             model = torch.compile(model, **self.state.dynamo_plugin.to_kwargs())
         return model
-
     def _prepare_deepspeed(self, *args):
         import deepspeed
-
         deepspeed_plugin = self.state.deepspeed_plugin
-
         is_dataloader_present = any(isinstance(obj, torch.utils.data.DataLoader) for obj in args)
         result = [
             self._prepare_one(obj, first_pass=True) if isinstance(obj, torch.utils.data.DataLoader) else obj
             for obj in args
         ]
-
         if deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] == "auto":
             if is_dataloader_present:
                 batch_sizes = [obj.batch_size for obj in args if hasattr(obj, "batch_size")]
@@ -1281,7 +1080,6 @@ class Accelerator:
                     )
                 if self.split_batches:
                     batch_sizes = [batch_size // self.num_processes for batch_size in batch_sizes]
-
                 batch_size_per_device = min(batch_sizes) if deepspeed_plugin.is_train_batch_min else max(batch_sizes)
                 if len(batch_sizes) > 1:
                     logger.info(
@@ -1297,14 +1095,12 @@ class Accelerator:
                 )
         else:
             batch_size_per_device = deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"]
-
         # handle `gradient_accumulation_steps` when the value is `auto`
         deepspeed_plugin.fill_match(
             "gradient_accumulation_steps",
             must_match=False,
             gradient_accumulation_steps=self.gradient_accumulation_steps,
         )
-
         config_kwargs = {
             "train_micro_batch_size_per_gpu": batch_size_per_device,
             "train_batch_size": batch_size_per_device
@@ -1313,7 +1109,6 @@ class Accelerator:
             "gradient_clipping": 1.0,
             "zero_optimization.stage3_gather_16bit_weights_on_model_save": False,
         }
-
         model = None
         optimizer = None
         scheduler = None
@@ -1326,7 +1121,6 @@ class Accelerator:
                 type(obj).__name__ in deepspeed.runtime.lr_schedules.VALID_LR_SCHEDULES
             ):
                 scheduler = obj
-
         if optimizer is not None:
             if "optimizer" in deepspeed_plugin.deepspeed_config and not isinstance(optimizer, (DummyOptim)):
                 raise ValueError(
@@ -1338,10 +1132,8 @@ class Accelerator:
                 raise ValueError(
                     "You cannot create a `DummyOptim` without specifying an optimizer in the config file."
                 )
-
             if isinstance(optimizer, (torch.optim.Optimizer)):
                 deepspeed_plugin.deepspeed_config["zero_allow_untested_optimizer"] = True
-
         if scheduler is not None:
             if "scheduler" in deepspeed_plugin.deepspeed_config and not isinstance(scheduler, (DummyScheduler)):
                 raise ValueError(
@@ -1358,14 +1150,12 @@ class Accelerator:
                     "Either specify a scheduler in the config file or "
                     "pass in the `lr_scheduler_callable` parameter when using `accelerate.utils.DummyScheduler`."
                 )
-
         if optimizer is not None and scheduler is not None:
             if isinstance(optimizer, (DummyOptim)) and not isinstance(scheduler, (DummyScheduler)):
                 raise ValueError(
                     "You can only specify `accelerate.utils.DummyScheduler` in the code when using "
                     "`accelerate.utils.DummyOptim`."
                 )
-
         if model is not None:
             if hasattr(model, "config"):
                 hidden_size = (
@@ -1381,7 +1171,6 @@ class Accelerator:
                             "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size,
                         }
                     )
-
             if isinstance(optimizer, (DummyOptim)):
                 config_kwargs.update(
                     {"optimizer.params.lr": optimizer.lr, "optimizer.params.weight_decay": optimizer.weight_decay}
@@ -1418,7 +1207,6 @@ class Accelerator:
                         "device", "none"
                     ) != "none" and self.deepspeed_config.get("zero_force_ds_cpu_optimizer", True):
                         from deepspeed.ops.adam import DeepSpeedCPUAdam
-
                         defaults = {k: v for k, v in optimizer.defaults.items() if k in ["lr", "weight_decay"]}
                         optimizer = DeepSpeedCPUAdam(optimizer.param_groups, **defaults)
                     kwargs["optimizer"] = optimizer
@@ -1428,7 +1216,6 @@ class Accelerator:
                             or type(scheduler).__name__ in deepspeed.runtime.lr_schedules.VALID_LR_SCHEDULES
                         ):
                             kwargs["lr_scheduler"] = scheduler
-
             engine, optimizer, _, lr_scheduler = deepspeed.initialize(**kwargs)
             if optimizer is not None:
                 optimizer = DeepSpeedOptimizerWrapper(optimizer)
@@ -1442,7 +1229,6 @@ class Accelerator:
                     )
                 else:
                     scheduler = DeepSpeedSchedulerWrapper(lr_scheduler, optimizer)
-
             for i in range(len(result)):
                 if isinstance(result[i], torch.nn.Module):
                     result[i] = engine
@@ -1464,7 +1250,6 @@ class Accelerator:
                     "You can't use same `Accelerator()` instance with multiple models when using DeepSpeed"
                 )
         return tuple(result)
-
     def _prepare_megatron_lm(self, *args):
         megatron_lm_plugin = self.state.megatron_lm_plugin
         if not megatron_lm_plugin.megatron_dataset_flag:
@@ -1473,7 +1258,6 @@ class Accelerator:
                 raise ValueError(
                     "You must specify a training or evaluation dataloader in `accelerate.prepare()` when using Megatron-LM."
                 )
-
             micro_batch_size = min(batch_sizes) if megatron_lm_plugin.is_train_batch_min else max(batch_sizes)
             if len(batch_sizes) > 1:
                 logger.info(
@@ -1485,10 +1269,8 @@ class Accelerator:
                 if isinstance(obj, MegatronLMDummyDataLoader):
                     micro_batch_size = obj.dataset_args["micro_batch_size"]
                     break
-
         dp_degree = self.num_processes // (megatron_lm_plugin.tp_degree * megatron_lm_plugin.pp_degree)
         megatron_lm_plugin.set_training_args(micro_batch_size, dp_degree)
-
         model = None
         optimizer = None
         scheduler = None
@@ -1503,7 +1285,6 @@ class Accelerator:
                 optimizer = obj
             elif isinstance(obj, (LRScheduler, MegatronLMDummyScheduler)):
                 scheduler = obj
-
         if model is not None:
             megatron_lm_plugin.set_network_size_args(model, batch_data)
         if optimizer is not None:
@@ -1515,7 +1296,6 @@ class Accelerator:
                     "You can't use a custom scheduler with Megatron-LM. Please use the `accelerate.utils.MegatronLMDummyScheduler` instead."
                 )
             megatron_lm_plugin.set_scheduler_args(scheduler)
-
         # initialize megatron-lm
         megatron_lm_initialize(self, args_defaults=megatron_lm_plugin.megatron_lm_default_args)
         counter = 0
@@ -1532,21 +1312,18 @@ class Accelerator:
                 counter += 1
             else:
                 result.append(obj)
-
         if model is not None:
             model = megatron_lm_prepare_model(self)
         if optimizer is not None:
             optimizer = megatron_lm_prepare_optimizer(self, model)
         if scheduler is not None:
             scheduler = megatron_lm_prepare_scheduler(self, optimizer, scheduler)
-
         if model is not None:
             model = MegatronEngine(self, model, optimizer, scheduler)
         if optimizer is not None:
             optimizer = MegatronLMOptimizerWrapper(optimizer)
         if scheduler is not None:
             scheduler = MegatronLMSchedulerWrapper(scheduler, optimizer)
-
         for i in range(len(result)):
             if isinstance(result[i], torch.nn.Module):
                 result[i] = model
@@ -1565,7 +1342,6 @@ class Accelerator:
                 "You can't use same `Accelerator()` instance with multiple models when using Megatron-LM"
             )
         return tuple(result)
-
     def _prepare_ipex(self, *args):
         if not is_ipex_available():
             raise ImportError(
@@ -1574,7 +1350,6 @@ class Accelerator:
             )
         else:
             import intel_extension_for_pytorch as ipex
-
         model = None
         optimizer = None
         result = [obj for obj in args]
@@ -1598,7 +1373,6 @@ class Accelerator:
             elif isinstance(result[i], (torch.optim.Optimizer)):
                 result[i] = optimizer
         return tuple(result)
-
     def _prepare_msamp(self, *args):
         if not is_msamp_available():
             raise ImportError(
@@ -1607,7 +1381,6 @@ class Accelerator:
             )
         else:
             import msamp
-
         model, optimizer = None, None
         num_models, num_optimizers = 0, 0
         result = [obj for obj in args]
@@ -1634,14 +1407,12 @@ class Accelerator:
             elif isinstance(result[i], (torch.optim.Optimizer)):
                 result[i] = optimizer
         return tuple(result)
-
     def prepare_data_loader(
         self, data_loader: torch.utils.data.DataLoader, device_placement=None, slice_fn_for_dispatch=None
     ):
         """
         Prepares a PyTorch DataLoader for training in any distributed setup. It is recommended to use
         [`Accelerator.prepare`] instead.
-
         Args:
             data_loader (`torch.utils.data.DataLoader`):
                 A vanilla PyTorch DataLoader to prepare
@@ -1652,13 +1423,10 @@ class Accelerator:
                 If passed, this function will be used to slice tensors across `num_processes`. Will default to
                 [`~utils.slice_tensors`]. This argument is used only when `dispatch_batches` is set to `True` and will
                 be ignored otherwise.
-
         Example:
-
         ```python
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> data_loader = torch.utils.data.DataLoader(...)
         >>> data_loader = accelerator.prepare_data_loader(data_loader, device_placement=True)
@@ -1685,24 +1453,19 @@ class Accelerator:
         )
         self._dataloaders.append(prepared_data_loader)
         return prepared_data_loader
-
     def prepare_optimizer(self, optimizer: torch.optim.Optimizer, device_placement=None):
         """
         Prepares a PyTorch Optimizer for training in any distributed setup. It is recommended to use
         [`Accelerator.prepare`] instead.
-
         Args:
             optimizer (`torch.optim.Optimizer`):
                 A vanilla PyTorch optimizer to prepare
             device_placement (`bool`, *optional*):
                 Whether or not to place the optimizer on the proper device. Will default to `self.device_placement`.
-
         Example:
-
         ```python
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> optimizer = torch.optim.Adam(...)
         >>> optimizer = accelerator.prepare_optimizer(optimizer, device_placement=True)
@@ -1718,22 +1481,17 @@ class Accelerator:
         optimizer = AcceleratedOptimizer(optimizer, device_placement=device_placement, scaler=self.scaler)
         self._optimizers.append(optimizer)
         return optimizer
-
     def prepare_scheduler(self, scheduler: LRScheduler):
         """
         Prepares a PyTorch Scheduler for training in any distributed setup. It is recommended to use
         [`Accelerator.prepare`] instead.
-
         Args:
             scheduler (`torch.optim.lr_scheduler.LRScheduler`):
                 A vanilla PyTorch scheduler to prepare
-
         Example:
-
         ```python
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> optimizer = torch.optim.Adam(...)
         >>> scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
@@ -1759,19 +1517,14 @@ class Accelerator:
         )
         self._schedulers.append(scheduler)
         return scheduler
-
     def backward(self, loss, **kwargs):
         """
         Scales the gradients in accordance to the `GradientAccumulationPlugin` and calls the correct `backward()` based
         on the configuration.
-
         Should be used in lieu of `loss.backward()`.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(gradient_accumulation_steps=2)
         >>> outputs = model(inputs)
         >>> loss = loss_fn(outputs, labels)
@@ -1789,20 +1542,15 @@ class Accelerator:
             self.scaler.scale(loss).backward(**kwargs)
         else:
             loss.backward(**kwargs)
-
     def set_trigger(self):
         """
         Sets the internal trigger tensor to 1 on the current process. A latter check should follow using this which
         will check across all processes.
-
         Note:
             Does not require `wait_for_everyone()`
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume later in the training script
         >>> # `should_do_breakpoint` is a custom function to monitor when to break,
@@ -1815,20 +1563,15 @@ class Accelerator:
         ```
         """
         self.flag_tensor = torch.tensor(1, device=self.device)
-
     def check_trigger(self):
         """
         Checks if the internal trigger tensor has been set to 1 in any of the processes. If so, will return `True` and
         reset the trigger tensor to 0.
-
         Note:
             Does not require `wait_for_everyone()`
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume later in the training script
         >>> # `should_do_breakpoint` is a custom function to monitor when to break,
@@ -1848,23 +1591,17 @@ class Accelerator:
             self.flag_tensor = torch.tensor(0, device=self.device)
             return True
         return False
-
     def unscale_gradients(self, optimizer=None):
         """
         Unscale the gradients in mixed precision training with AMP. This is a noop in all other settings.
-
         Likely should be called through [`Accelerator.clip_grad_norm_`] or [`Accelerator.clip_grad_value_`]
-
         Args:
             optimizer (`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 [`~Accelerator.prepare`].
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model, optimizer = accelerator.prepare(model, optimizer)
         >>> outputs = model(inputs)
@@ -1887,22 +1624,16 @@ class Accelerator:
                     gradients = xm._fetch_gradients(opt)
                     self.reduce(gradients, scale=1.0 / self.num_processes)
                 self.scaler.unscale_(opt)
-
     def clip_grad_norm_(self, parameters, max_norm, norm_type=2):
         """
         Should be used in place of `torch.nn.utils.clip_grad_norm_`.
-
         Returns:
             `torch.Tensor`: Total norm of the parameter gradients (viewed as a single vector).
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(gradient_accumulation_steps=2)
         >>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
-
         >>> for input, target in dataloader:
         ...     optimizer.zero_grad()
         ...     output = model(input)
@@ -1925,19 +1656,14 @@ class Accelerator:
             return None
         self.unscale_gradients()
         return torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=norm_type)
-
     def clip_grad_value_(self, parameters, clip_value):
         """
         Should be used in place of `torch.nn.utils.clip_grad_value_`.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(gradient_accumulation_steps=2)
         >>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
-
         >>> for input, target in dataloader:
         ...     optimizer.zero_grad()
         ...     output = model(input)
@@ -1952,30 +1678,23 @@ class Accelerator:
             raise Exception("DeepSpeed and FSDP  do not support `clip_grad_value_`. Use `clip_grad_norm_` instead.")
         self.unscale_gradients()
         torch.nn.utils.clip_grad_value_(parameters, clip_value)
-
     def gather(self, tensor):
         """
         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.
-
         Args:
             tensor (`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.
-
         Example:
-
         ```python
         >>> # Assuming four processes
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> process_tensor = torch.tensor([accelerator.process_index])
         >>> gathered_tensor = accelerator.gather(process_tensor)
@@ -1984,23 +1703,18 @@ class Accelerator:
         ```
         """
         return gather(tensor)
-
     def gather_for_metrics(self, input_data):
         """
         Gathers `input_data` and potentially drops duplicates in the last batch if on a distributed system. Should be
         used for gathering the inputs and targets for metric calculation.
-
         Args:
             input (`torch.Tensor`, `object`, a nested tuple/list/dictionary of `torch.Tensor`, or a nested tuple/list/dictionary of `object`):
                 The tensors or objects for calculating metrics across all processes
-
         Example:
-
         ```python
         >>> # Assuming two processes, with a batch size of 5 on a dataset with 9 samples
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> dataloader = torch.utils.data.DataLoader(range(9), batch_size=5)
         >>> dataloader = accelerator.prepare(dataloader)
@@ -2015,12 +1729,10 @@ class Accelerator:
             all_tensors = True
         except TypeError:
             all_tensors = False
-
         if not all_tensors:
             data = gather_object(input_data)
         else:
             data = self.gather(input_data)
-
         try:
             if self.gradient_state.end_of_dataloader:
                 # at the end of a dataloader, `gather_for_metrics` regresses to
@@ -2034,7 +1746,6 @@ class Accelerator:
                     # Last batch needs to be truncated on distributed systems as it contains additional samples
                     def _adjust_samples(tensor):
                         return tensor[: self.gradient_state.remainder]
-
                     return recursively_apply(_adjust_samples, data)
                 else:  # remainder is 0
                     # no remainder even though at end of dataloader, so nothing to do.
@@ -2045,14 +1756,11 @@ class Accelerator:
         except Exception:
             # Dataset had no length or raised an error
             return data
-
     def reduce(self, tensor, reduction="sum", scale=1.0):
         """
         Reduce the values in *tensor* across all processes based on *reduction*.
-
         Note:
             All processes get the reduced value.
-
         Args:
             tensor (`torch.Tensor`, or a nested tuple/list/dictionary of `torch.Tensor`):
                 The tensors to reduce across all processes.
@@ -2060,18 +1768,14 @@ class Accelerator:
                 A reduction type, can be one of 'sum', 'mean', or 'none'. If 'none', will not perform any operation.
             scale (`float`, *optional*, defaults to 1.0):
                 A default scaling value to be applied after the reduce, only valied on XLA.
-
         Returns:
             `torch.Tensor`, or a nested tuple/list/dictionary of `torch.Tensor`:
                 The reduced tensor(s).
-
         Example:
-
         ```python
         >>> # Assuming two processes
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> process_tensor = torch.arange(accelerator.num_processes) + 1 + (2 * accelerator.process_index)
         >>> process_tensor = process_tensor.to(accelerator.device)
@@ -2081,12 +1785,10 @@ class Accelerator:
         ```
         """
         return reduce(tensor, reduction, scale)
-
     def pad_across_processes(self, tensor, dim=0, pad_index=0, pad_first=False):
         """
         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.
-
         Args:
             tensor (nested list/tuple/dictionary of `torch.Tensor`):
                 The data to gather.
@@ -2096,18 +1798,14 @@ class Accelerator:
                 The value with which to pad.
             pad_first (`bool`, *optional*, defaults to `False`):
                 Whether to pad at the beginning or the end.
-
         Returns:
             `torch.Tensor`, or a nested tuple/list/dictionary of `torch.Tensor`:
                 The padded tensor(s).
-
         Example:
-
         ```python
         >>> # Assuming two processes, with the first processes having a tensor of size 1 and the second of size 2
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> process_tensor = torch.arange(accelerator.process_index + 1).to(accelerator.device)
         >>> padded_tensor = accelerator.pad_across_processes(process_tensor)
@@ -2116,52 +1814,41 @@ class Accelerator:
         ```
         """
         return pad_across_processes(tensor, dim=dim, pad_index=pad_index, pad_first=pad_first)
-
     def unwrap_model(self, model, keep_fp32_wrapper: bool = True):
         """
         Unwraps the `model` from the additional layer possible added by [`~Accelerator.prepare`]. Useful before saving
         the model.
-
         Args:
             model (`torch.nn.Module`):
                 The model to unwrap.
             keep_fp32_wrapper (`bool`, *optional*, defaults to `True`):
                 Whether to not remove the mixed precision hook if it was added.
-
         Returns:
             `torch.nn.Module`: The unwrapped model.
-
         Example:
-
         ```python
         >>> # Assuming two GPU processes
         >>> from torch.nn.parallel import DistributedDataParallel
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model = accelerator.prepare(MyModel())
         >>> print(model.__class__.__name__)
         DistributedDataParallel
-
         >>> model = accelerator.unwrap_model(model)
         >>> print(model.__class__.__name__)
         MyModel
         ```
         """
         return extract_model_from_parallel(model, keep_fp32_wrapper)
-
     def wait_for_everyone(self):
         """
         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.
-
         Example:
-
         ```python
         >>> # Assuming two GPU processes
         >>> import time
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> if accelerator.is_main_process:
         ...     time.sleep(2)
@@ -2173,12 +1860,10 @@ class Accelerator:
         ```
         """
         wait_for_everyone()
-
     @on_main_process
     def init_trackers(self, project_name: str, config: dict | None = None, init_kwargs: dict | None = {}):
         """
         Initializes a run for all trackers stored in `self.log_with`, potentially with starting configurations
-
         Args:
             project_name (`str`):
                 The name of the project. All trackers will save their data based on this
@@ -2190,12 +1875,9 @@ class Accelerator:
                 ```python
                 {"wandb": {"tags": ["tag_a", "tag_b"]}}
                 ```
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(log_with="tensorboard")
         >>> accelerator.init_trackers(
         ...     project_name="my_project",
@@ -2220,26 +1902,20 @@ class Accelerator:
         if config is not None:
             for tracker in self.trackers:
                 tracker.store_init_configuration(config)
-
     def get_tracker(self, name: str, unwrap: bool = False):
         """
         Returns a `tracker` from `self.trackers` based on `name` on the main process only.
-
         Args:
             name (`str`):
                 The name of a tracker, corresponding to the `.name` property.
             unwrap (`bool`):
                 Whether to return the internal tracking mechanism or to return the wrapped tracker instead
                 (recommended).
-
         Returns:
             `GeneralTracker`: The tracker corresponding to `name` if it exists.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(log_with="tensorboard")
         >>> accelerator.init_trackers("my_project")
         >>> tensorboard_tracker = accelerator.get_tracker("tensorboard")
@@ -2252,12 +1928,10 @@ class Accelerator:
             raise ValueError(f"{name} is not an available tracker stored inside the `Accelerator`.")
         # Handle tracker only made on main process
         return GeneralTracker(_blank=True)
-
     @on_main_process
     def log(self, values: dict, step: int | None = None, log_kwargs: dict | None = {}):
         """
         Logs `values` to all stored trackers in `self.trackers` on the main process only.
-
         Args:
             values (`dict`):
                 Values should be a dictionary-like object containing only types `int`, `float`, or `str`.
@@ -2269,12 +1943,9 @@ class Accelerator:
                 ```python
                 {"wandb": {"tags": ["tag_a", "tag_b"]}}
                 ```
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(log_with="tensorboard")
         >>> accelerator.init_trackers("my_project")
         >>> accelerator.log({"loss": 0.5, "accuracy": 0.9})
@@ -2282,18 +1953,14 @@ class Accelerator:
         """
         for tracker in self.trackers:
             tracker.log(values, step=step, **log_kwargs.get(tracker.name, {}))
-
     @on_main_process
     def end_training(self):
         """
         Runs any special end training behaviors, such as stopping trackers on the main process only. Should always be
         called at the end of your script if using experiment tracking.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(log_with="tensorboard")
         >>> accelerator.init_trackers("my_project")
         >>> # Do training
@@ -2302,25 +1969,19 @@ class Accelerator:
         """
         for tracker in self.trackers:
             tracker.finish()
-
     def save(self, obj, f, safe_serialization=False):
         """
         Save the object passed to disk once per machine. Use in place of `torch.save`.
-
         Args:
             obj (`object`): The object to save.
             f (`str` or `os.PathLike`): Where to save the content of `obj`.
             safe_serialization (`bool`, *optional*, defaults to `False`): Whether to save `obj` using `safetensors`
-
         Note:
             If `save_on_each_node` was passed in as a `ProjectConfiguration`, will save the object once per node,
             rather than only once on the main node.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> arr = [0, 1, 2, 3]
         >>> accelerator.save(arr, "array.pkl")
@@ -2332,7 +1993,6 @@ class Accelerator:
             save_on_each_node=self.project_configuration.save_on_each_node,
             safe_serialization=safe_serialization,
         )
-
     def save_model(
         self,
         model: torch.nn.Module,
@@ -2342,7 +2002,6 @@ class Accelerator:
     ):
         """
         Save a model so that it can be re-loaded using load_checkpoint_in_model
-
         Arguments:
             model: (`torch.nn.Module`):
                 Model to be saved. The model can be wrapped or unwraped.
@@ -2351,22 +2010,15 @@ class Accelerator:
             max_shard_size (`int` or `str`, *optional*, defaults to `"10GB"`):
                 The maximum size for a checkpoint before being sharded. Checkpoints shard will then be each of size
                 lower than this size. If expressed as a string, needs to be digits followed by a unit (like `"5MB"`).
-
                 <Tip warning={true}>
-
                 If a single weight of the model is bigger than `max_shard_size`, it will be in its own checkpoint shard
                 which will be bigger than `max_shard_size`.
-
                 </Tip>
-
             safe_serialization (`bool`, *optional*, defaults to `True`):
                 Whether to save the model using `safetensors` or the traditional PyTorch way (that uses `pickle`).
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model = ...
         >>> accelerator.save_model(model, save_directory)
@@ -2375,9 +2027,7 @@ class Accelerator:
         if os.path.isfile(save_directory):
             logger.error(f"Provided path ({save_directory}) should be a directory, not a file")
             return
-
         os.makedirs(save_directory, exist_ok=True)
-
         # get the state_dict of the model
         if any(
             [
@@ -2391,25 +2041,20 @@ class Accelerator:
             if any(param.device == torch.device("meta") for param in model.parameters()):
                 raise RuntimeError("You can't save the model since some parameters are on the meta device.")
             state_dict = self.get_state_dict(model)
-
         if safe_serialization:
             state_dict = clean_state_dict_for_safetensors(state_dict)
         weights_name = SAFE_WEIGHTS_NAME if safe_serialization else WEIGHTS_NAME
-
         # Shard the model if it is too big.
         shards, index = shard_checkpoint(state_dict, max_shard_size=max_shard_size, weights_name=weights_name)
-
         # Clean the folder from a previous save
         for filename in os.listdir(save_directory):
             full_filename = os.path.join(save_directory, filename)
             # If we have a shard file that is not going to be replaced, we delete it, but only from the main process
             # in distributed settings to avoid race conditions.
             weights_no_suffix = weights_name.replace(".bin", "")
-
             # make sure that file to be deleted matches format of sharded file, e.g. pytorch_model-00001-of-00005
             filename_no_suffix = filename.replace(".bin", "")
             reg = re.compile(r"(.*?)-\d{5}-of-\d{5}")
-
             if (
                 filename.startswith(weights_no_suffix)
                 and os.path.isfile(full_filename)
@@ -2418,11 +2063,9 @@ class Accelerator:
                 and PartialState().is_main_process
             ):
                 os.remove(full_filename)
-
         # Save the model
         for shard_file, shard in shards.items():
             self.save(shard, os.path.join(save_directory, shard_file), safe_serialization=safe_serialization)
-
         if index is None:
             path_to_weights = os.path.join(save_directory, WEIGHTS_NAME)
             logger.info(f"Model weights saved in {path_to_weights}")
@@ -2438,31 +2081,22 @@ class Accelerator:
                 f"split in {len(shards)} checkpoint shards. You can find where each parameters has been saved in the "
                 f"index located at {save_index_file}."
             )
-
     def register_save_state_pre_hook(self, hook: Callable[..., None]) -> hooks.RemovableHandle:
         """
         Registers a pre hook to be run before `save_checkpoint` is called in [`Accelerator.save_state`].
-
         Args:
             hook (`Callable`):
                 A function to be called in [`Accelerator.save_state`] before `save_checkpoint`.
-
         The hook should have the following signature:
-
         `hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None`
-
         The `models` argument are the models as saved in the accelerator state under `accelerator._models`, `weigths`
         argument are the state dicts of the `models`, and the `input_dir` argument is the `input_dir` argument passed
         to [`Accelerator.load_state`].
-
         <Tip>
-
         Should only be used in conjunction with [`Accelerator.register_load_state_pre_hook`]. Can be useful to save
         configurations in addition to model weights. Can also be used to overwrite model saving with a customized
         method. In this case, make sure to remove already loaded weights from the weights list.
-
         </Tip>
-
         Returns:
             `torch.utils.hooks.RemovableHandle`: a handle that can be used to remove the added hook by calling
             `handle.remove()`
@@ -2470,25 +2104,18 @@ class Accelerator:
         handle = hooks.RemovableHandle(self._save_model_state_pre_hook)
         self._save_model_state_pre_hook[handle.id] = hook
         return handle
-
     def save_state(self, output_dir: str = None, safe_serialization: bool = True, **save_model_func_kwargs):
         """
         Saves the current states of the model, optimizer, scaler, RNG generators, and registered objects to a folder.
-
         If a `ProjectConfiguration` was passed to the `Accelerator` object with `automatic_checkpoint_naming` enabled
         then checkpoints will be saved to `self.project_dir/checkpoints`. If the number of current saves is greater
         than `total_limit` then the oldest save is deleted. Each checkpoint is saved in seperate folders named
         `checkpoint_<iteration>`.
-
         Otherwise they are just saved to `output_dir`.
-
         <Tip>
-
         Should only be used when wanting to save a checkpoint during training and restoring the state in the same
         environment.
-
         </Tip>
-
         Args:
             output_dir (`str` or `os.PathLike`):
                 The name of the folder to save all relevant weights and states.
@@ -2497,12 +2124,9 @@ class Accelerator:
             save_model_func_kwargs (`dict`, *optional*):
                 Additional keyword arguments for saving model which can be passed to the underlying save function, such
                 as optional arguments for DeepSpeed's `save_checkpoint` function.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model, optimizer, lr_scheduler = ...
         >>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
@@ -2519,10 +2143,8 @@ class Accelerator:
                 and (len(folders) + 1 > self.project_configuration.total_limit)
                 and self.is_main_process
             ):
-
                 def _inner(folder):
                     return list(map(int, re.findall(r"[\/]?([0-9]+)(?=[^\/]*$)", folder)))[0]
-
                 folders.sort(key=_inner)
                 logger.warning(
                     f"Deleting {len(folders) + 1 - self.project_configuration.total_limit} checkpoints to make room for new checkpoint."
@@ -2537,11 +2159,9 @@ class Accelerator:
             self.wait_for_everyone()
         os.makedirs(output_dir, exist_ok=True)
         logger.info(f"Saving current state to {output_dir}")
-
         if self.distributed_type == DistributedType.TPU:
             # Finish running the previous step before checkpointing
             xm.mark_step()
-
         # Save the models taking care of FSDP and DeepSpeed nuances
         weights = []
         for i, model in enumerate(self._models):
@@ -2560,7 +2180,6 @@ class Accelerator:
                 logger.info(f"Megatron-LM Model , Optimizer and Scheduler saved to output dir {output_dir}")
             else:
                 weights.append(self.get_state_dict(model, unwrap=False))
-
         # Save the optimizers taking care of FSDP and DeepSpeed nuances
         optimizers = []
         if self.distributed_type == DistributedType.FSDP:
@@ -2570,7 +2189,6 @@ class Accelerator:
                 logger.info(f"FSDP Optimizer saved to output dir {output_dir}")
         elif self.distributed_type not in [DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM]:
             optimizers = self._optimizers
-
         # Save the lr schedulers taking care of DeepSpeed nuances
         schedulers = []
         if self.distributed_type == DistributedType.DEEPSPEED:
@@ -2580,15 +2198,12 @@ class Accelerator:
                 schedulers.append(scheduler)
         elif self.distributed_type not in [DistributedType.MEGATRON_LM]:
             schedulers = self._schedulers
-
         # Save the samplers of the dataloaders
         dataloaders = self._dataloaders
-
         # Call model loading hooks that might have been registered with
         # accelerator.register_model_state_hook
         for hook in self._save_model_state_pre_hook.values():
             hook(self._models, weights, output_dir)
-
         save_location = save_accelerator_state(
             output_dir,
             weights,
@@ -2604,30 +2219,21 @@ class Accelerator:
             save_custom_state(obj, output_dir, i, save_on_each_node=self.project_configuration.save_on_each_node)
         self.project_configuration.iteration += 1
         return save_location
-
     def register_load_state_pre_hook(self, hook: Callable[..., None]) -> hooks.RemovableHandle:
         """
         Registers a pre hook to be run before [`load_checkpoint`] is called in [`Accelerator.load_state`].
-
         Args:
             hook (`Callable`):
                 A function to be called in [`Accelerator.load_state`] before `load_checkpoint`.
-
         The hook should have the following signature:
-
         `hook(models: list[torch.nn.Module], input_dir: str) -> None`
-
         The `models` argument are the models as saved in the accelerator state under `accelerator._models`, and the
         `input_dir` argument is the `input_dir` argument passed to [`Accelerator.load_state`].
-
         <Tip>
-
         Should only be used in conjunction with [`Accelerator.register_save_state_pre_hook`]. Can be useful to load
         configurations in addition to model weights. Can also be used to overwrite model loading with a customized
         method. In this case, make sure to remove already loaded models from the models list.
-
         </Tip>
-
         Returns:
             `torch.utils.hooks.RemovableHandle`: a handle that can be used to remove the added hook by calling
             `handle.remove()`
@@ -2635,18 +2241,13 @@ class Accelerator:
         handle = hooks.RemovableHandle(self._load_model_state_pre_hook)
         self._load_model_state_pre_hook[handle.id] = hook
         return handle
-
     def load_state(self, input_dir: str = None, **load_model_func_kwargs):
         """
         Loads the current states of the model, optimizer, scaler, RNG generators, and registered objects.
-
         <Tip>
-
         Should only be used in conjunction with [`Accelerator.save_state`]. If a file is not registered for
         checkpointing, it will not be loaded if stored in the directory.
-
         </Tip>
-
         Args:
             input_dir (`str` or `os.PathLike`):
                 The name of the folder all relevant weights and states were saved in. Can be `None` if
@@ -2655,12 +2256,9 @@ class Accelerator:
                 Additional keyword arguments for loading model which can be passed to the underlying load function,
                 such as optional arguments for DeepSpeed's `load_checkpoint` function or a `map_location` to load the
                 model and optimizer on.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model, optimizer, lr_scheduler = ...
         >>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
@@ -2676,16 +2274,13 @@ class Accelerator:
             # Pick up from automatic checkpoint naming
             input_dir = os.path.join(self.project_dir, "checkpoints")
             folders = [os.path.join(input_dir, folder) for folder in os.listdir(input_dir)]
-
             def _inner(folder):
                 return list(map(int, re.findall(r"[\/]?([0-9]+)(?=[^\/]*$)", folder)))[0]
-
             folders.sort(key=_inner)
             input_dir = folders[-1]
         else:
             raise ValueError("No input_dir provided and automatic checkpoint naming is disabled.")
         logger.info(f"Loading states from {input_dir}")
-
         # Load the models taking care of FSDP and DeepSpeed nuances
         models = []
         for i, model in enumerate(self._models):
@@ -2704,7 +2299,6 @@ class Accelerator:
                 logger.info(f"Megatron-LM Model , Optimizer and Scheduler loaded from input dir {input_dir}")
             else:
                 models.append(model)
-
         # Load the optimizers taking care of FSDP and DeepSpeed nuances
         optimizers = []
         if self.distributed_type == DistributedType.FSDP:
@@ -2714,7 +2308,6 @@ class Accelerator:
                 logger.info(f"FSDP Optimizer loaded from input dir {input_dir}")
         elif self.distributed_type not in [DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM]:
             optimizers = self._optimizers
-
         # Load the lr schedulers taking care of DeepSpeed nuances
         schedulers = []
         if self.distributed_type == DistributedType.DEEPSPEED:
@@ -2724,14 +2317,11 @@ class Accelerator:
                 schedulers.append(scheduler)
         elif self.distributed_type not in [DistributedType.MEGATRON_LM]:
             schedulers = self._schedulers
-
         dataloaders = self._dataloaders
-
         # Call model loading hooks that might have been registered with
         # accelerator.register_model_state_hook
         for hook in self._load_model_state_pre_hook.values():
             hook(models, input_dir)
-
         map_location = load_model_func_kwargs.pop("map_location", None)
         if map_location is None:
             if self.num_processes > 1 and self.distributed_type in (
@@ -2741,7 +2331,6 @@ class Accelerator:
                 map_location = "on_device"
             else:
                 map_location = "cpu"
-
         load_accelerator_state(
             input_dir,
             models,
@@ -2767,17 +2356,13 @@ class Accelerator:
             logger.info(f"Loading in {len(custom_checkpoints)} custom states")
             for index, obj in enumerate(self._custom_objects):
                 load_custom_state(obj, input_dir, index)
-
     def free_memory(self):
         """
         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. Also will reset `Accelerator.step` to 0.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model, optimizer, scheduler = ...
         >>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
@@ -2792,17 +2377,13 @@ class Accelerator:
         self.deepspeed_engine_wrapped = None
         self.step = 0
         release_memory()
-
     def clear(self):
         """
         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.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> model, optimizer, scheduler = ...
         >>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
@@ -2811,7 +2392,6 @@ class Accelerator:
         ```
         """
         self.free_memory()
-
     def _get_named_parameters(self, *args):
         named_parameters = {}
         for obj in args:
@@ -2819,7 +2399,6 @@ class Accelerator:
                 obj = extract_model_from_parallel(obj)
                 named_parameters.update({n: p for n, p in obj.named_parameters()})
         return named_parameters
-
     def _get_devices(self, *args):
         model_device = None
         optimizer_device = None
@@ -2836,27 +2415,21 @@ class Accelerator:
                         optimizer_device = param_group["params"][0].device
                         break
         return (model_device, optimizer_device)
-
     def get_state_dict(self, model, unwrap=True):
         """
         Returns the state dictionary of a model sent through [`Accelerator.prepare`] potentially without full
         precision.
-
         Args:
             model (`torch.nn.Module`):
                 A PyTorch model sent through [`Accelerator.prepare`]
             unwrap (`bool`, *optional*, defaults to `True`):
                 Whether to return the original underlying state_dict of `model` or to return the wrapped state_dict
-
         Returns:
             `dict`: The state dictionary of the model potentially without full precision.
-
         Example:
-
         ```python
         >>> import torch
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> net = torch.nn.Linear(2, 2)
         >>> net = accelerator.prepare(net)
@@ -2876,12 +2449,10 @@ class Accelerator:
                     )
             else:
                 from deepspeed.checkpoint.utils import clone_tensors_for_torch_save
-
                 state_dict = clone_tensors_for_torch_save(self.unwrap_model(model).state_dict())
         elif self.distributed_type == DistributedType.FSDP:
             from torch.distributed.fsdp import FullStateDictConfig, StateDictType
             from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
-
             full_state_dict_config = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
             with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_state_dict_config):
                 state_dict = model.state_dict()
@@ -2889,27 +2460,18 @@ class Accelerator:
             if unwrap:
                 model = self.unwrap_model(model)
             state_dict = model.state_dict()
-
         return state_dict
-
     def register_for_checkpointing(self, *objects):
         """
         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.
-
         <Tip>
-
         Every `object` must have a `load_state_dict` and `state_dict` function to be stored.
-
         </Tip>
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> # Assume `CustomObject` has a `state_dict` and `load_state_dict` function.
         >>> obj = CustomObject()
@@ -2927,21 +2489,16 @@ class Accelerator:
                 err += f"\n\t- Item at index {index}, `{get_pretty_name(obj)}`"
             raise ValueError(err)
         self._custom_objects.extend(objects)
-
     @contextmanager
     def autocast(self, cache_enabled: bool = False, autocast_handler: AutocastKwargs = None):
         """
         Will apply automatic mixed-precision inside the block inside this context manager, if it is enabled. Nothing
         different will happen otherwise.
-
         A different `autocast_handler` can be passed in to override the one set in the `Accelerator` object. This is
         useful in blocks under `autocast` where you want to revert to fp32.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator(mixed_precision="fp16")
         >>> with accelerator.autocast():
         ...     train()
@@ -2963,7 +2520,6 @@ class Accelerator:
         autocast_context.__enter__()
         yield
         autocast_context.__exit__(*sys.exc_info())
-
     @property
     def optimizer_step_was_skipped(self):
         """
@@ -2974,20 +2530,15 @@ class Accelerator:
             if optimizer.step_was_skipped:
                 return True
         return False
-
     def skip_first_batches(self, dataloader, num_batches: int = 0):
         """
         Creates a new `torch.utils.data.DataLoader` that will efficiently skip the first `num_batches`.
-
         Args:
             dataloader (`torch.utils.data.DataLoader`): The data loader in which to skip batches.
             num_batches (`int`, *optional*, defaults to 0): The number of batches to skip
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
         >>> skipped_dataloader = accelerator.skip_first_batches(dataloader, num_batches=2)
@@ -2998,7 +2549,6 @@ class Accelerator:
         ...     loss = loss_func(output, target)
         ...     accelerator.backward(loss)
         ...     optimizer.step()
-
         >>> # subsequent epochs
         >>> for input, target in dataloader:
         ...     optimizer.zero_grad()
@@ -3006,11 +2556,9 @@ class Accelerator:
         ```
         """
         return skip_first_batches(dataloader, num_batches=num_batches)
-
     def __deepcopy__(self, memo):
         logger.info("Deep copying the `Accelerator` object, note that this will point to the same original object.")
         return self
-
     def verify_device_map(self, model: torch.nn.Module) -> bool:
         """
         Verifies that `model` has not been prepared with big model inference with a device-map resembling `auto`.
@@ -3019,5 +2567,4 @@ class Accelerator:
         for m in model.modules():
             if hasattr(m, "hf_device_map") and len(m.hf_device_map) > 1:
                 return True
-
         return False

src/big_modeling.py

@@ -1,86 +1,66 @@
 logger = logging.getLogger(__name__)
-
-
 @contextmanager
 def init_empty_weights(include_buffers: bool = None):
     """
     A context manager under which models are initialized with all parameters on the meta device, therefore creating an
     empty model. Useful when just initializing the model would blow the available RAM.
-
     Args:
         include_buffers (`bool`, *optional*):
             Whether or not to also put all buffers on the meta device while initializing.
-
     Example:
-
     ```python
     import torch.nn as nn
     from accelerate import init_empty_weights
-
     # Initialize a model with 100 billions parameters in no time and without using any RAM.
     with init_empty_weights():
         tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])
     ```
-
     <Tip warning={true}>
-
     Any model created under this context manager has no weights. As such you can't do something like
     `model.to(some_device)` with it. To load weights inside your empty model, see [`load_checkpoint_and_dispatch`].
-
     </Tip>
     """
     if include_buffers is None:
         include_buffers = parse_flag_from_env("ACCELERATE_INIT_INCLUDE_BUFFERS", False)
     with init_on_device(torch.device("meta"), include_buffers=include_buffers) as f:
         yield f
-
-
 @contextmanager
 def init_on_device(device: torch.device, include_buffers: bool = None):
     """
     A context manager under which models are initialized with all parameters on the specified device.
-
     Args:
         device (`torch.device`):
             Device to initialize all parameters on.
         include_buffers (`bool`, *optional*):
             Whether or not to also put all buffers on the meta device while initializing.
-
     Example:
-
     ```python
     import torch.nn as nn
     from accelerate import init_on_device
-
     with init_on_device(device=torch.device("cuda")):
         tst = nn.Liner(100, 100)  # on `cuda` device
     ```
     """
     if include_buffers is None:
         include_buffers = parse_flag_from_env("ACCELERATE_INIT_INCLUDE_BUFFERS", False)
-
     # TODO(shingjan): remove the torch version check once older versions are deprecated
     if is_torch_version(">=", "2.0") and include_buffers:
         with device:
             yield
         return
-
     old_register_parameter = nn.Module.register_parameter
     if include_buffers:
         old_register_buffer = nn.Module.register_buffer
-
     def register_empty_parameter(module, name, param):
         old_register_parameter(module, name, param)
         if param is not None:
             param_cls = type(module._parameters[name])
             kwargs = module._parameters[name].__dict__
             module._parameters[name] = param_cls(module._parameters[name].to(device), **kwargs)
-
     def register_empty_buffer(module, name, buffer, persistent=True):
         old_register_buffer(module, name, buffer, persistent=persistent)
         if buffer is not None:
             module._buffers[name] = module._buffers[name].to(device)
-
     # Patch tensor creation
     if include_buffers:
         tensor_constructors_to_patch = {
@@ -89,14 +69,11 @@ def init_on_device(device: torch.device, include_buffers: bool = None):
         }
     else:
         tensor_constructors_to_patch = {}
-
     def patch_tensor_constructor(fn):
         def wrapper(*args, **kwargs):
             kwargs["device"] = device
             return fn(*args, **kwargs)
-
         return wrapper
-
     try:
         nn.Module.register_parameter = register_empty_parameter
         if include_buffers:
@@ -110,8 +87,6 @@ def init_on_device(device: torch.device, include_buffers: bool = None):
             nn.Module.register_buffer = old_register_buffer
         for torch_function_name, old_torch_function in tensor_constructors_to_patch.items():
             setattr(torch, torch_function_name, old_torch_function)
-
-
 def cpu_offload(
     model: nn.Module,
     execution_device: Optional[torch.device] = None,
@@ -123,7 +98,6 @@ def cpu_offload(
     Activates full CPU offload for a model. As a result, all parameters of the model will be offloaded and only one
     copy of the state dict of the model will be kept. During the forward pass, parameters will be extracted from that
     state dict and put on the execution device passed as they are needed, then offloaded again.
-
     Args:
         model (`torch.nn.Module`):
             The model to offload.
@@ -144,7 +118,6 @@ def cpu_offload(
         execution_device = next(iter(model.parameters())).device
     if state_dict is None:
         state_dict = {n: p.to("cpu") for n, p in model.state_dict().items()}
-
     add_hook_to_module(model, AlignDevicesHook(io_same_device=True), append=True)
     attach_align_device_hook(
         model,
@@ -154,10 +127,7 @@ def cpu_offload(
         weights_map=state_dict,
         preload_module_classes=preload_module_classes,
     )
-
     return model
-
-
 def cpu_offload_with_hook(
     model: torch.nn.Module,
     execution_device: Optional[Union[int, str, torch.device]] = None,
@@ -167,7 +137,6 @@ def cpu_offload_with_hook(
     Offloads a model on the CPU and puts it back to an execution device when executed. The difference with
     [`cpu_offload`] is that the model stays on the execution device after the forward and is only offloaded again when
     the `offload` method of the returned `hook` is called. Useful for pipelines running a model in a loop.
-
     Args:
         model (`torch.nn.Module`):
             The model to offload.
@@ -177,21 +146,17 @@ def cpu_offload_with_hook(
         prev_module_hook (`UserCpuOffloadHook`, *optional*):
             The hook sent back by this function for a previous model in the pipeline you are running. If passed, its
             offload method will be called just before the forward of the model to which this hook is attached.
-
     Example:
-
     ```py
     model_1, hook_1 = cpu_offload_with_hook(model_1, cuda_device)
     model_2, hook_2 = cpu_offload_with_hook(model_2, cuda_device, prev_module_hook=hook_1)
     model_3, hook_3 = cpu_offload_with_hook(model_3, cuda_device, prev_module_hook=hook_2)
-
     hid_1 = model_1(input)
     for i in range(50):
         # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
         hid_2 = model_2(hid_1)
     # model2 is offloaded to the CPU just before this forward.
     hid_3 = model_3(hid_3)
-
     # For model3, you need to manually call the hook offload method.
     hook_3.offload()
     ```
@@ -200,8 +165,6 @@ def cpu_offload_with_hook(
     add_hook_to_module(model, hook, append=True)
     user_hook = UserCpuOffloadHook(model, hook)
     return model, user_hook
-
-
 def disk_offload(
     model: nn.Module,
     offload_dir: Union[str, os.PathLike],
@@ -213,7 +176,6 @@ def disk_offload(
     Activates full disk offload for a model. As a result, all parameters of the model will be offloaded as
     memory-mapped array in a given folder. During the forward pass, parameters will be accessed from that folder and
     put on the execution device passed as they are needed, then offloaded again.
-
     Args:
         model (`torch.nn.Module`): The model to offload.
         offload_dir (`str` or `os.PathLike`):
@@ -234,7 +196,6 @@ def disk_offload(
     if execution_device is None:
         execution_device = next(iter(model.parameters())).device
     weights_map = OffloadedWeightsLoader(save_folder=offload_dir)
-
     add_hook_to_module(model, AlignDevicesHook(io_same_device=True), append=True)
     attach_align_device_hook(
         model,
@@ -244,10 +205,7 @@ def disk_offload(
         weights_map=weights_map,
         preload_module_classes=preload_module_classes,
     )
-
     return model
-
-
 def dispatch_model(
     model: nn.Module,
     device_map: Dict[str, Union[str, int, torch.device]],
@@ -263,7 +221,6 @@ def dispatch_model(
     """
     Dispatches a model according to a given device map. Layers of the model might be spread across GPUs, offloaded on
     the CPU or even the disk.
-
     Args:
         model (`torch.nn.Module`):
             The model to dispatch.
@@ -295,12 +252,10 @@ def dispatch_model(
     """
     # Error early if the device map is incomplete.
     check_device_map(model, device_map)
-
     # for backward compatibility
     is_bnb_quantized = (
         getattr(model, "is_quantized", False) or getattr(model, "is_loaded_in_8bit", False)
     ) and getattr(model, "quantization_method", "bitsandbytes") == "bitsandbytes"
-
     # We attach hooks if the device_map has at least 2 different devices or if
     # force_hooks is set to `True`. Otherwise, the model in already loaded
     # in the unique device and the user can decide where to dispatch the model.
@@ -311,12 +266,10 @@ def dispatch_model(
                 main_device = "cpu"
             else:
                 main_device = [d for d in device_map.values() if d not in ["cpu", "disk"]][0]
-
         if main_device != "cpu":
             cpu_modules = [name for name, device in device_map.items() if device == "cpu"]
             if state_dict is None and len(cpu_modules) > 0:
                 state_dict = extract_submodules_state_dict(model.state_dict(), cpu_modules)
-
         disk_modules = [name for name, device in device_map.items() if device == "disk"]
         if offload_dir is None and offload_index is None and len(disk_modules) > 0:
             raise ValueError(
@@ -330,7 +283,6 @@ def dispatch_model(
         ):
             disk_state_dict = extract_submodules_state_dict(model.state_dict(), disk_modules)
             offload_state_dict(offload_dir, disk_state_dict)
-
         execution_device = {
             name: main_device if device in ["cpu", "disk"] else device for name, device in device_map.items()
         }
@@ -345,7 +297,6 @@ def dispatch_model(
             )
         else:
             weights_map = None
-
         tied_params = find_tied_parameters(model)
         attach_align_device_hook_on_blocks(
             model,
@@ -356,7 +307,6 @@ def dispatch_model(
             skip_keys=skip_keys,
             preload_module_classes=preload_module_classes,
         )
-
         # warn if there is any params on the meta device
         offloaded_devices_str = " and ".join(
             [device for device in set(device_map.values()) if device in ("cpu", "disk")]
@@ -365,10 +315,8 @@ def dispatch_model(
             logging.warning(
                 f"Some parameters are on the meta device device because they were offloaded to the {offloaded_devices_str}."
             )
-
         # Attaching the hook may break tied weights, so we retie them
         retie_parameters(model, tied_params)
-
         # add warning to cuda and to method
         def add_warning(fn, model):
             @wraps(fn)
@@ -378,15 +326,12 @@ def dispatch_model(
                     if param.device == torch.device("meta"):
                         raise RuntimeError("You can't move a model that has some modules offloaded to cpu or disk.")
                 return fn(*args, **kwargs)
-
             return wrapper
-
         model.to = add_warning(model.to, model)
         if is_npu_available():
             model.npu = add_warning(model.npu, model)
         else:
             model.cuda = add_warning(model.cuda, model)
-
     else:
         device = list(device_map.values())[0]
         # `torch.Tensor.to(<int num>)` is not supported by `torch_npu` (see this [issue](https://github.com/Ascend/pytorch/issues/16)).
@@ -400,8 +345,6 @@ def dispatch_model(
             )
     model.hf_device_map = device_map
     return model
-
-
 def load_checkpoint_and_dispatch(
     model: nn.Module,
     checkpoint: Union[str, os.PathLike],
@@ -419,7 +362,6 @@ def load_checkpoint_and_dispatch(
     """
     Loads a (potentially sharded) checkpoint inside a model, potentially sending weights to a given device as they are
     loaded and adds the various hooks that will make this model run properly (even if split across devices).
-
     Args:
         model (`torch.nn.Module`): The model in which we want to load a checkpoint.
         checkpoint (`str` or `os.PathLike`):
@@ -430,7 +372,6 @@ def load_checkpoint_and_dispatch(
         device_map (`Dict[str, Union[int, str, torch.device]]`, *optional*):
             A map that specifies where each submodule should go. It doesn't need to be refined to each parameter/buffer
             name, once a given module name is inside, every submodule of it will be sent to the same device.
-
             To have Accelerate compute the most optimized `device_map` automatically, set `device_map="auto"`. For more
             information about each option see [here](big_modeling#designing-a-device-map).
         max_memory (`Dict`, *optional*):
@@ -460,23 +401,18 @@ def load_checkpoint_and_dispatch(
         force_hooks (`bool`, *optional*, defaults to `False`):
             Whether or not to force device hooks to be attached to the model even if all layers are dispatched to a
             single device.
-
     Example:
-
     ```python
     >>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
     >>> from huggingface_hub import hf_hub_download
     >>> from transformers import AutoConfig, AutoModelForCausalLM
-
     >>> # Download the Weights
     >>> checkpoint = "EleutherAI/gpt-j-6B"
     >>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")
-
     >>> # Create a model and initialize it with empty weights
     >>> config = AutoConfig.from_pretrained(checkpoint)
     >>> with init_empty_weights():
     ...     model = AutoModelForCausalLM.from_config(config)
-
     >>> # Load the checkpoint and dispatch it to the right devices
     >>> model = load_checkpoint_and_dispatch(
     ...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]

src/checkpointing.py

@@ -1,6 +1,4 @@
 logger = get_logger(__name__)
-
-
 def save_accelerator_state(
     output_dir: str,
     model_states: List[dict],
@@ -14,14 +12,10 @@ def save_accelerator_state(
 ):
     """
     Saves the current states of the models, optimizers, scaler, and RNG generators to a given directory.
-
     <Tip>
-
     If `safe_serialization` is `True`, models will be saved with `safetensors` while the rest are saved using native
     `pickle`.
-
     </Tip>
-
     Args:
         output_dir (`str` or `os.PathLike`):
             The name of the folder to save all relevant weights and states.
@@ -71,14 +65,11 @@ def save_accelerator_state(
         output_sampler_file = output_dir.joinpath(sampler_name)
         # Only save if we have our custom sampler
         from .data_loader import IterableDatasetShard, SeedableRandomSampler
-
         if isinstance(dataloader.dataset, IterableDatasetShard):
             sampler = dataloader.sampler.sampler
-
             if isinstance(sampler, SeedableRandomSampler):
                 save(sampler, output_sampler_file, save_on_each_node=save_on_each_node, safe_serialization=False)
         logger.info(f"Sampler state for dataloader {i} saved in {output_sampler_file}")
-
     # GradScaler state
     if scaler is not None:
         state = scaler.state_dict()
@@ -101,8 +92,6 @@ def save_accelerator_state(
     torch.save(states, output_states_file)
     logger.info(f"Random states saved in {output_states_file}")
     return output_dir
-
-
 def load_accelerator_state(
     input_dir,
     models,
@@ -116,7 +105,6 @@ def load_accelerator_state(
 ):
     """
     Loads states of the models, optimizers, scaler, and RNG generators from a given directory.
-
     Args:
         input_dir (`str` or `os.PathLike`):
             The name of the folder to load all relevant weights and states.
@@ -143,7 +131,6 @@ def load_accelerator_state(
         map_location = "cpu"
     elif map_location == "on_device":
         map_location = PartialState().device
-
     input_dir = Path(input_dir)
     # Model states
     for i, model in enumerate(models):
@@ -157,7 +144,6 @@ def load_accelerator_state(
             state_dict = torch.load(input_model_file, map_location=map_location)
         models[i].load_state_dict(state_dict, **load_model_func_kwargs)
     logger.info("All model weights loaded successfully")
-
     # Optimizer states
     for i, opt in enumerate(optimizers):
         optimizer_name = f"{OPTIMIZER_NAME}.bin" if i == 0 else f"{OPTIMIZER_NAME}_{i}.bin"
@@ -165,33 +151,27 @@ def load_accelerator_state(
         optimizer_state = torch.load(input_optimizer_file, map_location=map_location)
         optimizers[i].load_state_dict(optimizer_state)
     logger.info("All optimizer states loaded successfully")
-
     # Scheduler states
     for i, scheduler in enumerate(schedulers):
         scheduler_name = f"{SCHEDULER_NAME}.bin" if i == 0 else f"{SCHEDULER_NAME}_{i}.bin"
         input_scheduler_file = input_dir.joinpath(scheduler_name)
         scheduler.load_state_dict(torch.load(input_scheduler_file))
     logger.info("All scheduler states loaded successfully")
-
     for i, dataloader in enumerate(dataloaders):
         sampler_name = f"{SAMPLER_NAME}.bin" if i == 0 else f"{SAMPLER_NAME}_{i}.bin"
         input_sampler_file = input_dir.joinpath(sampler_name)
         # Only load if we have our custom sampler
         from .data_loader import IterableDatasetShard, SeedableRandomSampler
-
         if isinstance(dataloader.dataset, IterableDatasetShard):
             sampler = dataloader.sampler.sampler
-
             if isinstance(sampler, SeedableRandomSampler):
                 dataloader.sampler.sampler = torch.load(input_sampler_file)
     logger.info("All dataloader sampler states loaded successfully")
-
     # GradScaler state
     if scaler is not None:
         input_scaler_file = input_dir.joinpath(SCALER_NAME)
         scaler.load_state_dict(torch.load(input_scaler_file))
         logger.info("GradScaler state loaded successfully")
-
     # Random states
     try:
         states = torch.load(input_dir.joinpath(f"{RNG_STATE_NAME}_{process_index}.pkl"))
@@ -207,8 +187,6 @@ def load_accelerator_state(
         logger.info("All random states loaded successfully")
     except Exception:
         logger.info("Could not load random states")
-
-
 def save_custom_state(obj, path, index: int = 0, save_on_each_node: bool = False):
     """
     Saves the state of `obj` to `{path}/custom_checkpoint_{index}.pkl`
@@ -217,8 +195,6 @@ def save_custom_state(obj, path, index: int = 0, save_on_each_node: bool = False
     save_location = Path(path) / f"custom_checkpoint_{index}.pkl"
     logger.info(f"Saving the state of {get_pretty_name(obj)} to {save_location}")
     save(obj.state_dict(), save_location, save_on_each_node=save_on_each_node)
-
-
 def load_custom_state(obj, path, index: int = 0):
     """
     Loads the state of `obj` at `{path}/custom_checkpoint_{index}.pkl`

src/commands/accelerate_cli.py

@@ -2,7 +2,6 @@
 def main():
     parser = ArgumentParser("Accelerate CLI tool", usage="accelerate <command> [<args>]", allow_abbrev=False)
     subparsers = parser.add_subparsers(help="accelerate command helpers")
-
     # Register commands
     get_config_parser(subparsers=subparsers)
     estimate_command_parser(subparsers=subparsers)
@@ -10,17 +9,12 @@ def main():
     launch_command_parser(subparsers=subparsers)
     tpu_command_parser(subparsers=subparsers)
     test_command_parser(subparsers=subparsers)
-
     # Let's go
     args = parser.parse_args()
-
     if not hasattr(args, "func"):
         parser.print_help()
         exit(1)
-
     # Run
     args.func(args)
-
-
 if __name__ == "__main__":
     main()

src/commands/config/cluster.py

@@ -5,7 +5,6 @@ def get_cluster_input():
         ["No distributed training", "multi-CPU", "multi-XPU", "multi-GPU", "multi-NPU", "TPU"],
         _convert_distributed_mode,
     )
-
     machine_rank = 0
     num_machines = 1
     num_processes = 1
@@ -15,7 +14,6 @@ def get_cluster_input():
     rdzv_backend = "static"
     same_network = True
     debug = False
-
     if distributed_type in [
         DistributedType.MULTI_GPU,
         DistributedType.MULTI_NPU,
@@ -56,7 +54,6 @@ def get_cluster_input():
             default=False,
             error_message="Please enter yes or no.",
         )
-
     if distributed_type == DistributedType.NO:
         use_cpu = _ask_field(
             "Do you want to run your training on CPU only (even if a GPU / Apple Silicon / Ascend NPU device is available)? [yes/NO]:",
@@ -68,7 +65,6 @@ def get_cluster_input():
         use_cpu = True
     else:
         use_cpu = False
-
     ipex_config = {}
     if use_cpu:
         ipex_config["ipex"] = _ask_field(
@@ -88,7 +84,6 @@ def get_cluster_input():
             default=False,
             error_message="Please enter yes or no.",
         )
-
     dynamo_config = {}
     use_dynamo = _ask_field(
         "Do you wish to optimize your script with torch dynamo?[yes/NO]:",
@@ -110,7 +105,6 @@ def get_cluster_input():
             default=False,
             error_message="Please enter yes or no.",
         )
-
         if use_custom_options:
             dynamo_config[prefix + "mode"] = _ask_options(
                 "Which mode do you want to use?",
@@ -130,7 +124,6 @@ def get_cluster_input():
                 default=False,
                 error_message="Please enter yes or no.",
             )
-
     use_mps = not use_cpu and is_mps_available()
     deepspeed_config = {}
     if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.NO] and not use_mps:
@@ -145,7 +138,6 @@ def get_cluster_input():
             assert (
                 is_deepspeed_available()
             ), "DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source"
-
         if distributed_type == DistributedType.DEEPSPEED:
             use_deepspeed_config = _ask_field(
                 "Do you want to specify a json file to a DeepSpeed config? [yes/NO]: ",
@@ -166,7 +158,6 @@ def get_cluster_input():
                     int,
                     default=2,
                 )
-
                 deepspeed_devices = ["none", "cpu", "nvme"]
                 if deepspeed_config["zero_stage"] >= 2:
                     deepspeed_config["offload_optimizer_device"] = _ask_options(
@@ -223,7 +214,6 @@ def get_cluster_input():
                         "When `zero3_init_flag` is set, it requires Transformers to be installed. "
                         "Please run `pip3 install transformers`."
                     )
-
             if num_machines > 1:
                 launcher_query = "Which Type of launcher do you want to use?"
                 deepspeed_config["deepspeed_multinode_launcher"] = _ask_options(
@@ -231,7 +221,6 @@ def get_cluster_input():
                     DEEPSPEED_MULTINODE_LAUNCHERS,
                     lambda x: DEEPSPEED_MULTINODE_LAUNCHERS[int(x)],
                 )
-
                 if deepspeed_config["deepspeed_multinode_launcher"] != DEEPSPEED_MULTINODE_LAUNCHERS[1]:
                     deepspeed_config["deepspeed_hostfile"] = _ask_field(
                         "DeepSpeed configures multi-node compute resources with hostfile. "
@@ -241,7 +230,6 @@ def get_cluster_input():
                         "Please specify the location of hostfile: ",
                         str,
                     )
-
                     is_exclusion_filter = _ask_field(
                         "Do you want to specify exclusion filter string? [yes/NO]: ",
                         _convert_yes_no_to_bool,
@@ -253,7 +241,6 @@ def get_cluster_input():
                             "DeepSpeed exclusion filter string: ",
                             str,
                         )
-
                     is_inclusion_filter = _ask_field(
                         "Do you want to specify inclusion filter string? [yes/NO]: ",
                         _convert_yes_no_to_bool,
@@ -265,7 +252,6 @@ def get_cluster_input():
                             "DeepSpeed inclusion filter string: ",
                             str,
                         )
-
     fsdp_config = {}
     if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_XPU]:
         use_fsdp = _ask_field(
@@ -354,7 +340,6 @@ def get_cluster_input():
                     default=True,
                     error_message="Please enter yes or no.",
                 )
-
     megatron_lm_config = {}
     if distributed_type in [DistributedType.MULTI_GPU]:
         use_megatron_lm = _ask_field(
@@ -380,7 +365,6 @@ def get_cluster_input():
                     default=True,
                     error_message="Please enter yes or no.",
                 )
-
             megatron_lm_config[prefix + "pp_degree"] = _ask_field(
                 "What is the Pipeline Parallelism degree/size? [1]:",
                 int,
@@ -394,14 +378,12 @@ def get_cluster_input():
                     default=1,
                     error_message="Please enter an integer.",
                 )
-
             megatron_lm_config[prefix + "recompute_activations"] = _ask_field(
                 "Do you want to enable selective activation recomputation? [YES/no]: ",
                 _convert_yes_no_to_bool,
                 default=True,
                 error_message="Please enter yes or no.",
             )
-
             megatron_lm_config[prefix + "use_distributed_optimizer"] = _ask_field(
                 "Do you want to use distributed optimizer "
                 "which shards optimizer state and gradients across data parallel ranks? [YES/no]: ",
@@ -409,7 +391,6 @@ def get_cluster_input():
                 default=True,
                 error_message="Please enter yes or no.",
             )
-
             megatron_lm_config[prefix + "gradient_clipping"] = _ask_field(
                 "What is the gradient clipping value based on global L2 Norm (0 to disable)? [1.0]: ",
                 float,
@@ -425,7 +406,6 @@ def get_cluster_input():
     tpu_zone = None
     tpu_use_sudo = False
     tpu_use_cluster = False
-
     if distributed_type in [
         DistributedType.MULTI_CPU,
         DistributedType.MULTI_XPU,
@@ -453,12 +433,10 @@ def get_cluster_input():
         )
     else:
         num_processes = 1
-
     if (distributed_type == DistributedType.MULTI_GPU) and (num_machines == 1) and (num_processes == 1):
         raise ValueError(
             f"Specified distributed type {distributed_type} but only using 1 GPU on a single machine. Please select `No distributed training` for the type of machine you are using."
         )
-
     if (
         distributed_type
         in [
@@ -478,7 +456,6 @@ def get_cluster_input():
             f"What {machine_type} (by id) should be used for training on this machine as a comma-seperated list? [all]:",
             default="all",
         )
-
     if distributed_type == DistributedType.TPU:
         mixed_precision = "no"
         main_training_function = _ask_field(
@@ -553,7 +530,6 @@ def get_cluster_input():
                 "What environment variables do you wish to set in each pod, seperated by a comma: ",
                 default="",
             ).split(",")
-
     else:
         main_training_function = "main"
         if distributed_type == DistributedType.DEEPSPEED and use_deepspeed_config:
@@ -564,17 +540,14 @@ def get_cluster_input():
                 ["no", "fp16", "bf16", "fp8"],
                 _convert_mixed_precision,
             )
-
     if use_dynamo and mixed_precision == "no" and not use_cpu:
         print(
             "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."
         )
-
     if distributed_type == DistributedType.TPU and mixed_precision == "bf16":
         tpu_downcast_bf16 = _ask_field(
             "Should `torch.float` be cast as `bfloat16` and `torch.double` remain `float32` on TPUs?", default="no"
         )
-
     return ClusterConfig(
         compute_environment=ComputeEnvironment.LOCAL_MACHINE,
         distributed_type=distributed_type,

src/commands/config/config.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 description = "Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine"
-
-
 def get_user_input():
     compute_environment = _ask_options(
         "In which compute environment are you running?",
@@ -13,14 +11,11 @@ def get_user_input():
     else:
         config = get_cluster_input()
     return config
-
-
 def config_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("config", description=description)
     else:
         parser = argparse.ArgumentParser("Accelerate config command", description=description)
-
     parser.add_argument(
         "--config_file",
         default=None,
@@ -31,12 +26,9 @@ def config_command_parser(subparsers=None):
             "with 'huggingface'."
         ),
     )
-
     if subparsers is not None:
         parser.set_defaults(func=config_command)
     return parser
-
-
 def config_command(args):
     config = get_user_input()
     if args.config_file is not None:
@@ -45,19 +37,14 @@ def config_command(args):
         if not os.path.isdir(cache_dir):
             os.makedirs(cache_dir)
         config_file = default_yaml_config_file
-
     if config_file.endswith(".json"):
         config.to_json_file(config_file)
     else:
         config.to_yaml_file(config_file)
     print(f"accelerate configuration saved at {config_file}")
-
-
 def main():
     parser = config_command_parser()
     args = parser.parse_args()
     config_command(args)
-
-
 if __name__ == "__main__":
     main()

src/commands/config/config_args.py

@@ -5,14 +5,11 @@ hf_cache_home = os.path.expanduser(
 cache_dir = os.path.join(hf_cache_home, "accelerate")
 default_json_config_file = os.path.join(cache_dir, "default_config.yaml")
 default_yaml_config_file = os.path.join(cache_dir, "default_config.yaml")
-
 # For backward compatibility: the default config is the json one if it's the only existing file.
 if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):
     default_config_file = default_yaml_config_file
 else:
     default_config_file = default_json_config_file
-
-
 def load_config_from_file(config_file):
     if config_file is not None:
         if not os.path.isfile(config_file):
@@ -43,8 +40,6 @@ def load_config_from_file(config_file):
             else:
                 config_class = SageMakerConfig
             return config_class.from_yaml_file(yaml_file=config_file)
-
-
 @dataclass
 class BaseConfig:
     compute_environment: ComputeEnvironment
@@ -52,7 +47,6 @@ class BaseConfig:
     mixed_precision: str
     use_cpu: bool
     debug: bool
-
     def to_dict(self):
         result = self.__dict__
         # For serialization, it's best to convert Enums to strings (or their underlying value type).
@@ -63,7 +57,6 @@ class BaseConfig:
                 result[key] = None
         result = {k: v for k, v in result.items() if v is not None}
         return result
-
     @classmethod
     def from_json_file(cls, json_file=None):
         json_file = default_json_config_file if json_file is None else json_file
@@ -88,14 +81,11 @@ class BaseConfig:
                 f"The config file at {json_file} had unknown keys ({extra_keys}), please try upgrading your `accelerate`"
                 " version or fix (and potentially remove) these keys from your config file."
             )
-
         return cls(**config_dict)
-
     def to_json_file(self, json_file):
         with open(json_file, "w", encoding="utf-8") as f:
             content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
             f.write(content)
-
     @classmethod
     def from_yaml_file(cls, yaml_file=None):
         yaml_file = default_yaml_config_file if yaml_file is None else yaml_file
@@ -123,11 +113,9 @@ class BaseConfig:
                 " version or fix (and potentially remove) these keys from your config file."
             )
         return cls(**config_dict)
-
     def to_yaml_file(self, yaml_file):
         with open(yaml_file, "w", encoding="utf-8") as f:
             yaml.safe_dump(self.to_dict(), f)
-
     def __post_init__(self):
         if isinstance(self.compute_environment, str):
             self.compute_environment = ComputeEnvironment(self.compute_environment)
@@ -138,8 +126,6 @@ class BaseConfig:
                 self.distributed_type = DistributedType(self.distributed_type)
         if self.dynamo_config is None:
             self.dynamo_config = {}
-
-
 @dataclass
 class ClusterConfig(BaseConfig):
     num_processes: int
@@ -151,7 +137,6 @@ class ClusterConfig(BaseConfig):
     rdzv_backend: Optional[str] = "static"
     same_network: Optional[bool] = False
     main_training_function: str = "main"
-
     # args for deepspeed_plugin
     deepspeed_config: dict = None
     # args for fsdp
@@ -162,7 +147,6 @@ class ClusterConfig(BaseConfig):
     ipex_config: dict = None
     # args for TPU
     downcast_bf16: bool = False
-
     # args for TPU pods
     tpu_name: str = None
     tpu_zone: str = None
@@ -172,10 +156,8 @@ class ClusterConfig(BaseConfig):
     commands: List[str] = None
     tpu_vm: List[str] = None
     tpu_env: List[str] = None
-
     # args for dynamo
     dynamo_config: dict = None
-
     def __post_init__(self):
         if self.deepspeed_config is None:
             self.deepspeed_config = {}
@@ -186,8 +168,6 @@ class ClusterConfig(BaseConfig):
         if self.ipex_config is None:
             self.ipex_config = {}
         return super().__post_init__()
-
-
 @dataclass
 class SageMakerConfig(BaseConfig):
     ec2_instance_type: str

src/commands/config/config_utils.py

@@ -13,8 +13,6 @@ DYNAMO_BACKENDS = [
     "IPEX",
     "TVM",
 ]
-
-
 def _ask_field(input_text, convert_value=None, default=None, error_message=None):
     ask_again = True
     while ask_again:
@@ -26,43 +24,27 @@ def _ask_field(input_text, convert_value=None, default=None, error_message=None)
         except Exception:
             if error_message is not None:
                 print(error_message)
-
-
 def _ask_options(input_text, options=[], convert_value=None, default=0):
     menu = BulletMenu(input_text, options)
     result = menu.run(default_choice=default)
     return convert_value(result) if convert_value is not None else result
-
-
 def _convert_compute_environment(value):
     value = int(value)
     return ComputeEnvironment(["LOCAL_MACHINE", "AMAZON_SAGEMAKER"][value])
-
-
 def _convert_distributed_mode(value):
     value = int(value)
     return DistributedType(["NO", "MULTI_CPU", "MULTI_XPU", "MULTI_GPU", "MULTI_NPU", "TPU"][value])
-
-
 def _convert_dynamo_backend(value):
     value = int(value)
     return DynamoBackend(DYNAMO_BACKENDS[value]).value
-
-
 def _convert_mixed_precision(value):
     value = int(value)
     return PrecisionType(["no", "fp16", "bf16", "fp8"][value])
-
-
 def _convert_sagemaker_distributed_mode(value):
     value = int(value)
     return SageMakerDistributedType(["NO", "DATA_PARALLEL", "MODEL_PARALLEL"][value])
-
-
 def _convert_yes_no_to_bool(value):
     return {"yes": True, "no": False}[value.lower()]
-
-
 class SubcommandHelpFormatter(argparse.RawDescriptionHelpFormatter):
     """
     A custom formatter that will remove the usage line from the help message for subcommands.

src/commands/config/default.py

@@ -1,12 +1,9 @@
 #!/usr/bin/env python
 description = "Create a default config file for Accelerate with only a few flags set."
-
-
 def write_basic_config(mixed_precision="no", save_location: str = default_json_config_file, use_xpu: bool = False):
     """
     Creates and saves a basic cluster config to be used on a local machine with potentially multiple GPUs. Will also
     set CPU if it is a CPU-only machine.
-
     Args:
         mixed_precision (`str`, *optional*, defaults to "no"):
             Mixed Precision to use. Should be one of "no", "fp16", or "bf16"
@@ -66,8 +63,6 @@ def write_basic_config(mixed_precision="no", save_location: str = default_json_c
     config = ClusterConfig(**config)
     config.to_json_file(path)
     return path
-
-
 def default_command_parser(parser, parents):
     parser = parser.add_parser("default", parents=parents, help=description, formatter_class=SubcommandHelpFormatter)
     parser.add_argument(
@@ -81,7 +76,6 @@ def default_command_parser(parser, parents):
         ),
         dest="save_location",
     )
-
     parser.add_argument(
         "--mixed_precision",
         choices=["no", "fp16", "bf16"],
@@ -93,8 +87,6 @@ def default_command_parser(parser, parents):
     )
     parser.set_defaults(func=default_config_command)
     return parser
-
-
 def default_config_command(args):
     config_file = write_basic_config(args.mixed_precision, args.save_location)
     if config_file:

src/commands/config/sagemaker.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 def _create_iam_role_for_sagemaker(role_name):
     iam_client = boto3.client("iam")
-
     sagemaker_trust_policy = {
         "Version": "2012-10-17",
         "Statement": [
@@ -51,13 +50,9 @@ def _create_iam_role_for_sagemaker(role_name):
         )
     except iam_client.exceptions.EntityAlreadyExistsException:
         print(f"role {role_name} already exists. Using existing one")
-
-
 def _get_iam_role_arn(role_name):
     iam_client = boto3.client("iam")
     return iam_client.get_role(RoleName=role_name)["Role"]["Arn"]
-
-
 def get_sagemaker_input():
     credentials_configuration = _ask_options(
         "How do you want to authorize?",
@@ -75,13 +70,10 @@ def get_sagemaker_input():
         )
         aws_access_key_id = _ask_field("AWS Access Key ID: ")
         os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
-
         aws_secret_access_key = _ask_field("AWS Secret Access Key: ")
         os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
-
     aws_region = _ask_field("Enter your AWS Region: [us-east-1]", default="us-east-1")
     os.environ["AWS_DEFAULT_REGION"] = aws_region
-
     role_management = _ask_options(
         "Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?",
         ["Provide IAM Role name", "Create new IAM role using credentials"],
@@ -93,7 +85,6 @@ def get_sagemaker_input():
         iam_role_name = "accelerate_sagemaker_execution_role"
         print(f'Accelerate will create an iam role "{iam_role_name}" using the provided credentials')
         _create_iam_role_for_sagemaker(iam_role_name)
-
     is_custom_docker_image = _ask_field(
         "Do you want to use custom Docker image? [yes/NO]: ",
         _convert_yes_no_to_bool,
@@ -103,7 +94,6 @@ def get_sagemaker_input():
     docker_image = None
     if is_custom_docker_image:
         docker_image = _ask_field("Enter your Docker image: ", lambda x: str(x).lower())
-
     is_sagemaker_inputs_enabled = _ask_field(
         "Do you want to provide SageMaker input channels with data locations? [yes/NO]: ",
         _convert_yes_no_to_bool,
@@ -116,7 +106,6 @@ def get_sagemaker_input():
             "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): ",
             lambda x: str(x).lower(),
         )
-
     is_sagemaker_metrics_enabled = _ask_field(
         "Do you want to enable SageMaker metrics? [yes/NO]: ",
         _convert_yes_no_to_bool,
@@ -129,7 +118,6 @@ def get_sagemaker_input():
             "Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): ",
             lambda x: str(x).lower(),
         )
-
     distributed_type = _ask_options(
         "What is the distributed mode?",
         ["No distributed training", "Data parallelism"],
@@ -156,7 +144,6 @@ def get_sagemaker_input():
             default=False,
             error_message="Please enter yes or no.",
         )
-
         if use_custom_options:
             dynamo_config[prefix + "mode"] = _ask_options(
                 "Which mode do you want to use?",
@@ -184,7 +171,6 @@ def get_sagemaker_input():
     else:
         ec2_instance_query += "? [ml.p3.2xlarge]:"
         ec2_instance_type = _ask_field(ec2_instance_query, lambda x: str(x).lower(), default="ml.p3.2xlarge")
-
     debug = False
     if distributed_type != SageMakerDistributedType.NO:
         debug = _ask_field(
@@ -193,7 +179,6 @@ def get_sagemaker_input():
             default=False,
             error_message="Please enter yes or no.",
         )
-
     num_machines = 1
     if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
         num_machines = _ask_field(
@@ -201,18 +186,15 @@ def get_sagemaker_input():
             int,
             default=1,
         )
-
     mixed_precision = _ask_options(
         "Do you wish to use FP16 or BF16 (mixed precision)?",
         ["no", "fp16", "bf16", "fp8"],
         _convert_mixed_precision,
     )
-
     if use_dynamo and mixed_precision == "no":
         print(
             "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."
         )
-
     return SageMakerConfig(
         image_uri=docker_image,
         compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER,

src/commands/config/update.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 description = "Update an existing config file with the latest defaults while maintaining the old configuration."
-
-
 def update_config(args):
     """
     Update an existing config file with the latest defaults while maintaining the old configuration.
@@ -12,14 +10,11 @@ def update_config(args):
     elif not Path(config_file).exists():
         raise ValueError(f"The passed config file located at {config_file} doesn't exist.")
     config = load_config_from_file(config_file)
-
     if config_file.endswith(".json"):
         config.to_json_file(config_file)
     else:
         config.to_yaml_file(config_file)
     return config_file
-
-
 def update_command_parser(parser, parents):
     parser = parser.add_parser("update", parents=parents, help=description, formatter_class=SubcommandHelpFormatter)
     parser.add_argument(
@@ -32,11 +27,8 @@ def update_command_parser(parser, parents):
             "with 'huggingface'."
         ),
     )
-
     parser.set_defaults(func=update_config_command)
     return parser
-
-
 def update_config_command(args):
     config_file = update_config(args)
     print(f"Sucessfully updated the configuration file at {config_file}.")

src/commands/env.py

@@ -4,27 +4,21 @@ def env_command_parser(subparsers=None):
         parser = subparsers.add_parser("env")
     else:
         parser = argparse.ArgumentParser("Accelerate env command")
-
     parser.add_argument(
         "--config_file", default=None, help="The config file to use for the default values in the launching script."
     )
-
     if subparsers is not None:
         parser.set_defaults(func=env_command)
     return parser
-
-
 def env_command(args):
     pt_version = torch.__version__
     pt_cuda_available = torch.cuda.is_available()
     pt_xpu_available = is_xpu_available()
     pt_npu_available = is_npu_available()
-
     accelerate_config = "Not found"
     # Get the default from the config file.
     if args.config_file is not None or os.path.isfile(default_config_file):
         accelerate_config = load_config_from_file(args.config_file).to_dict()
-
     info = {
         "`Accelerate` version": version,
         "Platform": platform.platform(),
@@ -37,10 +31,8 @@ def env_command(args):
     }
     if pt_cuda_available:
         info["GPU type"] = torch.cuda.get_device_name()
-
     print("\nCopy-and-paste the text below in your GitHub issue\n")
     print("\n".join([f"- {prop}: {val}" for prop, val in info.items()]))
-
     print("- `Accelerate` default config:" if args.config_file is None else "- `Accelerate` config passed:")
     accelerate_config_str = (
         "\n".join([f"\t- {prop}: {val}" for prop, val in accelerate_config.items()])
@@ -48,18 +40,12 @@ def env_command(args):
         else f"\t{accelerate_config}"
     )
     print(accelerate_config_str)
-
     info["`Accelerate` configs"] = accelerate_config
-
     return info
-
-
 def main() -> int:
     parser = env_command_parser()
     args = parser.parse_args()
     env_command(args)
     return 0
-
-
 if __name__ == "__main__":
     raise SystemExit(main())

src/commands/estimate.py

@@ -7,8 +7,6 @@ def verify_on_hub(repo: str, token: str = None):
         return "gated"
     except RepositoryNotFoundError:
         return "repo"
-
-
 def check_has_model(error):
     """
     Checks what library spawned `error` when a model is not found
@@ -23,12 +21,9 @@ def check_has_model(error):
         return "transformers"
     else:
         return "unknown"
-
-
 def create_empty_model(model_name: str, library_name: str, trust_remote_code: bool = False, access_token: str = None):
     """
     Creates an empty model from its parent library on the `Hub` to calculate the overall memory consumption.
-
     Args:
         model_name (`str`):
             The model name on the Hub
@@ -41,10 +36,8 @@ def create_empty_model(model_name: str, library_name: str, trust_remote_code: bo
             execute code present on the Hub on your local machine.
         access_token (`str`, `optional`, defaults to `None`):
             The access token to use to access private or gated models on the Hub. (for use on the Gradio app)
-
     Returns:
         `torch.nn.Module`: The torch model that has been initialized on the `meta` device.
-
     """
     model_info = verify_on_hub(model_name, access_token)
     # Simplified errors
@@ -69,10 +62,8 @@ def create_empty_model(model_name: str, library_name: str, trust_remote_code: bo
                 f"To check `{model_name}`, `transformers` must be installed. Please install it via `pip install transformers`"
             )
         print(f"Loading pretrained config for `{model_name}` from `transformers`...")
-
         auto_map = model_info.config.get("auto_map", False)
         config = AutoConfig.from_pretrained(model_name, trust_remote_code=trust_remote_code)
-
         with init_empty_weights():
             # remote code could specify a specific `AutoModel` class in the `auto_map`
             constructor = AutoModel
@@ -98,8 +89,6 @@ def create_empty_model(model_name: str, library_name: str, trust_remote_code: bo
             f"Library `{library_name}` is not supported yet, please open an issue on GitHub for us to add support."
         )
     return model
-
-
 def create_ascii_table(headers: list, rows: list, title: str):
     "Creates a pretty table from a list of rows, minimal version of `tabulate`."
     sep_char, in_between = "│", "─"
@@ -108,20 +97,15 @@ def create_ascii_table(headers: list, rows: list, title: str):
         column_values = [row[i] for row in rows] + [headers[i]]
         max_column_width = max(len(value) for value in column_values)
         column_widths.append(max_column_width)
-
     formats = [f"%{column_widths[i]}s" for i in range(len(rows[0]))]
-
     pattern = f"{sep_char}{sep_char.join(formats)}{sep_char}"
     diff = 0
-
     def make_row(left_char, middle_char, right_char):
         return f"{left_char}{middle_char.join([in_between * n for n in column_widths])}{in_between * diff}{right_char}"
-
     separator = make_row("├", "┼", "┤")
     if len(title) > sum(column_widths):
         diff = abs(len(title) - len(separator))
         column_widths[-1] += diff
-
     # Update with diff
     separator = make_row("├", "┼", "┤")
     initial_rows = [
@@ -137,16 +121,12 @@ def create_ascii_table(headers: list, rows: list, title: str):
         centered_line = [t.center(column_widths[i]) for i, t in enumerate(line)]
         table += f"{pattern % tuple(centered_line)}\n"
     table += f'└{"┴".join([in_between * n for n in column_widths])}┘'
-
     return table
-
-
 def estimate_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("estimate-memory")
     else:
         parser = argparse.ArgumentParser(description="Model size estimator for fitting a model onto CUDA memory.")
-
     parser.add_argument("model_name", type=str, help="The model name on the Hugging Face Hub.")
     parser.add_argument(
         "--library_name",
@@ -169,12 +149,9 @@ def estimate_command_parser(subparsers=None):
                 should only be used for repositories you trust and in which you have read the code, as it will execute
                 code present on the Hub on your local machine.""",
     )
-
     if subparsers is not None:
         parser.set_defaults(func=estimate_command)
     return parser
-
-
 def gather_data(args):
     "Creates an empty model and gathers the data for the sizes"
     try:
@@ -188,11 +165,8 @@ def gather_data(args):
                 f"Tried to load `{args.model_name}` with `{library}` but a possible model to load was not found inside the repo."
             )
         raise e
-
     total_size, largest_layer = calculate_maximum_sizes(model)
-
     data = []
-
     for dtype in args.dtypes:
         dtype_total_size = total_size
         dtype_largest_layer = largest_layer[0]
@@ -208,27 +182,19 @@ def gather_data(args):
         dtype_training_size = dtype_total_size * 4
         data.append([dtype, dtype_largest_layer, dtype_total_size, dtype_training_size])
     return data
-
-
 def estimate_command(args):
     data = gather_data(args)
     for row in data:
         for i, item in enumerate(row):
             if isinstance(item, (int, float)):
                 row[i] = convert_bytes(item)
-
     headers = ["dtype", "Largest Layer", "Total Size", "Training using Adam"]
-
     title = f"Memory Usage for loading `{args.model_name}`"
     table = create_ascii_table(headers, data, title)
     print(table)
-
-
 def main():
     parser = estimate_command_parser()
     args = parser.parse_args()
     estimate_command(args)
-
-
 if __name__ == "__main__":
     main()

src/commands/launch.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 logger = logging.getLogger(__name__)
-
 options_to_group = {
     "--multi-gpu": "Distributed GPUs",
     "--tpu": "TPU",
@@ -8,14 +7,10 @@ options_to_group = {
     "--use_fsdp": "FSDP Arguments",
     "--use_megatron_lm": "Megatron-LM Arguments",
 }
-
-
 def clean_option(option):
     "Finds all cases of - after the first two characters and changes them to _"
     if option.startswith("--"):
         return option[:3] + option[3:].replace("-", "_")
-
-
 class _CustomHelpAction(argparse._HelpAction):
     """
     This is a custom help action that will hide all arguments that are not used in the command line when the help is
@@ -59,19 +54,14 @@ class _CustomHelpAction(argparse._HelpAction):
                 # If all arguments in the group are hidden, hide the group
                 if all([arg.help == argparse.SUPPRESS for arg in group._group_actions]):
                     parser._action_groups.remove(group)
-
         super().__call__(parser, namespace, values, option_string)
-
-
 def launch_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("launch", add_help=False, allow_abbrev=False)
     else:
         parser = argparse.ArgumentParser("Accelerate launch command", add_help=False, allow_abbrev=False)
-
     parser.register("action", "help", _CustomHelpAction)
     parser.add_argument("-h", "--help", action="help", help="Show this help message and exit.")
-
     parser.add_argument(
         "--config_file", default=None, help="The config file to use for the default values in the launching script."
     )
@@ -103,7 +93,6 @@ def launch_command_parser(subparsers=None):
         action="store_true",
         help="Whether or not this should launch a Intel PyTorch Extension (IPEX) training.",
     )
-
     # Resource selection arguments
     resource_args = parser.add_argument_group(
         "Resource Selection Arguments", "Arguments for fine-tuning how available hardware should be used."
@@ -128,7 +117,6 @@ def launch_command_parser(subparsers=None):
         default=None,
         help="The number of CPU threads per process. Can be tuned for optimal performance.",
     )
-
     # Dynamo arguments
     resource_args.add_argument(
         "--dynamo_backend",
@@ -156,7 +144,6 @@ def launch_command_parser(subparsers=None):
         action="store_true",
         help="Whether to enable dynamic shape tracing.",
     )
-
     # Training Paradigm arguments
     paradigm_args = parser.add_argument_group(
         "Training Paradigm Arguments", "Arguments for selecting which training paradigm to be used."
@@ -185,7 +172,6 @@ def launch_command_parser(subparsers=None):
         action="store_true",
         help="Whether to use IPEX plugin to speed up training on XPU specifically.",
     )
-
     # distributed GPU training arguments
     distributed_args = parser.add_argument_group("Distributed GPUs", "Arguments related to distributed GPU training.")
     distributed_args.add_argument(
@@ -260,7 +246,6 @@ def launch_command_parser(subparsers=None):
         action="store_true",
         help="Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.",
     )
-
     # TPU arguments
     tpu_args = parser.add_argument_group("TPU", "Arguments related to TPU.")
     tpu_args.add_argument(
@@ -306,7 +291,6 @@ def launch_command_parser(subparsers=None):
         action="store_true",
         help="Whether when using bf16 precision on TPUs if both float and double tensors are cast to bfloat16 or if double tensors remain as float32.",
     )
-
     # DeepSpeed arguments
     deepspeed_args = parser.add_argument_group("DeepSpeed Arguments", "Arguments related to DeepSpeed.")
     deepspeed_args.add_argument(
@@ -402,7 +386,6 @@ def launch_command_parser(subparsers=None):
         type=str,
         help="DeepSpeed multi-node launcher to use. If unspecified, will default to `pdsh`.",
     )
-
     # fsdp arguments
     fsdp_args = parser.add_argument_group("FSDP Arguments", "Arguments related to Fully Shared Data Parallelism.")
     fsdp_args.add_argument(
@@ -483,7 +466,6 @@ def launch_command_parser(subparsers=None):
         help="If True, each individually wrapped FSDP unit will broadcast module parameters from rank 0."
         " (useful only when `use_fsdp` flag is passed).",
     )
-
     # megatron_lm args
     megatron_lm_args = parser.add_argument_group("Megatron-LM Arguments", "Arguments related to Megatron-LM.")
     megatron_lm_args.add_argument(
@@ -533,7 +515,6 @@ def launch_command_parser(subparsers=None):
         help="Megatron-LM's gradient clipping value based on global L2 Norm (0 to disable). "
         "(useful only when `use_megatron_lm` flag is passed).",
     )
-
     # AWS arguments
     aws_args = parser.add_argument_group("AWS Arguments", "Arguments related to AWS.")
     aws_args.add_argument(
@@ -561,18 +542,13 @@ def launch_command_parser(subparsers=None):
             "script."
         ),
     )
-
     # Other arguments of the training scripts
     parser.add_argument("training_script_args", nargs=argparse.REMAINDER, help="Arguments of the training script.")
-
     if subparsers is not None:
         parser.set_defaults(func=launch_command)
     return parser
-
-
 def simple_launcher(args):
     cmd, current_env = prepare_simple_launcher_cmd_env(args)
-
     process = subprocess.Popen(cmd, env=current_env)
     process.wait()
     if process.returncode != 0:
@@ -580,11 +556,8 @@ def simple_launcher(args):
             raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)
         else:
             sys.exit(1)
-
-
 def multi_gpu_launcher(args):
     import torch.distributed.run as distrib_run
-
     current_env = prepare_multi_gpu_env(args)
     if not check_cuda_p2p_ib_support():
         message = "Using RTX 3090 or 4000 series which doesn't support faster communication speedups. Ensuring P2P and IB communications are disabled."
@@ -597,7 +570,6 @@ def multi_gpu_launcher(args):
             warn = True
         if warn:
             logger.warning(message)
-
     debug = getattr(args, "debug", False)
     args = _filter_args(
         args,
@@ -614,14 +586,10 @@ def multi_gpu_launcher(args):
                 console.print_exception(suppress=[__file__], show_locals=False)
             else:
                 raise
-
-
 def deepspeed_launcher(args):
     import torch.distributed.run as distrib_run
-
     if not is_deepspeed_available():
         raise ImportError("DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source.")
-
     cmd, current_env = prepare_deepspeed_cmd_env(args)
     if not check_cuda_p2p_ib_support():
         message = "Using RTX 3090 or 4000 series which doesn't support faster communication speedups. Ensuring P2P and IB communications are disabled."
@@ -634,14 +602,12 @@ def deepspeed_launcher(args):
             warn = True
         if warn:
             logger.warning(message)
-
     if args.num_machines > 1 and args.deepspeed_multinode_launcher != DEEPSPEED_MULTINODE_LAUNCHERS[1]:
         with open(".deepspeed_env", "a") as f:
             for key, value in current_env.items():
                 if ";" in value or " " in value:
                     continue
                 f.write(f"{key}={value}\n")
-
         process = subprocess.Popen(cmd, env=current_env)
         process.wait()
         if process.returncode != 0:
@@ -666,16 +632,11 @@ def deepspeed_launcher(args):
                     console.print_exception(suppress=[__file__], show_locals=False)
                 else:
                     raise
-
-
 def tpu_launcher(args):
     import torch_xla.distributed.xla_multiprocessing as xmp
-
     if args.no_python:
         raise ValueError("--no_python cannot be used with TPU launcher")
-
     args, current_env = prepare_tpu(args, {})
-
     if args.module:
         mod_name = args.training_script
     else:
@@ -683,40 +644,31 @@ def tpu_launcher(args):
         script_path = Path(args.training_script)
         sys.path.append(str(script_path.parent.resolve()))
         mod_name = script_path.stem
-
     mod = importlib.import_module(mod_name)
     if not hasattr(mod, args.main_training_function):
         raise ValueError(
             f"Your training script should have a function named {args.main_training_function}, or you should pass a "
             "different value to `--main_training_function`."
         )
-
     # Patch sys.argv
     sys.argv = [mod.__file__] + args.training_script_args
-
     main_function = getattr(mod, args.main_training_function)
     with patch_environment(**current_env):
         xmp.spawn(PrepareForLaunch(main_function), args=(), nprocs=args.num_processes)
-
-
 def tpu_pod_launcher(args):
     from torch_xla.distributed import xla_dist
-
     current_env = {}
     args, current_env = prepare_tpu(args, current_env, True)
     debug = getattr(args, "debug", False)
-
     training_script = args.training_script
     training_script_args = args.training_script_args
     new_args = _filter_args(
         args, xla_dist.get_args_parser(), ["--tpu", args.tpu_name, "--positional", "", "--restart-tpuvm-pod-server"]
     )
-
     if args.tpu_use_sudo:
         new_cmd = ["sudo"]
     else:
         new_cmd = []
-
     new_cmd += [
         "accelerate-launch",
         "--tpu",
@@ -733,7 +685,6 @@ def tpu_pod_launcher(args):
         str(args.main_training_function),
         training_script,
     ] + training_script_args
-
     new_args.positional = new_cmd
     bad_flags = ""
     for arg in vars(new_args):
@@ -756,8 +707,6 @@ def tpu_pod_launcher(args):
             console.print_exception(suppress=[__file__], show_locals=False)
         else:
             raise
-
-
 def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):
     if not is_sagemaker_available():
         raise ImportError(
@@ -767,17 +716,11 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):
         raise ValueError(
             "SageMaker requires a python training script file and cannot be used with --module or --no_python"
         )
-
     from sagemaker.huggingface import HuggingFace
-
     args, sagemaker_inputs = prepare_sagemager_args_inputs(sagemaker_config, args)
-
     huggingface_estimator = HuggingFace(**args)
-
     huggingface_estimator.fit(inputs=sagemaker_inputs)
     print(f"You can find your model data at: {huggingface_estimator.model_data}")
-
-
 def _validate_launch_command(args):
     # Sanity checks
     if sum([args.multi_gpu, args.cpu, args.tpu, args.use_deepspeed, args.use_fsdp]) > 1:
@@ -786,7 +729,6 @@ def _validate_launch_command(args):
         )
     if args.multi_gpu and (args.num_processes is not None) and (args.num_processes < 2):
         raise ValueError("You need to use at least 2 processes to use `--multi_gpu`.")
-
     defaults = None
     warned = []
     mp_from_config_flag = False
@@ -817,10 +759,8 @@ def _validate_launch_command(args):
                 args.gpu_ids = defaults.gpu_ids
             else:
                 args.gpu_ids = "all"
-
         if args.multi_gpu and args.num_machines is None:
             args.num_machines = defaults.num_machines
-
         if len(args.gpu_ids.split(",")) < 2 and (args.gpu_ids != "all") and args.multi_gpu and args.num_machines <= 1:
             raise ValueError(
                 "Less than two GPU ids were configured and tried to run on on multiple GPUs. "
@@ -844,7 +784,6 @@ def _validate_launch_command(args):
                     for k in defaults.ipex_config:
                         setattr(args, k, defaults.ipex_config[k])
                     continue
-
                 # Those args are handled separately
                 if (
                     name not in ["compute_environment", "mixed_precision", "distributed_type"]
@@ -853,7 +792,6 @@ def _validate_launch_command(args):
                     setattr(args, name, attr)
         if not args.debug:
             args.debug = defaults.debug
-
         if not args.mixed_precision:
             if defaults.mixed_precision is None:
                 args.mixed_precision = "no"
@@ -869,7 +807,6 @@ def _validate_launch_command(args):
                 native_amp = is_bf16_available(True)
             if args.mixed_precision == "bf16" and not native_amp and not (args.tpu and is_tpu_available()):
                 raise ValueError(err.format(mode="bf16", requirement="PyTorch >= 1.10 and a supported device."))
-
         # Silently set the default here
         if args.dynamo_backend is None:
             args.dynamo_backend = "no"
@@ -907,7 +844,6 @@ def _validate_launch_command(args):
             args.dynamo_backend = "no"
     if args.debug:
         logger.debug("Running script in debug mode, expect distributed operations to be slightly slower.")
-
     is_aws_env_disabled = defaults is None or (
         defaults is not None and defaults.compute_environment != ComputeEnvironment.AMAZON_SAGEMAKER
     )
@@ -923,7 +859,6 @@ def _validate_launch_command(args):
                 warned.append(
                     f"\t`--num_cpu_threads_per_process` was set to `{args.num_cpu_threads_per_process}` to improve out-of-box performance when training on CPUs"
                 )
-
     if any(warned):
         message = "The following values were not passed to `accelerate launch` and had defaults used instead:\n"
         message += "\n".join(warned)
@@ -932,8 +867,6 @@ def _validate_launch_command(args):
         )
         logger.warning(message)
     return args, defaults, mp_from_config_flag
-
-
 def launch_command(args):
     args, defaults, mp_from_config_flag = _validate_launch_command(args)
     # Use the proper launcher
@@ -958,13 +891,9 @@ def launch_command(args):
         sagemaker_launcher(defaults, args)
     else:
         simple_launcher(args)
-
-
 def main():
     parser = launch_command_parser()
     args = parser.parse_args()
     launch_command(args)
-
-
 if __name__ == "__main__":
     main()

src/commands/test.py

@@ -4,7 +4,6 @@ def test_command_parser(subparsers=None):
         parser = subparsers.add_parser("test")
     else:
         parser = argparse.ArgumentParser("Accelerate test command")
-
     parser.add_argument(
         "--config_file",
         default=None,
@@ -15,31 +14,22 @@ def test_command_parser(subparsers=None):
             "with 'huggingface'."
         ),
     )
-
     if subparsers is not None:
         parser.set_defaults(func=test_command)
     return parser
-
-
 def test_command(args):
     script_name = os.path.sep.join(__file__.split(os.path.sep)[:-2] + ["test_utils", "scripts", "test_script.py"])
-
     if args.config_file is None:
         test_args = script_name
     else:
         test_args = f"--config_file={args.config_file} {script_name}"
-
     cmd = ["accelerate-launch"] + test_args.split()
     result = execute_subprocess_async(cmd, env=os.environ.copy())
     if result.returncode == 0:
         print("Test is a success! You are ready for your distributed training!")
-
-
 def main():
     parser = test_command_parser()
     args = parser.parse_args()
     test_command(args)
-
-
 if __name__ == "__main__":
     main()

src/commands/tpu.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 _description = "Run commands across TPU VMs for initial setup before running `accelerate launch`."
-
-
 def tpu_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("tpu-config", description=_description)
@@ -57,15 +55,11 @@ def tpu_command_parser(subparsers=None):
     pod_args.add_argument(
         "--debug", action="store_true", help="If set, will print the command that would be run instead of running it."
     )
-
     if subparsers is not None:
         parser.set_defaults(func=tpu_command_launcher)
     return parser
-
-
 def tpu_command_launcher(args):
     defaults = None
-
     # Get the default from the config file if it exists.
     if args.config_file is not None or os.path.isfile(default_config_file):
         defaults = load_config_from_file(args.config_file)
@@ -83,14 +77,11 @@ def tpu_command_launcher(args):
         args.accelerate_version = "accelerate -U"
     elif isinstance(parse(args.accelerate_version), Version):
         args.accelerate_version = f"accelerate=={args.accelerate_version}"
-
     if not args.command_file and not args.command:
         raise ValueError("You must specify either a command file or a command to run on the pod.")
-
     if args.command_file:
         with open(args.command_file, "r") as f:
             args.command = [f.read().splitlines()]
-
     # To turn list of lists into list of strings
     if isinstance(args.command[0], list):
         args.command = [line for cmd in args.command for line in cmd]
@@ -100,7 +91,6 @@ def tpu_command_launcher(args):
         new_cmd += [f"pip install {args.accelerate_version}"]
     new_cmd += args.command
     args.command = "; ".join(new_cmd)
-
     # Then send it to gcloud
     # Eventually try to use google-api-core to do this instead of subprocess
     cmd = ["gcloud"]
@@ -124,10 +114,7 @@ def tpu_command_launcher(args):
         return
     subprocess.run(cmd)
     print("Successfully setup pod.")
-
-
 def main():
     parser = tpu_command_parser()
     args = parser.parse_args()
-
     tpu_command_launcher(args)

src/data_loader.py

@@ -1,5 +1,4 @@
 logger = get_logger(__name__)
-
 # kwargs of the DataLoader in min version 1.4.0.
 _PYTORCH_DATALOADER_KWARGS = {
     "batch_size": 1,
@@ -17,22 +16,16 @@ _PYTORCH_DATALOADER_KWARGS = {
     "prefetch_factor": 2,
     "persistent_workers": False,
 }
-
 # kwargs added after by version
 _PYTORCH_DATALOADER_ADDITIONAL_KWARGS = {}
-
 for v, additional_kwargs in _PYTORCH_DATALOADER_ADDITIONAL_KWARGS.items():
     if is_torch_version(">=", v):
         _PYTORCH_DATALOADER_KWARGS.update(additional_kwargs)
-
-
 class SeedableRandomSampler(RandomSampler):
     """
     Same as a random sampler, except that in `__iter__` a seed can be used.
-
     Needed specifically in distributed cases, when the random generator for each GPU needs to start from the same seed
     and be fully reproducable on multiple iterations.
-
     If a custom `generator` is passed, it will rely on its initial seed as well as the current iteration it is on
     (stored in `self.epoch`).
     """
@@ -40,7 +33,6 @@ class SeedableRandomSampler(RandomSampler):
         super().__init__(*args, **kwargs)
         self.epoch = 0
         self.seed = torch.random.initial_seed()
-
     def __iter__(self):
         if self.generator is None:
             self.generator = torch.Generator()
@@ -51,19 +43,15 @@ class SeedableRandomSampler(RandomSampler):
         self.generator.manual_seed(seed)
         yield from super().__iter__()
         self.set_epoch(self.epoch + 1)
-
     def set_epoch(self, epoch: int):
         "Sets the current iteration of the sampler."
         self.epoch = epoch
-
-
 class BatchSamplerShard(BatchSampler):
     """
     Wraps a PyTorch `BatchSampler` to generate batches for one of the processes only. Instances of this class will
     always yield a number of batches that is a round multiple of `num_processes` and that all have the same size.
     Depending on the value of the `drop_last` attribute of the batch sampler passed, it will either stop the iteration
     at the first batch that would be too small / not present on all processes or loop with indices from the beginning.
-
     Args:
         batch_sampler (`torch.utils.data.sampler.BatchSampler`):
             The batch sampler to split in several shards.
@@ -74,9 +62,7 @@ class BatchSamplerShard(BatchSampler):
         split_batches (`bool`, *optional*, defaults to `False`):
             Whether the shards should be created by splitting a batch to give a piece of it on each process, or by
             yielding different full batches on each process.
-
             On two processes with a sampler of `[[0, 1, 2, 3], [4, 5, 6, 7]]`, this will result in:
-
             - the sampler on process 0 to yield `[0, 1, 2, 3]` and the sampler on process 1 to yield `[4, 5, 6, 7]` if
               this argument is set to `False`.
             - the sampler on process 0 to yield `[0, 1]` then `[4, 5]` and the sampler on process 1 to yield `[2, 3]`
@@ -84,14 +70,10 @@ class BatchSamplerShard(BatchSampler):
         even_batches (`bool`, *optional*, defaults to `True`):
             Whether or not to loop back at the beginning of the sampler when the number of samples is not a round
             multiple of (original batch size / number of processes).
-
     <Tip warning={true}>
-
     `BatchSampler`s with varying batch sizes are not enabled by default. To enable this behaviour, set `even_batches`
     equal to `False`
-
     </Tip>"""
-
     def __init__(
         self,
         batch_sampler: BatchSampler,
@@ -117,11 +99,9 @@ class BatchSamplerShard(BatchSampler):
                 "You need to use `even_batches=False` when the batch sampler has no batch size. If you "
                 "are not calling this method directly, set `accelerator.even_batches=False` instead."
             )
-
     @property
     def total_length(self):
         return len(self.batch_sampler)
-
     def __len__(self):
         if self.split_batches:
             # Split batches does not change the length of the batch sampler
@@ -139,10 +119,8 @@ class BatchSamplerShard(BatchSampler):
         else:
             # Otherwise it depends on the process index.
             return length + 1 if self.process_index < len(self.batch_sampler) % self.num_processes else length
-
     def __iter__(self):
         return self._iter_with_split() if self.split_batches else self._iter_with_no_split()
-
     def _iter_with_split(self):
         initial_data = []
         batch_length = self.batch_sampler.batch_size // self.num_processes
@@ -152,7 +130,6 @@ class BatchSamplerShard(BatchSampler):
             if len(batch) == self.batch_size:
                 # If the batch is full, we yield the part of it this process is responsible of.
                 yield batch[batch_length * self.process_index : batch_length * (self.process_index + 1)]
-
         # If drop_last is True of the last batch was full, iteration is over, otherwise...
         if not self.drop_last and len(initial_data) > 0 and len(batch) < self.batch_size:
             if not self.even_batches:
@@ -164,7 +141,6 @@ class BatchSamplerShard(BatchSampler):
                     initial_data += initial_data
                 batch = batch + initial_data
                 yield batch[batch_length * self.process_index : batch_length * (self.process_index + 1)]
-
     def _iter_with_no_split(self):
         initial_data = []
         batch_to_yield = []
@@ -181,7 +157,6 @@ class BatchSamplerShard(BatchSampler):
             ):
                 yield batch_to_yield
                 batch_to_yield = []
-
         # If drop_last is True, iteration is over, otherwise...
         if not self.drop_last and len(initial_data) > 0:
             if not self.even_batches:
@@ -191,16 +166,13 @@ class BatchSamplerShard(BatchSampler):
                 # ... we yield the complete batch we had saved before if it has the proper length
                 if len(batch_to_yield) == self.batch_size:
                     yield batch_to_yield
-
                 # For degenerate cases where the dataset has less than num_process * batch_size samples
                 while len(initial_data) < self.num_processes * self.batch_size:
                     initial_data += initial_data
-
                 # If the last batch seen was of the proper size, it has been yielded by its process so we move to the next
                 if len(batch) == self.batch_size:
                     batch = []
                     idx += 1
-
                 # Make sure we yield a multiple of self.num_processes batches
                 cycle_index = 0
                 while idx % self.num_processes != 0 or len(batch) > 0:
@@ -211,8 +183,6 @@ class BatchSamplerShard(BatchSampler):
                     cycle_index = end_index
                     batch = []
                     idx += 1
-
-
 class IterableDatasetShard(IterableDataset):
     """
     Wraps a PyTorch `IterableDataset` to generate samples for one of the processes only. Instances of this class will
@@ -220,7 +190,6 @@ class IterableDatasetShard(IterableDataset):
     `split_batches`, this is either `batch_size` or `batch_size x num_processes`). Depending on the value of the
     `drop_last` attribute of the batch sampler passed, it will either stop the iteration at the first batch that would
     be too small or loop with indices from the beginning.
-
     Args:
         dataset (`torch.utils.data.dataset.IterableDataset`):
             The batch sampler to split in several shards.
@@ -237,9 +206,7 @@ class IterableDatasetShard(IterableDataset):
         split_batches (`bool`, *optional*, defaults to `False`):
             Whether the shards should be created by splitting a batch to give a piece of it on each process, or by
             yielding different full batches on each process.
-
             On two processes with an iterable dataset yielding of `[0, 1, 2, 3, 4, 5, 6, 7]`, this will result in:
-
             - the shard on process 0 to yield `[0, 1, 2, 3]` and the shard on process 1 to yield `[4, 5, 6, 7]` if this
               argument is set to `False`.
             - the shard on process 0 to yield `[0, 1, 4, 5]` and the sampler on process 1 to yield `[2, 3, 6, 7]` if
@@ -265,19 +232,16 @@ class IterableDatasetShard(IterableDataset):
         self.num_processes = num_processes
         self.process_index = process_index
         self.split_batches = split_batches
-
     def set_epoch(self, epoch):
         self.epoch = epoch
         if hasattr(self.dataset, "set_epoch"):
             self.dataset.set_epoch(epoch)
-
     def __len__(self):
         # We will just raise the downstream error if the underlying dataset is not sized
         if self.drop_last:
             return (len(self.dataset) // (self.batch_size * self.num_processes)) * self.batch_size
         else:
             return math.ceil(len(self.dataset) / (self.batch_size * self.num_processes)) * self.batch_size
-
     def __iter__(self):
         if (
             not hasattr(self.dataset, "set_epoch")
@@ -288,7 +252,6 @@ class IterableDatasetShard(IterableDataset):
         real_batch_size = self.batch_size if self.split_batches else (self.batch_size * self.num_processes)
         process_batch_size = (self.batch_size // self.num_processes) if self.split_batches else self.batch_size
         process_slice = range(self.process_index * process_batch_size, (self.process_index + 1) * process_batch_size)
-
         first_batch = None
         current_batch = []
         for element in self.dataset:
@@ -300,7 +263,6 @@ class IterableDatasetShard(IterableDataset):
                 if first_batch is None:
                     first_batch = current_batch.copy()
                 current_batch = []
-
         # Finished if drop_last is True, otherwise complete the last batch with elements from the beginning.
         if not self.drop_last and len(current_batch) > 0:
             if first_batch is None:
@@ -309,29 +271,22 @@ class IterableDatasetShard(IterableDataset):
                 current_batch += first_batch
             for i in process_slice:
                 yield current_batch[i]
-
-
 class DataLoaderStateMixin:
     """
     Mixin class that adds a state to a `DataLoader` to keep track of the status inside the dataloader such as at the
     end of the iteration, the number of items in the dataset in the last batch relative to the batch size, and other
     useful information that might be needed.
-
     **Available attributes:**
-
         - **end_of_dataloader** (`bool`) -- Whether at the last iteration or batch
         - **remainder** (`int`) -- The number of items that are remaining in the last batch, relative to the total
           batch size
-
     """
     def __init_subclass__(cls, **kwargs):
         cls.end_of_dataloader = False
         cls.remainder = -1
-
     def reset(self):
         self.end_of_dataloader = False
         self.remainder = -1
-
     def begin(self):
         "Prepares the gradient state for the current dataloader"
         self.reset()
@@ -340,16 +295,12 @@ class DataLoaderStateMixin:
                 length = getattr(self.dataset, "total_dataset_length", len(self.dataset))
                 self.remainder = length % self.total_batch_size
         self.gradient_state._add_dataloader(self)
-
     def end(self):
         "Cleans up the gradient state after exiting the dataloader"
         self.gradient_state._remove_dataloader(self)
-
-
 class DataLoaderShard(DataLoader, DataLoaderStateMixin):
     """
     Subclass of a PyTorch `DataLoader` that will deal with device placement and current distributed setup.
-
     Args:
         dataset (`torch.utils.data.dataset.Dataset`):
             The dataset to use to build this datalaoder.
@@ -358,7 +309,6 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
         rng_types (list of `str` or [`~utils.RNGType`]):
             The list of random number generators to synchronize at the beginning of each iteration. 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)
@@ -369,13 +319,10 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
             The number of batches to skip at the beginning.
         kwargs:
             All other keyword arguments to pass to the regular `DataLoader` initialization.
-
     **Available attributes:**
-
         - **total_batch_size** (`int`) -- Total batch size of the dataloader across all processes.
             Equal to the original batch size when `split_batches=True`; otherwise the original batch size * the total
             number of processes
-
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
     """
     def __init__(
@@ -396,12 +343,10 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
         self.gradient_state = GradientState()
         self._drop_last = _drop_last
         self.iteration = 0
-
     def __iter__(self):
         if self.rng_types is not None:
             synchronize_rng_states(self.rng_types, self.synchronized_generator)
         self.begin()
-
         self.set_epoch(self.iteration)
         dataloader_iter = super().__iter__()
         # We iterate one batch ahead to check when we are at the end
@@ -409,7 +354,6 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
             current_batch = next(dataloader_iter)
         except StopIteration:
             yield
-
         batch_index = 0
         while True:
             try:
@@ -426,10 +370,8 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
                 if batch_index >= self.skip_batches:
                     yield current_batch
                 break
-
         self.iteration += 1
         self.end()
-
     def set_epoch(self, epoch: int):
         # In case it is manually passed in, the user can set it to what they like
         if self.iteration != epoch:
@@ -440,7 +382,6 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
         # or in general HF datasets `Datasets`
         elif hasattr(self.dataset, "set_epoch"):
             self.dataset.set_epoch(epoch)
-
     @property
     def total_batch_size(self):
         batch_sampler = self.sampler if isinstance(self.sampler, BatchSampler) else self.batch_sampler
@@ -449,63 +390,47 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
             if getattr(batch_sampler, "split_batches", False)
             else (batch_sampler.batch_size * getattr(batch_sampler, "num_processes", 1))
         )
-
     @property
     def total_dataset_length(self):
         if hasattr(self.dataset, "total_length"):
             return self.dataset.total_length
         else:
             return len(self.dataset)
-
-
 if is_tpu_available(check_device=False):
     import torch_xla.distributed.parallel_loader as xpl
-
     class MpDeviceLoaderWrapper(xpl.MpDeviceLoader):
         """
         Wrapper for the xpl.MpDeviceLoader class that knows the total batch size.
-
         XLA preloading threads will all call DataLoaderShard's __iter__(). Remove rng_types from DataLoaderShard to
         prevent it from using the XLA device in the preloading threads, and synchronize the RNG once from the main
         thread only.
-
         **Available attributes:**
-
         - **total_batch_size** (`int`) -- Total batch size of the dataloader across all processes.
             Equal to the original batch size when `split_batches=True`; otherwise the original batch size * the total
             number of processes
-
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
         """
         def __init__(self, dataloader: DataLoaderShard, device: torch.device):
             super().__init__(dataloader, device)
             self._rng_types = self._loader.rng_types
             self._loader.rng_types = None
-
         def __iter__(self):
             if self._rng_types is not None:
                 synchronize_rng_states(self._rng_types, self._loader.synchronized_generator)
-
             return super().__iter__()
-
         @property
         def total_batch_size(self):
             return self._loader.total_batch_size
-
         @property
         def total_dataset_length(self):
             return self._loader.total_dataset_length
-
         @property
         def batch_sampler(self):
             return self._loader.batch_sampler
-
-
 class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
     """
     Subclass of a PyTorch `DataLoader` that will iterate and preprocess on process 0 only, then dispatch on each
     process their part of the batch.
-
     Args:
         split_batches (`bool`, *optional*, defaults to `False`):
             Whether the resulting `DataLoader` should split the batches of the original data loader across devices or
@@ -516,13 +441,10 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
             size of the `dataloader` is a round multiple of `batch_size`.
         skip_batches (`int`, *optional*, defaults to 0):
             The number of batches to skip at the beginning of an iteration.
-
     **Available attributes:**
-
         - **total_batch_size** (`int`) -- Total batch size of the dataloader across all processes.
             Equal to the original batch size when `split_batches=True`; otherwise the original batch size * the total
             number of processes
-
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
     """
     def __init__(
@@ -531,7 +453,6 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
         shuffle = False
         if is_torch_version(">=", "1.11.0"):
             from torch.utils.data.datapipes.iter.combinatorics import ShufflerIterDataPipe
-
             # We need to save the shuffling state of the DataPipe
             if isinstance(dataset, ShufflerIterDataPipe):
                 shuffle = dataset._shuffle_enabled
@@ -539,15 +460,12 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
         self.split_batches = split_batches
         if shuffle:
             torch.utils.data.graph_settings.apply_shuffle_settings(dataset, shuffle=shuffle)
-
         self.gradient_state = GradientState()
         self.state = AcceleratorState()
         self._drop_last = _drop_last
         self.skip_batches = skip_batches
-
         self.slice_fn = slice_tensors if slice_fn is None else slice_fn
         self.iteration = 0
-
     def _fetch_batches(self, iterator):
         batches, batch = None, None
         # On process 0, we gather the batch to dispatch.
@@ -584,7 +502,6 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
                     batch_info = [None, True]
                 broadcast_object_list(batch_info)
         return batch, batch_info
-
     def __iter__(self):
         self.begin()
         self.set_epoch(self.iteration)
@@ -603,14 +520,12 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
         batch_index = 0
         while not stop_iteration:
             batch, batch_info = next_batch, next_batch_info
-
             if self.state.process_index != 0:
                 # Initialize tensors on other processes than process 0.
                 batch = initialize_tensors(batch_info[0])
             batch = send_to_device(batch, self.state.device)
             # Broadcast the batch before splitting it.
             batch = broadcast(batch, from_process=0)
-
             if not self._drop_last and first_batch is None:
                 # We keep at least num processes elements of the first batch to be able to complete the last batch
                 first_batch = self.slice_fn(
@@ -619,15 +534,12 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
                     process_index=self.state.process_index,
                     num_processes=self.state.num_processes,
                 )
-
             if batch is None:
                 raise ValueError(
                     f"Batch does not contain any data (`{batch}`). At the end of all iterable data available before expected stop iteration."
                 )
-
             observed_batch_size = find_batch_size(batch)
             batch_size = observed_batch_size // self.state.num_processes
-
             stop_iteration = self._stop_iteration
             if not stop_iteration:
                 # We may still be at the end of the dataloader without knowing it yet: if there is nothing left in
@@ -636,13 +548,11 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
                 # next_batch_info[0] is None when there are no more batches, otherwise we still need to process them.
                 if self._stop_iteration and next_batch_info[0] is None:
                     stop_iteration = True
-
             if not self._drop_last and stop_iteration and observed_batch_size % self.state.num_processes != 0:
                 # If the last batch is not complete, let's add the first batch to it.
                 batch = concatenate([batch, first_batch], dim=0)
                 # Batch size computation above is wrong, it's off by 1 so we fix it.
                 batch_size += 1
-
             data_slice = slice(self.state.process_index * batch_size, (self.state.process_index + 1) * batch_size)
             batch = self.slice_fn(
                 batch,
@@ -650,7 +560,6 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
                 process_index=self.state.process_index,
                 num_processes=self.state.num_processes,
             )
-
             if stop_iteration:
                 self.end_of_dataloader = True
                 self.remainder = observed_batch_size
@@ -659,7 +568,6 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
             batch_index += 1
         self.iteration += 1
         self.end()
-
     def set_epoch(self, epoch: int):
         # In case it is manually passed in, the user can set it to what they like
         if self.iteration != epoch:
@@ -668,7 +576,6 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
             self.batch_sampler.sampler.set_epoch(epoch)
         elif hasattr(self.dataset, "set_epoch"):
             self.dataset.set_epoch(epoch)
-
     def __len__(self):
         whole_length = super().__len__()
         if self.split_batches:
@@ -677,18 +584,14 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
             return whole_length // self.state.num_processes
         else:
             return math.ceil(whole_length / self.state.num_processes)
-
     @property
     def total_batch_size(self):
         return (
             self.dataset.batch_size if self.split_batches else (self.dataset.batch_size * self.dataset.num_processes)
         )
-
     @property
     def total_dataset_length(self):
         return len(self.dataset)
-
-
 def prepare_data_loader(
     dataloader: DataLoader,
     device: Optional[torch.device] = None,
@@ -703,10 +606,8 @@ def prepare_data_loader(
 ) -> DataLoader:
     """
     Wraps a PyTorch `DataLoader` to generate batches for one of the processes only.
-
     Depending on the value of the `drop_last` attribute of the `dataloader` passed, it will either stop the iteration
     at the first batch that would be too small / not present on all processes or loop with indices from the beginning.
-
     Args:
         dataloader (`torch.utils.data.dataloader.DataLoader`):
             The data loader to split across several devices.
@@ -721,11 +622,9 @@ def prepare_data_loader(
             Whether the resulting `DataLoader` should split the batches of the original data loader across devices or
             yield full batches (in which case it will yield batches starting at the `process_index`-th and advancing of
             `num_processes` batches at each iteration).
-
             Another way to see this is that the observed batch size will be the same as the initial `dataloader` if
             this option is set to `True`, the batch size of the initial `dataloader` multiplied by `num_processes`
             otherwise.
-
             Setting this option to `True` requires that the batch size of the `dataloader` is a round multiple of
             `batch_size`.
         put_on_device (`bool`, *optional*, defaults to `False`):
@@ -734,13 +633,11 @@ def prepare_data_loader(
         rng_types (list of `str` or [`~utils.RNGType`]):
             The list of random number generators to synchronize at the beginning of each iteration. 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.
-
         dispatch_batches (`bool`, *optional*):
             If set to `True`, the datalaoder prepared is only iterated through on the main process and then the batches
             are split and broadcast to each process. Will default to `True` when the underlying dataset is an
@@ -753,15 +650,11 @@ def prepare_data_loader(
             If passed, this function will be used to slice tensors across `num_processes`. Will default to
             [`~utils.slice_tensors`]. This argument is used only when `dispatch_batches` is set to `True` and will be
             ignored otherwise.
-
     Returns:
         `torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches
-
     <Tip warning={true}>
-
     `BatchSampler`s with varying batch sizes are not enabled by default. To enable this behaviour, set `even_batches`
     equal to `False`
-
     </Tip>
     """
     if dispatch_batches is None:
@@ -769,7 +662,6 @@ def prepare_data_loader(
             dispatch_batches = False
         else:
             dispatch_batches = isinstance(dataloader.dataset, IterableDataset)
-
     if dispatch_batches and not put_on_device:
         raise ValueError("Using `dispatch_batches=True` requires `put_on_device=True`.")
     # Grab defaults from AcceleratorState
@@ -778,14 +670,12 @@ def prepare_data_loader(
         num_processes = state.num_processes
     if process_index is None:
         process_index = state.process_index
-
     # Sanity check
     if split_batches and dataloader.batch_size > 1 and dataloader.batch_size % num_processes != 0:
         raise ValueError(
             f"To use a `DataLoader` in `split_batches` mode, the batch size ({dataloader.batch_size}) "
             f"needs to be a round multiple of the number of processes ({num_processes})."
         )
-
     new_dataset = dataloader.dataset
     # Iterable dataset doesn't like batch_sampler, but data_loader creates a default one for it
     new_batch_sampler = dataloader.batch_sampler if not isinstance(new_dataset, IterableDataset) else None
@@ -807,7 +697,6 @@ def prepare_data_loader(
             num_samples=sampler._num_samples,
             generator=getattr(sampler, "generator", torch.Generator()),
         )
-
     # No change if no multiprocess
     if (num_processes != 1 or state.distributed_type == DistributedType.MEGATRON_LM) and not dispatch_batches:
         if isinstance(new_dataset, IterableDataset):
@@ -830,7 +719,6 @@ def prepare_data_loader(
                 split_batches=split_batches,
                 even_batches=even_batches,
             )
-
     # We ignore all of those since they are all dealt with by our new_batch_sampler
     ignore_kwargs = [
         "batch_size",
@@ -839,16 +727,13 @@ def prepare_data_loader(
         "batch_sampler",
         "drop_last",
     ]
-
     if rng_types is not None and synchronized_generator is None and "generator" in rng_types:
         rng_types.remove("generator")
-
     kwargs = {
         k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k])
         for k in _PYTORCH_DATALOADER_KWARGS
         if k not in ignore_kwargs
     }
-
     # Need to provide batch_size as batch_sampler is None for Iterable dataset
     if new_batch_sampler is None:
         kwargs["drop_last"] = dataloader.drop_last
@@ -891,12 +776,9 @@ def prepare_data_loader(
             _drop_last=dataloader.drop_last,
             **kwargs,
         )
-
     if state.distributed_type == DistributedType.TPU:
         return MpDeviceLoaderWrapper(dataloader, device)
     return dataloader
-
-
 class SkipBatchSampler(BatchSampler):
     """
     A `torch.utils.data.BatchSampler` that skips the first `n` batches of another `torch.utils.data.BatchSampler`.
@@ -904,24 +786,18 @@ class SkipBatchSampler(BatchSampler):
     def __init__(self, batch_sampler, skip_batches=0):
         self.batch_sampler = batch_sampler
         self.skip_batches = skip_batches
-
     def __iter__(self):
         for index, samples in enumerate(self.batch_sampler):
             if index >= self.skip_batches:
                 yield samples
-
     @property
     def total_length(self):
         return len(self.batch_sampler)
-
     def __len__(self):
         return len(self.batch_sampler) - self.skip_batches
-
-
 class SkipDataLoader(DataLoader):
     """
     Subclass of a PyTorch `DataLoader` that will skip the first batches.
-
     Args:
         dataset (`torch.utils.data.dataset.Dataset`):
             The dataset to use to build this datalaoder.
@@ -933,13 +809,10 @@ class SkipDataLoader(DataLoader):
     def __init__(self, dataset, skip_batches=0, **kwargs):
         super().__init__(dataset, **kwargs)
         self.skip_batches = skip_batches
-
     def __iter__(self):
         for index, batch in enumerate(super().__iter__()):
             if index >= self.skip_batches:
                 yield batch
-
-
 def skip_first_batches(dataloader, num_batches=0):
     """
     Creates a `torch.utils.data.DataLoader` that will efficiently skip the first `num_batches`.
@@ -952,7 +825,6 @@ def skip_first_batches(dataloader, num_batches=0):
         sampler_is_batch_sampler = isinstance(dataloader.sampler, BatchSampler)
         batch_sampler = dataloader.sampler if sampler_is_batch_sampler else dataloader.batch_sampler
         new_batch_sampler = SkipBatchSampler(batch_sampler, skip_batches=num_batches)
-
     # We ignore all of those since they are all dealt with by our new_batch_sampler
     ignore_kwargs = [
         "batch_size",
@@ -961,18 +833,15 @@ def skip_first_batches(dataloader, num_batches=0):
         "batch_sampler",
         "drop_last",
     ]
-
     kwargs = {
         k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k])
         for k in _PYTORCH_DATALOADER_KWARGS
         if k not in ignore_kwargs
     }
-
     # Need to provide batch_size as batch_sampler is None for Iterable dataset
     if new_batch_sampler is None:
         kwargs["drop_last"] = dataloader.drop_last
         kwargs["batch_size"] = dataloader.batch_size
-
     if isinstance(dataloader, DataLoaderDispatcher):
         if new_batch_sampler is None:
             # Need to manually skip batches in the dataloader
@@ -1006,5 +875,4 @@ def skip_first_batches(dataloader, num_batches=0):
             dataloader = SkipDataLoader(dataset, skip_batches=num_batches, **kwargs)
         else:
             dataloader = DataLoader(dataset, batch_sampler=new_batch_sampler, **kwargs)
-
     return dataloader

src/hooks.py

@@ -2,99 +2,76 @@ class ModelHook:
     """
     A hook that contains callbacks to be executed just before and after the forward method of a model. The difference
     with PyTorch existing hooks is that they get passed along the kwargs.
-
     Class attribute:
     - **no_grad** (`bool`, *optional*, defaults to `False`) -- Whether or not to execute the actual forward pass under
       the `torch.no_grad()` context manager.
     """
     no_grad = False
-
     def init_hook(self, module):
         """
         To be executed when the hook is attached to the module.
-
         Args:
             module (`torch.nn.Module`): The module attached to this hook.
         """
         return module
-
     def pre_forward(self, module, *args, **kwargs):
         """
         To be executed just before the forward method of the model.
-
         Args:
             module (`torch.nn.Module`): The module whose forward pass will be executed just after this event.
             args (`Tuple[Any]`): The positional arguments passed to the module.
             kwargs (`Dict[Str, Any]`): The keyword arguments passed to the module.
-
         Returns:
             `Tuple[Tuple[Any], Dict[Str, Any]]`: A tuple with the treated `args` and `kwargs`.
         """
         return args, kwargs
-
     def post_forward(self, module, output):
         """
         To be executed just after the forward method of the model.
-
         Args:
             module (`torch.nn.Module`): The module whose forward pass been executed just before this event.
             output (`Any`): The output of the module.
-
         Returns:
             `Any`: The processed `output`.
         """
         return output
-
     def detach_hook(self, module):
         """
         To be executed when the hook is detached from a module.
-
         Args:
             module (`torch.nn.Module`): The module detached from this hook.
         """
         return module
-
-
 class SequentialHook(ModelHook):
     """
     A hook that can contain several hooks and iterates through them at each event.
     """
     def __init__(self, *hooks):
         self.hooks = hooks
-
     def init_hook(self, module):
         for hook in self.hooks:
             module = hook.init_hook(module)
         return module
-
     def pre_forward(self, module, *args, **kwargs):
         for hook in self.hooks:
             args, kwargs = hook.pre_forward(module, *args, **kwargs)
         return args, kwargs
-
     def post_forward(self, module, output):
         for hook in self.hooks:
             output = hook.post_forward(module, output)
         return output
-
     def detach_hook(self, module):
         for hook in self.hooks:
             module = hook.detach_hook(module)
         return module
-
-
 def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool = False):
     """
     Adds a hook to a given module. This will rewrite the `forward` method of the module to include the hook, to remove
     this behavior and restore the original `forward` method, use `remove_hook_from_module`.
-
     <Tip warning={true}>
-
     If the module already contains a hook, this will replace it with the new hook passed by default. To chain two hooks
     together, pass `append=True`, so it chains the current and new hook into an instance of the `SequentialHook` class.
-
     </Tip>
-
     Args:
         module (`torch.nn.Module`):
             The module to attach a hook to.
@@ -102,7 +79,6 @@ def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool = False)
             The hook to attach.
         append (`bool`, *optional*, defaults to `False`):
             Whether the hook should be chained with an existing one (if module already contains a hook) or not.
-
     Returns:
         `torch.nn.Module`: The same module, with the hook attached (the module is modified in place, so the result can
         be discarded).
@@ -111,17 +87,14 @@ def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool = False)
         old_hook = module._hf_hook
         remove_hook_from_module(module)
         hook = SequentialHook(old_hook, hook)
-
     if hasattr(module, "_hf_hook") and hasattr(module, "_old_forward"):
         # If we already put some hook on this module, we replace it with the new one.
         old_forward = module._old_forward
     else:
         old_forward = module.forward
         module._old_forward = old_forward
-
     module = hook.init_hook(module)
     module._hf_hook = hook
-
     def new_forward(module, *args, **kwargs):
         args, kwargs = module._hf_hook.pre_forward(module, *args, **kwargs)
         if module._hf_hook.no_grad:
@@ -130,20 +103,14 @@ def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool = False)
         else:
             output = module._old_forward(*args, **kwargs)
         return module._hf_hook.post_forward(module, output)
-
     module.forward = functools.update_wrapper(functools.partial(new_forward, module), old_forward)
-
     return module
-
-
 def remove_hook_from_module(module: nn.Module, recurse=False):
     """
     Removes any hook attached to a module via `add_hook_to_module`.
-
     Args:
         module (`torch.nn.Module`): The module to attach a hook to.
         recurse (`bool`, **optional**): Whether to remove the hooks recursively
-
     Returns:
         `torch.nn.Module`: The same module, with the hook detached (the module is modified in place, so the result can
         be discarded).
@@ -151,23 +118,17 @@ def remove_hook_from_module(module: nn.Module, recurse=False):
     if hasattr(module, "_hf_hook"):
         module._hf_hook.detach_hook(module)
         delattr(module, "_hf_hook")
-
     if hasattr(module, "_old_forward"):
         module.forward = module._old_forward
         delattr(module, "_old_forward")
-
     if recurse:
         for child in module.children():
             remove_hook_from_module(child, recurse)
-
     return module
-
-
 class AlignDevicesHook(ModelHook):
     """
     A generic `ModelHook` that ensures inputs and model weights are on the same device for the forward pass of the
     associated module, potentially offloading the weights after the forward pass.
-
     Args:
         execution_device (`torch.device`, *optional*):
             The device on which inputs and model weights should be placed before the forward pass.
@@ -199,19 +160,16 @@ class AlignDevicesHook(ModelHook):
         self.offload_buffers = offload_buffers
         self.place_submodules = place_submodules
         self.skip_keys = skip_keys
-
         # Will contain the input device when `io_same_device=True`.
         self.input_device = None
         self.param_original_devices = {}
         self.buffer_original_devices = {}
-
     def __repr__(self):
         return (
             f"AlignDevicesHook(execution_device={self.execution_device}, offload={self.offload}, "
             f"io_same_device={self.io_same_device}, offload_buffers={self.offload_buffers}, "
             f"place_submodules={self.place_submodules}, skip_keys={repr(self.skip_keys)})"
         )
-
     def init_hook(self, module):
         if not self.offload and self.execution_device is not None:
             for name, _ in named_module_tensors(module, recurse=self.place_submodules):
@@ -237,9 +195,7 @@ class AlignDevicesHook(ModelHook):
             elif self.offload_buffers and self.execution_device is not None:
                 for name in get_non_persistent_buffers(module, recurse=self.place_submodules):
                     set_module_tensor_to_device(module, name, self.execution_device)
-
         return module
-
     def pre_forward(self, module, *args, **kwargs):
         if self.io_same_device:
             self.input_device = find_device([args, kwargs])
@@ -257,11 +213,9 @@ class AlignDevicesHook(ModelHook):
                 set_module_tensor_to_device(
                     module, name, self.execution_device, value=self.weights_map[name], fp16_statistics=fp16_statistics
                 )
-
         return send_to_device(args, self.execution_device), send_to_device(
             kwargs, self.execution_device, skip_keys=self.skip_keys
         )
-
     def post_forward(self, module, output):
         if self.offload:
             for name, _ in named_module_tensors(
@@ -274,20 +228,15 @@ class AlignDevicesHook(ModelHook):
                 if type(module).__name__ == "Linear8bitLt":
                     module.state.SCB = None
                     module.state.CxB = None
-
         if self.io_same_device and self.input_device is not None:
             output = send_to_device(output, self.input_device, skip_keys=self.skip_keys)
-
         return output
-
     def detach_hook(self, module):
         if self.offload:
             for name, device in self.original_devices.items():
                 if device != torch.device("meta"):
                     set_module_tensor_to_device(module, name, device, value=self.weights_map.get(name, None))
         return module
-
-
 def attach_execution_device_hook(
     module: torch.nn.Module,
     execution_device: Union[int, str, torch.device],
@@ -297,7 +246,6 @@ def attach_execution_device_hook(
     """
     Recursively attaches `AlignDevicesHook` to all submodules of a given model to make sure they have the right
     execution device
-
     Args:
         module (`torch.nn.Module`):
             The module where we want to attach the hooks.
@@ -313,15 +261,11 @@ def attach_execution_device_hook(
     """
     if not hasattr(module, "_hf_hook") and len(module.state_dict()) > 0:
         add_hook_to_module(module, AlignDevicesHook(execution_device, skip_keys=skip_keys))
-
     # Break the recursion if we get to a preload module.
     if preload_module_classes is not None and module.__class__.__name__ in preload_module_classes:
         return
-
     for child in module.children():
         attach_execution_device_hook(child, execution_device)
-
-
 def attach_align_device_hook(
     module: torch.nn.Module,
     execution_device: Optional[torch.device] = None,
@@ -335,7 +279,6 @@ def attach_align_device_hook(
     """
     Recursively attaches `AlignDevicesHook` to all submodules of a given model that have direct parameters and/or
     buffers.
-
     Args:
         module (`torch.nn.Module`):
             The module where we want to attach the hooks.
@@ -362,7 +305,6 @@ def attach_align_device_hook(
     full_offload = (
         offload and preload_module_classes is not None and module.__class__.__name__ in preload_module_classes
     )
-
     if len(list(directs)) > 0 or full_offload:
         if weights_map is not None:
             prefix = f"{module_name}." if len(module_name) > 0 else ""
@@ -378,11 +320,9 @@ def attach_align_device_hook(
             skip_keys=skip_keys,
         )
         add_hook_to_module(module, hook, append=True)
-
     # We stop the recursion in case we hit the full offload.
     if full_offload:
         return
-
     # Recurse on all children of the module.
     for child_name, child in module.named_children():
         child_name = f"{module_name}.{child_name}" if len(module_name) > 0 else child_name
@@ -396,20 +336,15 @@ def attach_align_device_hook(
             preload_module_classes=preload_module_classes,
             skip_keys=skip_keys,
         )
-
-
 def remove_hook_from_submodules(module: nn.Module):
     """
     Recursively removes all hooks attached on the submodules of a given model.
-
     Args:
         module (`torch.nn.Module`): The module on which to remove all hooks.
     """
     remove_hook_from_module(module)
     for child in module.children():
         remove_hook_from_submodules(child)
-
-
 def attach_align_device_hook_on_blocks(
     module: nn.Module,
     execution_device: Optional[Union[torch.device, Dict[str, torch.device]]] = None,
@@ -422,7 +357,6 @@ def attach_align_device_hook_on_blocks(
 ):
     """
     Attaches `AlignDevicesHook` to all blocks of a given model as needed.
-
     Args:
         module (`torch.nn.Module`):
             The module where we want to attach the hooks.
@@ -464,12 +398,10 @@ def attach_align_device_hook_on_blocks(
                 skip_keys=skip_keys,
             )
         return
-
     if not isinstance(execution_device, Mapping):
         execution_device = {key: execution_device for key in offload.keys()}
     if not isinstance(offload, Mapping):
         offload = {key: offload for key in execution_device.keys()}
-
     if module_name in execution_device and module_name in offload and not offload[module_name]:
         hook = AlignDevicesHook(
             execution_device=execution_device[module_name],
@@ -505,7 +437,6 @@ def attach_align_device_hook_on_blocks(
     elif module_name == "":
         hook = AlignDevicesHook(execution_device=execution_device.get(""), io_same_device=True, skip_keys=skip_keys)
         add_hook_to_module(module, hook)
-
     for child_name, child in module.named_children():
         child_name = f"{module_name}.{child_name}" if len(module_name) > 0 else child_name
         attach_align_device_hook_on_blocks(
@@ -518,13 +449,10 @@ def attach_align_device_hook_on_blocks(
             preload_module_classes=preload_module_classes,
             skip_keys=skip_keys,
         )
-
-
 class CpuOffload(ModelHook):
     """
     Offloads a model on the CPU until its forward pass is called. The model will not be offloaded back to the CPU after
     the forward, the user needs to call the `init_hook` method again for this.
-
     Args:
         execution_device(`str`, `int` or `torch.device`, *optional*):
             The device on which the model should be executed. Will default to the MPS device if it's available, then
@@ -540,19 +468,14 @@ class CpuOffload(ModelHook):
         prev_module_hook: Optional["UserCpuOffloadHook"] = None,
     ):
         self.prev_module_hook = prev_module_hook
-
         self.execution_device = execution_device if execution_device is not None else PartialState().default_device
-
     def init_hook(self, module):
         return module.to("cpu")
-
     def pre_forward(self, module, *args, **kwargs):
         if self.prev_module_hook is not None:
             self.prev_module_hook.offload()
         module.to(self.execution_device)
         return send_to_device(args, self.execution_device), send_to_device(kwargs, self.execution_device)
-
-
 class UserCpuOffloadHook:
     """
     A simple hook grouping a model and a `ModelHook`, which provides easy APIs for to call the init method of the hook
@@ -561,9 +484,7 @@ class UserCpuOffloadHook:
     def __init__(self, model, hook):
         self.model = model
         self.hook = hook
-
     def offload(self):
         self.hook.init_hook(self.model)
-
     def remove(self):
         remove_hook_from_module(self.model)

src/launchers.py

@@ -1,8 +1,6 @@
 def test_launch():
     "Verify a `PartialState` can be initialized."
     _ = PartialState()
-
-
 def notebook_launcher(
     function,
     args=(),
@@ -16,17 +14,12 @@ def notebook_launcher(
     """
     Launches a training function, using several processes or multiple nodes if it's possible in the current environment
     (TPU with multiple cores for instance).
-
     <Tip warning={true}>
-
     To use this function absolutely zero calls to a CUDA device must be made in the notebook session before calling. If
     any have been made, you will need to restart the notebook and make sure no cells use any CUDA capability.
-
     Setting `ACCELERATE_DEBUG_MODE="1"` in your environment will run a test before truly launching to ensure that none
     of those calls have been made.
-
     </Tip>
-
     Args:
         function (`Callable`):
             The training function to execute. If it accepts arguments, the first argument should be the index of the
@@ -46,19 +39,13 @@ def notebook_launcher(
             The rank of the current node.
         num_nodes (`int`, *optional*, defaults to 1):
             The number of nodes to use for training.
-
     Example:
-
     ```python
     # Assume this is defined in a Jupyter Notebook on an instance with two GPUs
     from accelerate import notebook_launcher
-
-
     def train(*args):
         # Your training function here
         ...
-
-
     notebook_launcher(train, args=(arg1, arg2), num_processes=2, mixed_precision="fp16")
     ```
     """
@@ -69,18 +56,15 @@ def notebook_launcher(
         in_kaggle = True
     elif "IPython" in sys.modules:
         in_colab = "google.colab" in str(sys.modules["IPython"].get_ipython())
-
     try:
         mixed_precision = PrecisionType(mixed_precision.lower())
     except ValueError:
         raise ValueError(
             f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."
         )
-
     if (in_colab or in_kaggle) and (os.environ.get("TPU_NAME", None) is not None):
         # TPU launch
         import torch_xla.distributed.xla_multiprocessing as xmp
-
         if len(AcceleratorState._shared_state) > 0:
             raise ValueError(
                 "To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside "
@@ -89,7 +73,6 @@ def notebook_launcher(
             )
         if num_processes is None:
             num_processes = 8
-
         launcher = PrepareForLaunch(function, distributed_type="TPU")
         print(f"Launching a training on {num_processes} TPU cores.")
         xmp.spawn(launcher, args=args, nprocs=num_processes, start_method="fork")
@@ -111,7 +94,6 @@ def notebook_launcher(
             # Multi-GPU launch
             from torch.multiprocessing import start_processes
             from torch.multiprocessing.spawn import ProcessRaisedException
-
             if len(AcceleratorState._shared_state) > 0:
                 raise ValueError(
                     "To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized "
@@ -128,7 +110,6 @@ def notebook_launcher(
                 for lib_name in problematic_imports:
                     err += f"\n\t* `{lib_name}`"
                 raise RuntimeError(err)
-
             patched_env = dict(
                 nproc=num_processes,
                 node_rank=node_rank,
@@ -137,12 +118,10 @@ def notebook_launcher(
                 master_port=use_port,
                 mixed_precision=mixed_precision,
             )
-
             # Check for CUDA P2P and IB issues
             if not check_cuda_p2p_ib_support():
                 patched_env["nccl_p2p_disable"] = "1"
                 patched_env["nccl_ib_disable"] = "1"
-
             # torch.distributed will expect a few environment variable to be here. We set the ones common to each
             # process here (the other ones will be set be the launcher).
             with patch_environment(**patched_env):
@@ -177,7 +156,6 @@ def notebook_launcher(
                         ) from e
                     else:
                         raise RuntimeError(f"An issue was found when launching the training: {e}") from e
-
         else:
             # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
             if is_mps_available():
@@ -188,19 +166,13 @@ def notebook_launcher(
             else:
                 print("Launching training on CPU.")
             function(*args)
-
-
 def debug_launcher(function, args=(), num_processes=2):
     """
     Launches a training function using several processes on CPU for debugging purposes.
-
     <Tip warning={true}>
-
     This function is provided for internal testing and debugging, but it's not intended for real trainings. It will
     only use the CPU.
-
     </Tip>
-
     Args:
         function (`Callable`):
             The training function to execute.
@@ -210,7 +182,6 @@ def debug_launcher(function, args=(), num_processes=2):
             The number of processes to use for training.
     """
     from torch.multiprocessing import start_processes
-
     with tempfile.NamedTemporaryFile() as tmp_file:
         # torch.distributed will expect a few environment variable to be here. We set the ones common to each
         # process here (the other ones will be set be the launcher).

src/local_sgd.py

@@ -2,40 +2,29 @@ class LocalSGD:
     """
     A helper class to support local SGD on top of Accelerator. It simply runs a given number of updates independently
     on each device, and averages model weights every K synchronization step.
-
     It should be used only in the multi-GPU (or multi-CPU) setup without extensions such as DeepSpeed. In particular,
     this is a simple implementation that cannot support scenarios such as model parallelism.
-
-
     Although we are not aware of the true origins of this simple approach, the idea of local SGD is quite old and goes
     back to at least:
-
     Zhang, J., De Sa, C., Mitliagkas, I., & Ré, C. (2016). [Parallel SGD: When does averaging help?. arXiv preprint
     arXiv:1606.07365.](https://arxiv.org/abs/1606.07365)
-
     We credit the term Local SGD to the following paper (but there might be earlier references we are not aware of).
-
     Stich, Sebastian Urban. ["Local SGD Converges Fast and Communicates Little." ICLR 2019-International Conference on
     Learning Representations. No. CONF. 2019.](https://arxiv.org/abs/1805.09767)
-
     """
     def __enter__(self):
         if self.enabled:
             self.model_sync_obj = self.model.no_sync()
             self.model_sync_obj.__enter__()
-
         return self
-
     def __exit__(self, type, value, tb):
         if self.enabled:
             # Average all models on exit
             self._sync_and_avg_model_params()
             self.model_sync_obj.__exit__(type, value, tb)
-
     def __init__(self, accelerator: Accelerator, model: torch.nn.Module, local_sgd_steps: int, enabled: bool = True):
         """
         Constructor.
-
         Args:
             model (`torch.nn.Module):
                 The model whose parameters we need to average.
@@ -58,7 +47,6 @@ class LocalSGD:
             self.accelerator = accelerator
             self.model = model
             self.local_sgd_steps = local_sgd_steps
-
     def step(self):
         """
         This function makes a "step" and synchronizes model parameters if necessary.
@@ -66,10 +54,8 @@ class LocalSGD:
         self.num_steps += 1
         if not self.enabled:
             return
-
         if self.num_steps % self.local_sgd_steps == 0:
             self._sync_and_avg_model_params()
-
     def _sync_and_avg_model_params(self):
         """
         Synchronize + Average model parameters across all GPUs

src/logging.py

@@ -1,10 +1,8 @@
 class MultiProcessAdapter(logging.LoggerAdapter):
     """
     An adapter to assist with logging in multiprocess.
-
     `log` takes in an additional `main_process_only` kwarg, which dictates whether it should be called on all processes
     or only the main executed one. Default is `main_process_only=True`.
-
     Does not require an `Accelerator` object to be created first.
     """
     @staticmethod
@@ -12,18 +10,14 @@ class MultiProcessAdapter(logging.LoggerAdapter):
         "Check if log should be performed"
         state = PartialState()
         return not main_process_only or (main_process_only and state.is_main_process)
-
     def log(self, level, msg, *args, **kwargs):
         """
         Delegates logger call after checking if we should log.
-
         Accepts a new kwarg of `main_process_only`, which will dictate whether it will be logged across all processes
         or only the main executed one. Default is `True` if not passed
-
         Also accepts "in_order", which if `True` makes the processes log one by one, in order. This is much easier to
         read, but comes at the cost of sometimes needing to wait for the other processes. Default is `False` to not
         break with the previous behavior.
-
         `in_order` is ignored if `main_process_only` is passed.
         """
         if PartialState._shared_state == {}:
@@ -32,12 +26,10 @@ class MultiProcessAdapter(logging.LoggerAdapter):
             )
         main_process_only = kwargs.pop("main_process_only", True)
         in_order = kwargs.pop("in_order", False)
-
         if self.isEnabledFor(level):
             if self._should_log(main_process_only):
                 msg, kwargs = self.process(msg, kwargs)
                 self.logger.log(level, msg, *args, **kwargs)
-
             elif in_order:
                 state = PartialState()
                 for i in range(state.num_processes):
@@ -45,48 +37,36 @@ class MultiProcessAdapter(logging.LoggerAdapter):
                         msg, kwargs = self.process(msg, kwargs)
                         self.logger.log(level, msg, *args, **kwargs)
                     state.wait_for_everyone()
-
     @functools.lru_cache(None)
     def warning_once(self, *args, **kwargs):
         """
         This method is identical to `logger.warning()`, but will emit the warning with the same message only once
-
         Note: The cache is for the function arguments, so 2 different callers using the same arguments will hit the
         cache. The assumption here is that all warning messages are unique across the code. If they aren't then need to
         switch to another type of cache that includes the caller frame information in the hashing function.
         """
         self.warning(*args, **kwargs)
-
-
 def get_logger(name: str, log_level: str = None):
     """
     Returns a `logging.Logger` for `name` that can handle multiprocessing.
-
     If a log should be called on all processes, pass `main_process_only=False` If a log should be called on all
     processes and in order, also pass `in_order=True`
-
     Args:
         name (`str`):
             The name for the logger, such as `__file__`
         log_level (`str`, *optional*):
             The log level to use. If not passed, will default to the `LOG_LEVEL` environment variable, or `INFO` if not
-
     Example:
-
     ```python
     >>> from accelerate.logging import get_logger
     >>> from accelerate import Accelerator
-
     >>> logger = get_logger(__name__)
-
     >>> accelerator = Accelerator()
     >>> logger.info("My log", main_process_only=False)
     >>> logger.debug("My log", main_process_only=True)
-
     >>> logger = get_logger(__name__, log_level="DEBUG")
     >>> logger.info("My log")
     >>> logger.debug("My second log")
-
     >>> array = ["a", "b", "c", "d"]
     >>> letter_at_rank = array[accelerator.process_index]
     >>> logger.info(letter_at_rank, in_order=True)

src/optimizer.py

@@ -6,15 +6,11 @@ def move_to_device(state, device):
     elif isinstance(state, torch.Tensor):
         return state.to(device)
     return state
-
-
 class AcceleratedOptimizer(torch.optim.Optimizer):
     """
     Internal wrapper around a torch optimizer.
-
     Conditionally will perform `step` and `zero_grad` if gradients should be synchronized when performing gradient
     accumulation.
-
     Args:
         optimizer (`torch.optim.optimizer.Optimizer`):
             The optimizer to wrap.
@@ -31,12 +27,10 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
         self.gradient_state = GradientState()
         self.device_placement = device_placement
         self._is_overflow = False
-
         if self.scaler is not None:
             self._accelerate_step_called = False
             self._optimizer_original_step_method = self.optimizer.step
             self._optimizer_patched_step_method = patch_optimizer_step(self, self.optimizer.step)
-
         # Handle device placement
         if device_placement:
             state_dict = self.optimizer.state_dict()
@@ -45,42 +39,32 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
             else:
                 state_dict = move_to_device(state_dict, self.accelerator_state.device)
             self.optimizer.load_state_dict(state_dict)
-
     @property
     def state(self):
         return self.optimizer.state
-
     @state.setter
     def state(self, state):
         self.optimizer.state = state
-
     @property
     def param_groups(self):
         return self.optimizer.param_groups
-
     @param_groups.setter
     def param_groups(self, param_groups):
         self.optimizer.param_groups = param_groups
-
     @property
     def defaults(self):
         return self.optimizer.defaults
-
     @defaults.setter
     def defaults(self, defaults):
         self.optimizer.defaults = defaults
-
     def add_param_group(self, param_group):
         self.optimizer.add_param_group(param_group)
-
     def load_state_dict(self, state_dict):
         if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
             xm.send_cpu_data_to_device(state_dict, self.accelerator_state.device)
         self.optimizer.load_state_dict(state_dict)
-
     def state_dict(self):
         return self.optimizer.state_dict()
-
     def zero_grad(self, set_to_none=None):
         if self.gradient_state.sync_gradients:
             accept_arg = "set_to_none" in inspect.signature(self.optimizer.zero_grad).parameters
@@ -92,7 +76,6 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
                 if set_to_none is not None:
                     raise ValueError("`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.")
                 self.optimizer.zero_grad()
-
     def step(self, closure=None):
         if self.gradient_state.sync_gradients:
             if self.accelerator_state.distributed_type == DistributedType.TPU:
@@ -100,10 +83,8 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
                 xm.optimizer_step(self.optimizer, optimizer_args=optimizer_args)
             elif self.scaler is not None:
                 self.optimizer.step = self._optimizer_patched_step_method
-
                 self.scaler.step(self.optimizer, closure)
                 self.scaler.update()
-
                 if not self._accelerate_step_called:
                     # If the optimizer step was skipped, gradient overflow was detected.
                     self._is_overflow = True
@@ -115,11 +96,9 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
                 self._accelerate_step_called = False
             else:
                 self.optimizer.step(closure)
-
     def _switch_parameters(self, parameters_map):
         for param_group in self.optimizer.param_groups:
             param_group["params"] = [parameters_map.get(p, p) for p in param_group["params"]]
-
     @property
     def is_overflow(self):
         """Whether or not the optimizer step was done, or skipped because of gradient overflow."""
@@ -129,12 +108,10 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
             FutureWarning,
         )
         return self._is_overflow
-
     @property
     def step_was_skipped(self):
         """Whether or not the optimizer step was skipped."""
         return self._is_overflow
-
     def __getstate__(self):
         _ignored_keys = [
             "_accelerate_step_called",
@@ -142,18 +119,14 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
             "_optimizer_patched_step_method",
         ]
         return {k: v for k, v in self.__dict__.items() if k not in _ignored_keys}
-
     def __setstate__(self, state):
         self.__dict__.update(state)
         if self.scaler is not None:
             self._accelerate_step_called = False
             self._optimizer_original_step_method = self.optimizer.step
             self._optimizer_patched_step_method = patch_optimizer_step(self, self.optimizer.step)
-
-
 def patch_optimizer_step(accelerated_optimizer: AcceleratedOptimizer, method):
     def patched_step(*args, **kwargs):
         accelerated_optimizer._accelerate_step_called = True
         return method(*args, **kwargs)
-
     return patched_step

src/scheduler.py

@@ -1,16 +1,11 @@
-
-
 # We ignore warnings about stepping the scheduler since we step it ourselves during gradient accumulation
-
 class AcceleratedScheduler:
     """
     A wrapper around a learning rate scheduler that will only step when the optimizer(s) have a training step. Useful
     to avoid making a scheduler step too fast when gradients went overflow and there was no training step (in mixed
     precision training)
-
     When performing gradient accumulation scheduler lengths should not be changed accordingly, Accelerate will always
     step the scheduler to account for it.
-
     Args:
         scheduler (`torch.optim.lr_scheduler._LRScheduler`):
             The scheduler to wrap.
@@ -29,19 +24,16 @@ class AcceleratedScheduler:
         self.split_batches = split_batches
         self.step_with_optimizer = step_with_optimizer
         self.gradient_state = GradientState()
-
     def step(self, *args, **kwargs):
         if not self.step_with_optimizer:
             # No link between scheduler and optimizer -> just step
             self.scheduler.step(*args, **kwargs)
             return
-
         # Otherwise, first make sure the optimizer was stepped.
         if not self.gradient_state.sync_gradients:
             if self.gradient_state.adjust_scheduler:
                 self.scheduler._step_count += 1
             return
-
         for opt in self.optimizers:
             if opt.step_was_skipped:
                 return
@@ -59,19 +51,14 @@ class AcceleratedScheduler:
                         self.scheduler.step(*args, **kwargs)
                 else:
                     self.scheduler.step(*args, **kwargs)
-
     # Passthroughs
     def get_last_lr(self):
         return self.scheduler.get_last_lr()
-
     def state_dict(self):
         return self.scheduler.state_dict()
-
     def load_state_dict(self, state_dict):
         self.scheduler.load_state_dict(state_dict)
-
     def get_lr(self):
         return self.scheduler.get_lr()
-
     def print_lr(self, *args, **kwargs):
         return self.scheduler.print_lr(*args, **kwargs)

src/state.py

@@ -1,58 +1,40 @@
 logger = logging.getLogger(__name__)
-
-
 def is_initialized() -> bool:
     """
     Checks if the `AcceleratorState` has been initialized from `Accelerator`. Same as `AcceleratorState.initialized`,
     but works as a module method.
     """
     return AcceleratorState._shared_state != {}
-
-
 # Lambda function that does nothing
 def do_nothing(*args, **kwargs):
     return None
-
-
 class ThreadLocalSharedDict(threading.local):
     """
     Descriptor that holds a dict shared between instances of a class in the same thread.
-
     Note: Descriptors have slightly different semantics than just a dict field on its own.
     `PartialState(...)._shared_state` and `PartialState._shared_state` (instance vs class) give the same value: the
     underlying _storage dict. Likewise, `PartialState(...)._shared_state = {...}` overrides the _storage dict inside
     the descriptor as you would expect. However, `PartialState._shared_state = {}` actually replaces the descriptor
     object with a dict instead Thus, you should modify the _storage dict in-place (e.g. `_shared_state.clear()`).
-
     See Python documentation for an explanation of descriptors: https://docs.python.org/3/howto/descriptor.html
-
     This is required for using PyTorch/XLA with PJRT in multithreaded mode (required for TPU v2 and v3).
-
     See https://github.com/pytorch/xla/blob/r2.0/docs/pjrt.md#multithreading-on-tpu-v2v3
     """
     def __init__(self, thread_local: bool = False):
         self._storage = {}
-
     def __get__(self, obj, objtype=None):
         return self._storage
-
     def __set__(self, obj, value):
         self._storage = value
-
-
 # Prefer global shared dictionary, except when using TPU.
 SharedDict = dict if not is_tpu_available(check_device=False) else ThreadLocalSharedDict
-
-
 # Inspired by Alex Martelli's 'Borg'.
 class PartialState:
     """
     Singleton class that has information about the current training environment and functions to help with process
     control. Designed to be used when only process control and device execution states are needed. Does *not* need to
     be initialized from `Accelerator`.
-
     **Available attributes:**
-
         - **device** (`torch.device`) -- The device to use.
         - **distributed_type** ([`~accelerate.state.DistributedType`]) -- The type of distributed environment currently
           in use.
@@ -67,7 +49,6 @@ class PartialState:
         - **debug** (`bool`) -- Whether or not the current script is being run in debug mode.
     """
     _shared_state = SharedDict()
-
     def __init__(self, cpu: bool = False, **kwargs):
         self.__dict__ = self._shared_state
         if not self.initialized:
@@ -82,14 +63,12 @@ class PartialState:
                     os.environ.get("ACCELERATE_USE_SAGEMAKER", "false") == "true"
                     and os.environ.get("ACCELERATE_SAGEMAKER_DISTRIBUTED_TYPE") != SageMakerDistributedType.NO
                 )
-
             if use_sagemaker_dp and not cpu:
                 if (
                     os.environ.get("ACCELERATE_SAGEMAKER_DISTRIBUTED_TYPE") == SageMakerDistributedType.DATA_PARALLEL
                 ) or use_sagemaker_dp:
                     self.distributed_type = DistributedType.MULTI_GPU
                     import smdistributed.dataparallel.torch.torch_smddp  # noqa
-
                     if not torch.distributed.is_initialized():
                         torch.distributed.init_process_group(backend="smddp")
                     self.backend = "smddp"
@@ -116,7 +95,6 @@ class PartialState:
                 self.distributed_type = DistributedType.DEEPSPEED
                 if not torch.distributed.is_initialized():
                     from deepspeed import comm as dist
-
                     # DeepSpeed always uses nccl
                     kwargs.pop("backend", None)
                     if is_xpu_available and is_ccl_available():
@@ -127,7 +105,6 @@ class PartialState:
                     else:
                         self.backend = "nccl"
                     dist.init_distributed(dist_backend=self.backend, auto_mpi_discovery=False, **kwargs)
-
                 self.num_processes = torch.distributed.get_world_size()
                 self.process_index = torch.distributed.get_rank()
                 self.local_process_index = int(os.environ.get("LOCAL_RANK", -1))
@@ -230,7 +207,6 @@ class PartialState:
                     and get_int_from_env(["OMP_NUM_THREADS", "MKL_NUM_THREADS"], 0) == 0
                 ):
                     import psutil
-
                     num_cpu_threads_per_process = int(psutil.cpu_count(logical=False) / local_size)
                     if num_cpu_threads_per_process == 0:
                         num_cpu_threads_per_process = 1
@@ -261,12 +237,9 @@ class PartialState:
                 )
                 self.num_processes = 1
                 self.process_index = self.local_process_index = 0
-
                 if self.device is None:
                     self.device = torch.device("cpu") if cpu else self.default_device
-
         self.fork_launched = parse_flag_from_env("FORK_LAUNCHED", 0)
-
     def __repr__(self) -> str:
         return (
             f"Distributed environment: {self.distributed_type}{('  Backend: ' + self.backend) if self.backend else ''}\n"
@@ -275,36 +248,30 @@ class PartialState:
             f"Local process index: {self.local_process_index}\n"
             f"Device: {self.device}\n"
         )
-
     @staticmethod
     def _reset_state():
         "Resets `_shared_state`, is used internally and should not be called"
         PartialState._shared_state.clear()
-
     @property
     def initialized(self) -> bool:
         "Returns whether the `PartialState` has been initialized"
         return self._shared_state != {}
-
     @property
     def use_distributed(self):
         """
         Whether the Accelerator is configured for distributed training
         """
         return self.distributed_type != DistributedType.NO and self.num_processes > 1
-
     @property
     def is_last_process(self) -> bool:
         "Returns whether the current process is the last one"
         return self.process_index == self.num_processes - 1
-
     @property
     def is_main_process(self) -> bool:
         "Returns whether the current process is the main process"
         return (
             self.process_index == 0 if self.distributed_type != DistributedType.MEGATRON_LM else self.is_last_process
         )
-
     @property
     def is_local_main_process(self) -> bool:
         "Returns whether the current process is the main process on the local node"
@@ -313,19 +280,15 @@ class PartialState:
             if self.distributed_type != DistributedType.MEGATRON_LM
             else self.is_last_process
         )
-
     def wait_for_everyone(self):
         """
         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.
-
         Example:
-
         ```python
         >>> # Assuming two GPU processes
         >>> import time
         >>> from accelerate.state import PartialState
-
         >>> state = PartialState()
         >>> if state.is_main_process:
         ...     time.sleep(2)
@@ -347,24 +310,18 @@ class PartialState:
             torch.distributed.barrier()
         elif self.distributed_type == DistributedType.TPU:
             xm.rendezvous("accelerate.utils.wait_for_everyone")
-
     def _goes_first(self, is_main: bool):
         if not is_main:
             self.wait_for_everyone()
-
         yield
-
         if is_main:
             self.wait_for_everyone()
-
     @contextmanager
     def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False):
         """
         Splits `input` between `self.num_processes` quickly and can be then used on that process. Useful when doing
         distributed inference, such as with different prompts.
-
         Note that when using a `dict`, all keys need to have the same number of elements.
-
         Args:
             inputs (`list`, `tuple`, `torch.Tensor`, or `dict` of `list`/`tuple`/`torch.Tensor`):
                 The input to split between processes.
@@ -372,14 +329,10 @@ class PartialState:
                 Whether to apply padding by repeating the last element of the input so that all processes have the same
                 number of elements. Useful when trying to perform actions such as `gather()` on the outputs or passing
                 in less inputs than there are processes. If so, just remember to drop the padded elements afterwards.
-
-
         Example:
-
         ```python
         # Assume there are two processes
         from accelerate import PartialState
-
         state = PartialState()
         with state.split_between_processes(["A", "B", "C"]) as inputs:
             print(inputs)
@@ -387,7 +340,6 @@ class PartialState:
         ["A", "B"]
         # Process 1
         ["C"]
-
         with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
             print(inputs)
         # Process 0
@@ -410,7 +362,6 @@ class PartialState:
         end_index = start_index + num_samples_per_process
         if (len(inputs) % self.num_processes != 0) and (self.process_index == self.num_processes - 1):
             end_index = length
-
         def _split_values(inputs, start_index, end_index):
             if isinstance(inputs, (list, tuple, torch.Tensor)):
                 if start_index >= len(inputs):
@@ -420,7 +371,6 @@ class PartialState:
                 if apply_padding:
                     if isinstance(result, torch.Tensor):
                         from accelerate.utils import pad_across_processes, send_to_device
-
                         # The tensor needs to be on the device before we can pad it
                         tensorized_result = send_to_device(result, self.device)
                         result = pad_across_processes(tensorized_result, pad_index=inputs[-1])
@@ -433,21 +383,15 @@ class PartialState:
                 return inputs
             else:
                 return inputs
-
         yield _split_values(inputs, start_index, end_index)
-
     @contextmanager
     def main_process_first(self):
         """
         Lets the main process go first inside a with block.
-
         The other processes will enter the with block after the main process exits.
-
         Example:
-
         ```python
         >>> from accelerate import Accelerator
-
         >>> accelerator = Accelerator()
         >>> with accelerator.main_process_first():
         ...     # This will be printed first by process 0 then in a seemingly
@@ -456,19 +400,14 @@ class PartialState:
         ```
         """
         yield from self._goes_first(self.is_main_process)
-
     @contextmanager
     def local_main_process_first(self):
         """
         Lets the local main process go inside a with block.
-
         The other processes will enter the with block after the main process exits.
-
         Example:
-
         ```python
         >>> from accelerate.state import PartialState
-
         >>> state = PartialState()
         >>> with state.local_main_process_first():
         ...     # This will be printed first by local process 0 then in a seemingly
@@ -477,27 +416,18 @@ class PartialState:
         ```
         """
         yield from self._goes_first(self.is_local_main_process)
-
     def on_main_process(self, function: Callable[..., Any] = None):
         """
         Decorator that only runs the decorated function on the main process.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
-
         ```python
         >>> from accelerate.state import PartialState
-
         >>> state = PartialState()
-
-
         >>> @state.on_main_process
         ... def print_something():
         ...     print("This will be printed by process 0 only.")
-
-
         >>> print_something()
         "This will be printed by process 0 only"
         ```
@@ -507,27 +437,19 @@ class PartialState:
         if self.is_main_process or not self.use_distributed:
             return function
         return do_nothing
-
     def on_local_main_process(self, function: Callable[..., Any] = None):
         """
         Decorator that only runs the decorated function on the local main process.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
         ```python
         # Assume we have 2 servers with 4 processes each.
         from accelerate.state import PartialState
-
         state = PartialState()
-
-
         @state.on_local_main_process
         def print_something():
             print("This will be printed by process 0 only on each server.")
-
-
         print_something()
         # On server 1:
         "This will be printed by process 0 only"
@@ -538,27 +460,19 @@ class PartialState:
         if self.is_local_main_process or not self.use_distributed:
             return function
         return do_nothing
-
     def on_last_process(self, function: Callable[..., Any]):
         """
         Decorator that only runs the decorated function on the last process.
-
         Args:
             function (`Callable`): The function to decorate.
-
         Example:
         ```python
         # Assume we have 4 processes.
         from accelerate.state import PartialState
-
         state = PartialState()
-
-
         @state.on_last_process
         def print_something():
             print(f"Printed on process {state.process_index}")
-
-
         print_something()
         "Printed on process 3"
         ```
@@ -566,30 +480,22 @@ class PartialState:
         if self.is_last_process or not self.use_distributed:
             return function
         return do_nothing
-
     def on_process(self, function: Callable[..., Any] = None, process_index: int = None):
         """
         Decorator that only runs the decorated function on the process with the given index.
-
         Args:
             function (`Callable`, `optional`):
                 The function to decorate.
             process_index (`int`, `optional`):
                 The index of the process on which to run the function.
-
         Example:
         ```python
         # Assume we have 4 processes.
         from accelerate.state import PartialState
-
         state = PartialState()
-
-
         @state.on_process(process_index=2)
         def print_something():
             print(f"Printed on process {state.process_index}")
-
-
         print_something()
         "Printed on process 2"
         ```
@@ -599,30 +505,22 @@ class PartialState:
         if (self.process_index == process_index) or (not self.use_distributed):
             return function
         return do_nothing
-
     def on_local_process(self, function: Callable[..., Any] = None, local_process_index: int = None):
         """
         Decorator that only runs the decorated function on the process with the given index on the current node.
-
         Args:
             function (`Callable`, *optional*):
                 The function to decorate.
             local_process_index (`int`, *optional*):
                 The index of the local process on which to run the function.
-
         Example:
         ```python
         # Assume we have 2 servers with 4 processes each.
         from accelerate import Accelerator
-
         accelerator = Accelerator()
-
-
         @accelerator.on_local_process(local_process_index=2)
         def print_something():
             print(f"Printed on process {accelerator.local_process_index}")
-
-
         print_something()
         # On server 1:
         "Printed on process 2"
@@ -635,11 +533,9 @@ class PartialState:
         if (self.local_process_index == local_process_index) or (not self.use_distributed):
             return function
         return do_nothing
-
     def print(self, *args, **kwargs):
         if self.is_local_main_process:
             print(*args, **kwargs)
-
     @property
     def default_device(self) -> torch.device:
         """
@@ -660,14 +556,10 @@ class PartialState:
             return torch.device("npu")
         else:
             return torch.device("cpu")
-
-
 class AcceleratorState:
     """
     Singleton class that has information about the current training environment.
-
     **Available attributes:**
-
         - **device** (`torch.device`) -- The device to use.
         - **distributed_type** ([`~accelerate.state.DistributedType`]) -- The type of distributed environment currently
           in use.
@@ -683,7 +575,6 @@ class AcceleratorState:
         - **debug** (`bool`) -- Whether or not the current script is being run in debug mode.
     """
     _shared_state = SharedDict()
-
     def __init__(
         self,
         mixed_precision: str = None,
@@ -722,7 +613,6 @@ class AcceleratorState:
                         "or higher, compute capability of 8.9 or higher). Will use FP16 instead."
                     )
                     mixed_precision = "fp16"
-
             self.dynamo_plugin = dynamo_plugin
             if not _from_accelerator:
                 raise ValueError(
@@ -771,7 +661,6 @@ class AcceleratorState:
                         if self._mixed_precision != "no":
                             fsdp_plugin.set_mixed_precision(self._mixed_precision)
                         self.fsdp_plugin = fsdp_plugin
-
             if (
                 self.dynamo_plugin.backend != DynamoBackend.NO
                 and self._mixed_precision == "no"
@@ -779,17 +668,14 @@ class AcceleratorState:
             ):
                 torch.backends.cuda.matmul.allow_tf32 = True
             PartialState._shared_state["distributed_type"] = self.distributed_type
-
     @property
     def initialized(self) -> bool:
         return self._shared_state != PartialState._shared_state
-
     def __repr__(self):
         repr = PartialState().__repr__() + f"\nMixed precision type: {self.mixed_precision}\n"
         if self.distributed_type == DistributedType.DEEPSPEED:
             repr += f"ds_config: {self.deepspeed_plugin.deepspeed_config}\n"
         return repr
-
     def _check_initialized(self, mixed_precision=None, cpu=None):
         "Checks if a modification is trying to be made and the `AcceleratorState` has already been initialized"
         if self.initialized:
@@ -802,7 +688,6 @@ class AcceleratorState:
                 and self.distributed_type != DistributedType.DEEPSPEED
             ):
                 raise ValueError(err.format(flag=f"mixed_precision='{mixed_precision}'"))
-
     # For backward compatibility
     @property
     def use_fp16(self):
@@ -812,7 +697,6 @@ class AcceleratorState:
             FutureWarning,
         )
         return self._mixed_precision != "no"
-
     @property
     def mixed_precision(self):
         if self.distributed_type == DistributedType.DEEPSPEED:
@@ -826,47 +710,38 @@ class AcceleratorState:
         else:
             mixed_precision = self._mixed_precision
         return mixed_precision
-
     @staticmethod
     def _reset_state(reset_partial_state: bool = False):
         "Resets `_shared_state`, is used internally and should not be called"
         AcceleratorState._shared_state.clear()
         if reset_partial_state:
             PartialState._reset_state()
-
     @property
     def use_distributed(self):
         """
         Whether the Accelerator is configured for distributed training
         """
         return PartialState().use_distributed
-
     @property
     def is_last_process(self) -> bool:
         "Returns whether the current process is the last one"
         return PartialState().is_last_process
-
     @property
     def is_main_process(self) -> bool:
         "Returns whether the current process is the main process"
         return PartialState().is_main_process
-
     @property
     def is_local_main_process(self) -> bool:
         "Returns whether the current process is the main process on the local node"
         return PartialState().is_local_main_process
-
     def wait_for_everyone(self):
         PartialState().wait_for_everyone()
-
     @contextmanager
     def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False):
         """
         Splits `input` between `self.num_processes` quickly and can be then used on that process. Useful when doing
         distributed inference, such as with different prompts.
-
         Note that when using a `dict`, all keys need to have the same number of elements.
-
         Args:
             inputs (`list`, `tuple`, `torch.Tensor`, or `dict` of `list`/`tuple`/`torch.Tensor`):
                 The input to split between processes.
@@ -874,14 +749,10 @@ class AcceleratorState:
                 Whether to apply padding by repeating the last element of the input so that all processes have the same
                 number of elements. Useful when trying to perform actions such as `gather()` on the outputs or passing
                 in less inputs than there are processes. If so, just remember to drop the padded elements afterwards.
-
-
         Example:
-
         ```python
         # Assume there are two processes
         from accelerate.state import AcceleratorState
-
         state = AcceleratorState()
         with state.split_between_processes(["A", "B", "C"]) as inputs:
             print(inputs)
@@ -889,7 +760,6 @@ class AcceleratorState:
         ["A", "B"]
         # Process 1
         ["C"]
-
         with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
             print(inputs)
         # Process 0
@@ -900,37 +770,28 @@ class AcceleratorState:
         """
         with PartialState().split_between_processes(inputs, apply_padding=apply_padding) as inputs:
             yield inputs
-
     @contextmanager
     def main_process_first(self):
         """
         Lets the main process go first inside a with block.
-
         The other processes will enter the with block after the main process exits.
         """
         with PartialState().main_process_first():
             yield
-
     @contextmanager
     def local_main_process_first(self):
         """
         Lets the local main process go inside a with block.
-
         The other processes will enter the with block after the main process exits.
         """
         with PartialState().local_main_process_first():
             yield
-
     def print(self, *args, **kwargs):
         PartialState().print(*args, **kwargs)
-
-
 class GradientState:
     """
     Singleton class that has information related to gradient synchronization for gradient accumulation
-
     **Available attributes:**
-
         - **end_of_dataloader** (`bool`) -- Whether we have reached the end the current dataloader
         - **remainder** (`int`) -- The number of extra samples that were added from padding the dataloader
         - **sync_gradients** (`bool`) -- Whether the gradients should be synced across all devices
@@ -944,7 +805,6 @@ class GradientState:
             iteration and the number of total steps reset
     """
     _shared_state = SharedDict()
-
     def __init__(self, gradient_accumulation_plugin: Optional[GradientAccumulationPlugin] = None):
         self.__dict__ = self._shared_state
         if not self.initialized:
@@ -954,45 +814,37 @@ class GradientState:
             self.plugin_kwargs = (
                 gradient_accumulation_plugin.to_kwargs() if gradient_accumulation_plugin is not None else {}
             )
-
         # Plugin args are different and can be updated
         if gradient_accumulation_plugin is not None and self.plugin_kwargs != gradient_accumulation_plugin.to_kwargs():
             self.plugin_kwargs = gradient_accumulation_plugin.to_kwargs()
-
     @property
     def num_steps(self) -> int:
         "Returns the number of steps to accumulate over"
         return self.plugin_kwargs.get("num_steps", 1)
-
     @property
     def adjust_scheduler(self) -> bool:
         "Returns whether the scheduler should be adjusted"
         return self.plugin_kwargs.get("adjust_scheduler", False)
-
     @property
     def sync_with_dataloader(self) -> bool:
         "Returns whether the gradients should be synced at the end of the dataloader iteration and the number of total steps reset"
         return self.plugin_kwargs.get("sync_with_dataloader", True)
-
     @property
     def initialized(self) -> bool:
         "Returns whether the `GradientState` has been initialized"
         return GradientState._shared_state != {}
-
     @property
     def end_of_dataloader(self) -> bool:
         "Returns whether we have reached the end of the current dataloader"
         if not self.in_dataloader:
             return False
         return self.active_dataloader.end_of_dataloader
-
     @property
     def remainder(self) -> int:
         "Returns the number of extra samples that were added from padding the dataloader"
         if not self.in_dataloader:
             return -1
         return self.active_dataloader.remainder
-
     def __repr__(self):
         return (
             f"Sync Gradients: {self.sync_gradients}\n"
@@ -1000,26 +852,21 @@ class GradientState:
             f"Extra samples added: {self.remainder}\n"
             f"Gradient accumulation plugin: {self.plugin_kwargs}\n"
         )
-
     def _set_sync_gradients(self, sync_gradients):
         "Private function that sets whether gradients should be synchronized. Users should not have to call this."
         self.sync_gradients = sync_gradients
-
     def _add_dataloader(self, dataloader):
         "Private function that adds a dataloader to `self.dataloader_references` and sets `in_dataloader` to `True`. Users should not have to call this."
         self.active_dataloader = dataloader
         self.dataloader_references.append(self.active_dataloader)
-
     def _remove_dataloader(self, dataloader):
         "Private function that removes a dataloader from `self.dataloader_references` and sets `in_dataloader` to `False` if there are no more dataloaders. Users should not have to call this."
         self.dataloader_references.remove(dataloader)
         self.active_dataloader = self.dataloader_references[-1]
-
     @property
     def in_dataloader(self) -> bool:
         "Returns whether the current process is in a dataloader"
         return self.active_dataloader is not None
-
     @staticmethod
     def _reset_state():
         "Resets `_shared_state`, is used internally and should not be called"

src/tracking.py

@@ -1,39 +1,25 @@
-
-
 # Expectation:
 # Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}
-
 _available_trackers = []
-
 if is_tensorboard_available():
     _available_trackers.append(LoggerType.TENSORBOARD)
-
 if is_wandb_available():
     _available_trackers.append(LoggerType.WANDB)
-
 if is_comet_ml_available():
     _available_trackers.append(LoggerType.COMETML)
-
 if is_aim_available():
     _available_trackers.append(LoggerType.AIM)
-
 if is_mlflow_available():
     _available_trackers.append(LoggerType.MLFLOW)
-
 if is_clearml_available():
     _available_trackers.append(LoggerType.CLEARML)
-
 if is_dvclive_available():
     _available_trackers.append(LoggerType.DVCLIVE)
-
 logger = get_logger(__name__)
-
-
 def on_main_process(function):
     """
     Decorator to selectively run the decorated function on the main process only based on the `main_process_only`
     attribute in a class.
-
     Checks at function execution rather than initialization time, not triggering the initialization of the
     `PartialState`.
     """
@@ -43,33 +29,23 @@ def on_main_process(function):
             return PartialState().on_main_process(function)(self, *args, **kwargs)
         else:
             return function(self, *args, **kwargs)
-
     return execute_on_main_process
-
-
 def get_available_trackers():
     "Returns a list of all supported available trackers in the system"
     return _available_trackers
-
-
 class GeneralTracker:
     """
     A base Tracker class to be used for all logging integration implementations.
-
     Each function should take in `**kwargs` that will automatically be passed in from a base dictionary provided to
     [`Accelerator`].
-
     Should implement `name`, `requires_logging_directory`, and `tracker` properties such that:
-
     `name` (`str`): String representation of the tracker class name, such as "TensorBoard" `requires_logging_directory`
     (`bool`): Whether the logger requires a directory to store their logs. `tracker` (`object`): Should return internal
     tracking mechanism used by a tracker class (such as the `run` for wandb)
-
     Implementations can also include a `main_process_only` (`bool`) attribute to toggle if relevent logging, init, and
     other functions should occur on the main process or across all processes (by default will use `True`)
     """
     main_process_only = True
-
     def __init__(self, _blank=False):
         if not _blank:
             err = ""
@@ -79,7 +55,6 @@ class GeneralTracker:
                 if len(err) > 0:
                     err += ", "
                 err += "`requires_logging_directory`"
-
             # as tracker is a @property that relies on post-init
             if "tracker" not in dir(self):
                 if len(err) > 0:
@@ -91,24 +66,20 @@ class GeneralTracker:
                     f"required attributes. Please define them in the class definition: "
                     f"{err}"
                 )
-
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Implementations should use the experiment configuration
         functionality of a tracking API.
-
         Args:
             values (Dictionary `str` to `bool`, `str`, `float` or `int`):
                 Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,
                 `str`, `float`, `int`, or `None`.
         """
         pass
-
     def log(self, values: dict, step: Optional[int], **kwargs):
         """
         Logs `values` to the current run. Base `log` implementations of a tracking API should go in here, along with
         special behavior for the `step parameter.
-
         Args:
             values (Dictionary `str` to `str`, `float`, or `int`):
                 Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.
@@ -116,19 +87,15 @@ class GeneralTracker:
                 The run step. If included, the log will be affiliated with this step.
         """
         pass
-
     def finish(self):
         """
         Should run any finalizing functions within the tracking API. If the API should not have one, just don't
         overwrite that method.
         """
         pass
-
-
 class TensorBoardTracker(GeneralTracker):
     """
     A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.
-
     Args:
         run_name (`str`):
             The name of the experiment run
@@ -139,7 +106,6 @@ class TensorBoardTracker(GeneralTracker):
     """
     name = "tensorboard"
     requires_logging_directory = True
-
     @on_main_process
     def __init__(self, run_name: str, logging_dir: Union[str, os.PathLike], **kwargs):
         try:
@@ -154,17 +120,14 @@ class TensorBoardTracker(GeneralTracker):
         logger.debug(
             "Make sure to log any initial configurations with `self.store_init_configuration` before training!"
         )
-
     @property
     def tracker(self):
         return self.writer
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment. Stores the
         hyperparameters in a yaml file for future use.
-
         Args:
             values (Dictionary `str` to `bool`, `str`, `float` or `int`):
                 Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,
@@ -182,12 +145,10 @@ class TensorBoardTracker(GeneralTracker):
                 logger.error("Serialization to store hyperparameters failed")
                 raise
         logger.debug("Stored initial configuration hyperparameters to TensorBoard and hparams yaml file")
-
     @on_main_process
     def log(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `values` to the current run.
-
         Args:
             values (Dictionary `str` to `str`, `float`, `int` or `dict` of `str` to `float`/`int`):
                 Values to be logged as key-value pairs. The values need to have type `str`, `float`, `int` or `dict` of
@@ -208,12 +169,10 @@ class TensorBoardTracker(GeneralTracker):
                 self.writer.add_scalars(k, v, global_step=step, **kwargs)
         self.writer.flush()
         logger.debug("Successfully logged to TensorBoard")
-
     @on_main_process
     def log_images(self, values: dict, step: Optional[int], **kwargs):
         """
         Logs `images` to the current run.
-
         Args:
             values (Dictionary `str` to `List` of `np.ndarray` or `PIL.Image`):
                 Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or
@@ -225,7 +184,6 @@ class TensorBoardTracker(GeneralTracker):
         for k, v in values.items():
             self.writer.add_images(k, v, global_step=step, **kwargs)
         logger.debug("Successfully logged images to TensorBoard")
-
     @on_main_process
     def finish(self):
         """
@@ -233,12 +191,9 @@ class TensorBoardTracker(GeneralTracker):
         """
         self.writer.close()
         logger.debug("TensorBoard writer closed")
-
-
 class WandBTracker(GeneralTracker):
     """
     A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.
-
     Args:
         run_name (`str`):
             The name of the experiment run.
@@ -248,44 +203,35 @@ class WandBTracker(GeneralTracker):
     name = "wandb"
     requires_logging_directory = False
     main_process_only = False
-
     @on_main_process
     def __init__(self, run_name: str, **kwargs):
         super().__init__()
         self.run_name = run_name
-
         import wandb
-
         self.run = wandb.init(project=self.run_name, **kwargs)
         logger.debug(f"Initialized WandB project {self.run_name}")
         logger.debug(
             "Make sure to log any initial configurations with `self.store_init_configuration` before training!"
         )
-
     @property
     def tracker(self):
         return self.run
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.
-
         Args:
             values (Dictionary `str` to `bool`, `str`, `float` or `int`):
                 Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,
                 `str`, `float`, `int`, or `None`.
         """
         import wandb
-
         wandb.config.update(values, allow_val_change=True)
         logger.debug("Stored initial configuration hyperparameters to WandB")
-
     @on_main_process
     def log(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `values` to the current run.
-
         Args:
             values (Dictionary `str` to `str`, `float`, `int` or `dict` of `str` to `float`/`int`):
                 Values to be logged as key-value pairs. The values need to have type `str`, `float`, `int` or `dict` of
@@ -297,12 +243,10 @@ class WandBTracker(GeneralTracker):
         """
         self.run.log(values, step=step, **kwargs)
         logger.debug("Successfully logged to WandB")
-
     @on_main_process
     def log_images(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `images` to the current run.
-
         Args:
             values (Dictionary `str` to `List` of `np.ndarray` or `PIL.Image`):
                 Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or
@@ -312,11 +256,9 @@ class WandBTracker(GeneralTracker):
                 Additional key word arguments passed along to the `wandb.log` method.
         """
         import wandb
-
         for k, v in values.items():
             self.log({k: [wandb.Image(image) for image in v]}, step=step, **kwargs)
         logger.debug("Successfully logged images to WandB")
-
     @on_main_process
     def log_table(
         self,
@@ -330,7 +272,6 @@ class WandBTracker(GeneralTracker):
         """
         Log a Table containing any object type (text, image, audio, video, molecule, html, etc). Can be defined either
         with `columns` and `data` or with `dataframe`.
-
         Args:
             table_name (`str`):
                 The name to give to the logged table on the wandb workspace
@@ -344,10 +285,8 @@ class WandBTracker(GeneralTracker):
                 The run step. If included, the log will be affiliated with this step.
         """
         import wandb
-
         values = {table_name: wandb.Table(columns=columns, data=data, dataframe=dataframe)}
         self.log(values, step=step, **kwargs)
-
     @on_main_process
     def finish(self):
         """
@@ -355,14 +294,10 @@ class WandBTracker(GeneralTracker):
         """
         self.run.finish()
         logger.debug("WandB run closed")
-
-
 class CometMLTracker(GeneralTracker):
     """
     A `Tracker` class that supports `comet_ml`. Should be initialized at the start of your script.
-
     API keys must be stored in a Comet config file.
-
     Args:
         run_name (`str`):
             The name of the experiment run.
@@ -371,29 +306,23 @@ class CometMLTracker(GeneralTracker):
     """
     name = "comet_ml"
     requires_logging_directory = False
-
     @on_main_process
     def __init__(self, run_name: str, **kwargs):
         super().__init__()
         self.run_name = run_name
-
         from comet_ml import Experiment
-
         self.writer = Experiment(project_name=run_name, **kwargs)
         logger.debug(f"Initialized CometML project {self.run_name}")
         logger.debug(
             "Make sure to log any initial configurations with `self.store_init_configuration` before training!"
         )
-
     @property
     def tracker(self):
         return self.writer
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.
-
         Args:
             values (Dictionary `str` to `bool`, `str`, `float` or `int`):
                 Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,
@@ -401,12 +330,10 @@ class CometMLTracker(GeneralTracker):
         """
         self.writer.log_parameters(values)
         logger.debug("Stored initial configuration hyperparameters to CometML")
-
     @on_main_process
     def log(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `values` to the current run.
-
         Args:
             values (Dictionary `str` to `str`, `float`, `int` or `dict` of `str` to `float`/`int`):
                 Values to be logged as key-value pairs. The values need to have type `str`, `float`, `int` or `dict` of
@@ -427,7 +354,6 @@ class CometMLTracker(GeneralTracker):
             elif isinstance(v, dict):
                 self.writer.log_metrics(v, step=step, **kwargs)
         logger.debug("Successfully logged to CometML")
-
     @on_main_process
     def finish(self):
         """
@@ -435,12 +361,9 @@ class CometMLTracker(GeneralTracker):
         """
         self.writer.end()
         logger.debug("CometML run closed")
-
-
 class AimTracker(GeneralTracker):
     """
     A `Tracker` class that supports `aim`. Should be initialized at the start of your script.
-
     Args:
         run_name (`str`):
             The name of the experiment run.
@@ -449,40 +372,32 @@ class AimTracker(GeneralTracker):
     """
     name = "aim"
     requires_logging_directory = True
-
     @on_main_process
     def __init__(self, run_name: str, logging_dir: Optional[Union[str, os.PathLike]] = ".", **kwargs):
         self.run_name = run_name
-
         from aim import Run
-
         self.writer = Run(repo=logging_dir, **kwargs)
         self.writer.name = self.run_name
         logger.debug(f"Initialized Aim project {self.run_name}")
         logger.debug(
             "Make sure to log any initial configurations with `self.store_init_configuration` before training!"
         )
-
     @property
     def tracker(self):
         return self.writer
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.
-
         Args:
             values (`dict`):
                 Values to be stored as initial hyperparameters as key-value pairs.
         """
         self.writer["hparams"] = values
-
     @on_main_process
     def log(self, values: dict, step: Optional[int], **kwargs):
         """
         Logs `values` to the current run.
-
         Args:
             values (`dict`):
                 Values to be logged as key-value pairs.
@@ -494,12 +409,10 @@ class AimTracker(GeneralTracker):
         # Note: replace this with the dictionary support when merged
         for key, value in values.items():
             self.writer.track(value, name=key, step=step, **kwargs)
-
     @on_main_process
     def log_images(self, values: dict, step: Optional[int] = None, kwargs: Optional[Dict[str, dict]] = None):
         """
         Logs `images` to the current run.
-
         Args:
             values (`Dict[str, Union[np.ndarray, PIL.Image, Tuple[np.ndarray, str], Tuple[PIL.Image, str]]]`):
                 Values to be logged as key-value pairs. The values need to have type `np.ndarray` or PIL.Image. If a
@@ -511,14 +424,11 @@ class AimTracker(GeneralTracker):
                 keys `aim_image` and `track`, respectively.
         """
         import aim
-
         aim_image_kw = {}
         track_kw = {}
-
         if kwargs is not None:
             aim_image_kw = kwargs.get("aim_image", {})
             track_kw = kwargs.get("track", {})
-
         for key, value in values.items():
             if isinstance(value, tuple):
                 img, caption = value
@@ -526,19 +436,15 @@ class AimTracker(GeneralTracker):
                 img, caption = value, ""
             aim_image = aim.Image(img, caption=caption, **aim_image_kw)
             self.writer.track(aim_image, name=key, step=step, **track_kw)
-
     @on_main_process
     def finish(self):
         """
         Closes `aim` writer
         """
         self.writer.close()
-
-
 class MLflowTracker(GeneralTracker):
     """
     A `Tracker` class that supports `mlflow`. Should be initialized at the start of your script.
-
     Args:
         experiment_name (`str`, *optional*):
             Name of the experiment. Environment variable MLFLOW_EXPERIMENT_NAME has priority over this argument.
@@ -564,7 +470,6 @@ class MLflowTracker(GeneralTracker):
     """
     name = "mlflow"
     requires_logging_directory = False
-
     @on_main_process
     def __init__(
         self,
@@ -581,11 +486,8 @@ class MLflowTracker(GeneralTracker):
         tags = os.getenv("MLFLOW_TAGS", tags)
         if isinstance(tags, str):
             tags = json.loads(tags)
-
         nested_run = os.getenv("MLFLOW_NESTED_RUN", nested_run)
-
         import mlflow
-
         exps = mlflow.search_experiments(filter_string=f"name = '{experiment_name}'")
         if len(exps) > 0:
             if len(exps) > 1:
@@ -597,7 +499,6 @@ class MLflowTracker(GeneralTracker):
                 artifact_location=logging_dir,
                 tags=tags,
             )
-
         self.active_run = mlflow.start_run(
             run_id=run_id,
             experiment_id=experiment_id,
@@ -606,27 +507,22 @@ class MLflowTracker(GeneralTracker):
             tags=tags,
             description=description,
         )
-
         logger.debug(f"Initialized mlflow experiment {experiment_name}")
         logger.debug(
             "Make sure to log any initial configurations with `self.store_init_configuration` before training!"
         )
-
     @property
     def tracker(self):
         return self.active_run
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.
-
         Args:
             values (`dict`):
                 Values to be stored as initial hyperparameters as key-value pairs.
         """
         import mlflow
-
         for name, value in list(values.items()):
             # internally, all values are converted to str in MLflow
             if len(str(value)) > mlflow.utils.validation.MAX_PARAM_VAL_LENGTH:
@@ -635,20 +531,15 @@ class MLflowTracker(GeneralTracker):
                     f" log_param() only accepts values no longer than {mlflow.utils.validation.MAX_PARAM_VAL_LENGTH} characters so we dropped this attribute."
                 )
                 del values[name]
-
         values_list = list(values.items())
-
         # MLflow cannot log more than 100 values in one go, so we have to split it
         for i in range(0, len(values_list), mlflow.utils.validation.MAX_PARAMS_TAGS_PER_BATCH):
             mlflow.log_params(dict(values_list[i : i + mlflow.utils.validation.MAX_PARAMS_TAGS_PER_BATCH]))
-
         logger.debug("Stored initial configuration hyperparameters to MLflow")
-
     @on_main_process
     def log(self, values: dict, step: Optional[int]):
         """
         Logs `values` to the current run.
-
         Args:
             values (`dict`):
                 Values to be logged as key-value pairs.
@@ -665,24 +556,18 @@ class MLflowTracker(GeneralTracker):
                     "MLflow's log_metric() only accepts float and int types so we dropped this attribute."
                 )
         import mlflow
-
         mlflow.log_metrics(metrics, step=step)
         logger.debug("Successfully logged to mlflow")
-
     @on_main_process
     def finish(self):
         """
         End the active MLflow run.
         """
         import mlflow
-
         mlflow.end_run()
-
-
 class ClearMLTracker(GeneralTracker):
     """
     A `Tracker` class that supports `clearml`. Should be initialized at the start of your script.
-
     Args:
         run_name (`str`, *optional*):
             Name of the experiment. Environment variables `CLEARML_PROJECT` and `CLEARML_TASK` have priority over this
@@ -692,43 +577,35 @@ class ClearMLTracker(GeneralTracker):
     """
     name = "clearml"
     requires_logging_directory = False
-
     @on_main_process
     def __init__(self, run_name: str = None, **kwargs):
         from clearml import Task
-
         current_task = Task.current_task()
         self._initialized_externally = False
         if current_task:
             self._initialized_externally = True
             self.task = current_task
             return
-
         kwargs.setdefault("project_name", os.environ.get("CLEARML_PROJECT", run_name))
         kwargs.setdefault("task_name", os.environ.get("CLEARML_TASK", run_name))
         self.task = Task.init(**kwargs)
-
     @property
     def tracker(self):
         return self.task
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Connect configuration dictionary to the Task object. Should be run at the beginning of your experiment.
-
         Args:
             values (`dict`):
                 Values to be stored as initial hyperparameters as key-value pairs.
         """
         return self.task.connect_configuration(values)
-
     @on_main_process
     def log(self, values: Dict[str, Union[int, float]], step: Optional[int] = None, **kwargs):
         """
         Logs `values` dictionary to the current run. The dictionary keys must be strings. The dictionary values must be
         ints or floats
-
         Args:
             values (`Dict[str, Union[int, float]]`):
                 Values to be logged as key-value pairs. If the key starts with 'eval_'/'test_'/'train_', the value will
@@ -756,12 +633,10 @@ class ClearMLTracker(GeneralTracker):
                 continue
             title, series = ClearMLTracker._get_title_series(k)
             clearml_logger.report_scalar(title=title, series=series, value=v, iteration=step, **kwargs)
-
     @on_main_process
     def log_images(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `images` to the current run.
-
         Args:
             values (`Dict[str, List[Union[np.ndarray, PIL.Image]]`):
                 Values to be logged as key-value pairs. The values need to have type `List` of `np.ndarray` or
@@ -774,7 +649,6 @@ class ClearMLTracker(GeneralTracker):
         for k, v in values.items():
             title, series = ClearMLTracker._get_title_series(k)
             clearml_logger.report_image(title=title, series=series, iteration=step, image=v, **kwargs)
-
     @on_main_process
     def log_table(
         self,
@@ -787,7 +661,6 @@ class ClearMLTracker(GeneralTracker):
     ):
         """
         Log a Table to the task. Can be defined eitherwith `columns` and `data` or with `dataframe`.
-
         Args:
             table_name (`str`):
                 The name of the table
@@ -812,7 +685,6 @@ class ClearMLTracker(GeneralTracker):
             to_report = [columns] + data if columns else data
         title, series = ClearMLTracker._get_title_series(table_name)
         self.task.get_logger().report_table(title=title, series=series, table_plot=to_report, iteration=step, **kwargs)
-
     @on_main_process
     def finish(self):
         """
@@ -821,66 +693,52 @@ class ClearMLTracker(GeneralTracker):
         """
         if self.task and not self._initialized_externally:
             self.task.close()
-
     @staticmethod
     def _get_title_series(name):
         for prefix in ["eval", "test", "train"]:
             if name.startswith(prefix + "_"):
                 return name[len(prefix) + 1 :], prefix
         return name, "train"
-
-
 class DVCLiveTracker(GeneralTracker):
     """
     A `Tracker` class that supports `dvclive`. Should be initialized at the start of your script.
-
     Args:
         run_name (`str`, *optional*):
             Ignored for dvclive. See `kwargs` instead.
         kwargs:
             Additional key word arguments passed along to [`dvclive.Live()`](https://dvc.org/doc/dvclive/live).
-
     Example:
-
     ```py
     from accelerate import Accelerator
-
     accelerator = Accelerator(log_with="dvclive")
     accelerator.init_trackers(project_name="my_project", init_kwargs={"dvclive": {"dir": "my_directory"}})
     ```
     """
     name = "dvclive"
     requires_logging_directory = False
-
     @on_main_process
     def __init__(self, run_name: Optional[str] = None, live: Optional[Any] = None, **kwargs):
         from dvclive import Live
-
         super().__init__()
         self.live = live if live is not None else Live(**kwargs)
-
     @property
     def tracker(self):
         return self.live
-
     @on_main_process
     def store_init_configuration(self, values: dict):
         """
         Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment. Stores the
         hyperparameters in a yaml file for future use.
-
         Args:
             values (Dictionary `str` to `bool`, `str`, `float`, `int`, or a List or Dict of those types):
                 Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,
                 `str`, `float`, or `int`.
         """
         self.live.log_params(values)
-
     @on_main_process
     def log(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `values` to the current run.
-
         Args:
             values (Dictionary `str` to `str`, `float`, or `int`):
                 Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.
@@ -890,7 +748,6 @@ class DVCLiveTracker(GeneralTracker):
                 Additional key word arguments passed along to `dvclive.Live.log_metric()`.
         """
         from dvclive.plots import Metric
-
         if step is not None:
             self.live.step = step
         for k, v in values.items():
@@ -903,15 +760,12 @@ class DVCLiveTracker(GeneralTracker):
                     "This invocation of DVCLive's Live.log_metric() "
                     "is incorrect so we dropped this attribute."
                 )
-
     @on_main_process
     def finish(self):
         """
         Closes `dvclive.Live()`.
         """
         self.live.end()
-
-
 LOGGER_TYPE_TO_CLASS = {
     "aim": AimTracker,
     "comet_ml": CometMLTracker,
@@ -921,8 +775,6 @@ LOGGER_TYPE_TO_CLASS = {
     "clearml": ClearMLTracker,
     "dvclive": DVCLiveTracker,
 }
-
-
 def filter_trackers(
     log_with: List[Union[str, LoggerType, GeneralTracker]],
     logging_dir: Union[str, os.PathLike] = None,
@@ -933,11 +785,9 @@ def filter_trackers(
         - Filters out repeats of tracker types
         - If `all` is in `log_with`, will return all trackers in the environment
         - If a tracker requires a `logging_dir`, ensures that `logging_dir` is not `None`
-
     Args:
         log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):
             A list of loggers to be setup for experiment tracking. Should be one or several of:
-
             - `"all"`
             - `"tensorboard"`
             - `"wandb"`
@@ -974,5 +824,4 @@ def filter_trackers(
                             loggers.append(log_type)
                         else:
                             logger.debug(f"Tried adding logger {log_type}, but package is unavailable in the system.")
-
     return loggers

src/utils/bnb.py

@@ -1,6 +1,4 @@
 logger = logging.getLogger(__name__)
-
-
 def load_and_quantize_model(
     model: torch.nn.Module,
     bnb_quantization_config: BnbQuantizationConfig,
@@ -15,7 +13,6 @@ def load_and_quantize_model(
     This function will quantize the input model with the associated config passed in `bnb_quantization_config`. If the
     model is in the meta device, we will load and dispatch the weights according to the `device_map` passed. If the
     model is already loaded, we will quantize the model and put the model on the GPU,
-
     Args:
         model (`torch.nn.Module`):
             Input model. The model can be already loaded or on the meta device
@@ -40,13 +37,11 @@ def load_and_quantize_model(
         offload_state_dict (`bool`, *optional*, defaults to `False`):
             If `True`, will temporarily offload the CPU state dict on the hard drive to avoid getting out of CPU RAM if
             the weight of the CPU state dict + the biggest shard does not fit.
-
     Returns:
         `torch.nn.Module`: The quantized model
     """
     load_in_4bit = bnb_quantization_config.load_in_4bit
     load_in_8bit = bnb_quantization_config.load_in_8bit
-
     if load_in_8bit and not is_8bit_bnb_available():
         raise ImportError(
             "You have a version of `bitsandbytes` that is not compatible with 8bit quantization,"
@@ -57,31 +52,25 @@ def load_and_quantize_model(
             "You have a version of `bitsandbytes` that is not compatible with 4bit quantization,"
             "make sure you have the latest version of `bitsandbytes` installed."
         )
-
     modules_on_cpu = []
     # custom device map
     if isinstance(device_map, dict) and len(device_map.keys()) > 1:
         modules_on_cpu = [key for key, value in device_map.items() if value in ["disk", "cpu"]]
-
     # We keep some modules such as the lm_head in their original dtype for numerical stability reasons
     if bnb_quantization_config.skip_modules is None:
         bnb_quantization_config.skip_modules = get_keys_to_not_convert(model)
-
     # add cpu modules to skip modules only for 4-bit modules
     if load_in_4bit:
         bnb_quantization_config.skip_modules.extend(modules_on_cpu)
     modules_to_not_convert = bnb_quantization_config.skip_modules
-
     # We add the modules we want to keep in full precision
     if bnb_quantization_config.keep_in_fp32_modules is None:
         bnb_quantization_config.keep_in_fp32_modules = []
     keep_in_fp32_modules = bnb_quantization_config.keep_in_fp32_modules
     modules_to_not_convert.extend(keep_in_fp32_modules)
-
     # compatibility with peft
     model.is_loaded_in_4bit = load_in_4bit
     model.is_loaded_in_8bit = load_in_8bit
-
     model_device = get_parameter_device(model)
     if model_device.type != "meta":
         # quantization of an already loaded model
@@ -115,18 +104,15 @@ def load_and_quantize_model(
             "We move the model to cuda."
         )
         return model
-
     elif weights_location is None:
         raise RuntimeError(
             f"`weights_location` needs to be the folder path containing the weights of the model, but we found {weights_location} "
         )
-
     else:
         with init_empty_weights():
             model = replace_with_bnb_layers(
                 model, bnb_quantization_config, modules_to_not_convert=modules_to_not_convert
             )
-
         device_map = get_quantized_model_device_map(
             model,
             bnb_quantization_config,
@@ -136,9 +122,7 @@ def load_and_quantize_model(
         )
         if offload_state_dict is None and device_map is not None and "disk" in device_map.values():
             offload_state_dict = True
-
         offload = any(x in list(device_map.values()) for x in ["cpu", "disk"])
-
         load_checkpoint_in_model(
             model,
             weights_location,
@@ -150,8 +134,6 @@ def load_and_quantize_model(
             offload_8bit_bnb=load_in_8bit and offload,
         )
         return dispatch_model(model, device_map=device_map, offload_dir=offload_folder)
-
-
 def get_quantized_model_device_map(
     model, bnb_quantization_config, device_map=None, max_memory=None, no_split_module_classes=None
 ):
@@ -161,14 +143,12 @@ def get_quantized_model_device_map(
         else:
             raise RuntimeError("No GPU found. A GPU is needed for quantization.")
         logger.info("The device_map was not initialized." "Setting device_map to `{'':torch.cuda.current_device()}`.")
-
     if isinstance(device_map, str):
         if device_map not in ["auto", "balanced", "balanced_low_0", "sequential"]:
             raise ValueError(
                 "If passing a string for `device_map`, please choose 'auto', 'balanced', 'balanced_low_0' or "
                 "'sequential'."
             )
-
         special_dtypes = {}
         special_dtypes.update(
             {
@@ -184,12 +164,10 @@ def get_quantized_model_device_map(
                 if any(m in name for m in bnb_quantization_config.keep_in_fp32_modules)
             }
         )
-
         kwargs = {}
         kwargs["special_dtypes"] = special_dtypes
         kwargs["no_split_module_classes"] = no_split_module_classes
         kwargs["dtype"] = bnb_quantization_config.target_dtype
-
         # get max_memory for each device.
         if device_map != "sequential":
             max_memory = get_balanced_memory(
@@ -198,14 +176,11 @@ def get_quantized_model_device_map(
                 max_memory=max_memory,
                 **kwargs,
             )
-
         kwargs["max_memory"] = max_memory
         device_map = infer_auto_device_map(model, **kwargs)
-
     if isinstance(device_map, dict):
         # check if don't have any quantized module on the cpu
         modules_not_to_convert = bnb_quantization_config.skip_modules + bnb_quantization_config.keep_in_fp32_modules
-
         device_map_without_some_modules = {
             key: device_map[key] for key in device_map.keys() if key not in modules_not_to_convert
         }
@@ -228,13 +203,10 @@ def get_quantized_model_device_map(
                     )
         del device_map_without_some_modules
     return device_map
-
-
 def replace_with_bnb_layers(model, bnb_quantization_config, modules_to_not_convert=None, current_key_name=None):
     """
     A helper function to replace all `torch.nn.Linear` modules by `bnb.nn.Linear8bit` modules or by `bnb.nn.Linear4bit`
     modules from the `bitsandbytes`library. The function will be run recursively and replace `torch.nn.Linear` modules.
-
     Parameters:
         model (`torch.nn.Module`):
             Input model or `torch.nn.Module` as the function is run recursively.
@@ -247,7 +219,6 @@ def replace_with_bnb_layers(model, bnb_quantization_config, modules_to_not_conve
     """
     if modules_to_not_convert is None:
         modules_to_not_convert = []
-
     model, has_been_replaced = _replace_with_bnb_layers(
         model, bnb_quantization_config, modules_to_not_convert, current_key_name
     )
@@ -259,8 +230,6 @@ def replace_with_bnb_layers(model, bnb_quantization_config, modules_to_not_conve
             " a bug."
         )
     return model
-
-
 def _replace_with_bnb_layers(
     model,
     bnb_quantization_config,
@@ -269,12 +238,10 @@ def _replace_with_bnb_layers(
 ):
     """
     Private method that wraps the recursion for module replacement.
-
     Returns the converted model and a boolean that indicates if the conversion has been successfull or not.
     """
     # bitsandbytes will initialize CUDA on import, so it needs to be imported lazily
     import bitsandbytes as bnb
-
     has_been_replaced = False
     for name, module in model.named_children():
         if current_key_name is None:
@@ -325,15 +292,12 @@ def _replace_with_bnb_layers(
         # Remove the last key for recursion
         current_key_name.pop(-1)
     return model, has_been_replaced
-
-
 def get_keys_to_not_convert(model):
     r"""
     An utility function to get the key of the module to keep in full precision if any For example for CausalLM modules
     we may want to keep the lm_head in full precision for numerical stability reasons. For other architectures, we want
     to keep the tied weights of the model. The function will return a list of the keys of the modules to not convert in
     int8.
-
     Parameters:
     model (`torch.nn.Module`):
         Input model
@@ -341,7 +305,6 @@ def get_keys_to_not_convert(model):
     # Create a copy of the model
     with init_empty_weights():
         tied_model = deepcopy(model)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
-
     tied_params = find_tied_parameters(tied_model)
     # For compatibility with Accelerate < 0.18
     if isinstance(tied_params, dict):
@@ -349,24 +312,19 @@ def get_keys_to_not_convert(model):
     else:
         tied_keys = sum(tied_params, [])
     has_tied_params = len(tied_keys) > 0
-
     # Check if it is a base model
     is_base_model = False
     if hasattr(model, "base_model_prefix"):
         is_base_model = not hasattr(model, model.base_model_prefix)
-
     # Ignore this for base models (BertModel, GPT2Model, etc.)
     if (not has_tied_params) and is_base_model:
         return []
-
     # otherwise they have an attached head
     list_modules = list(model.named_children())
     list_last_module = [list_modules[-1][0]]
-
     # add last module together with tied weights
     intersection = set(list_last_module) - set(tied_keys)
     list_untouched = list(set(tied_keys)) + list(intersection)
-
     # remove ".weight" from the keys
     names_to_remove = [".weight", ".bias"]
     filtered_module_names = []
@@ -375,25 +333,17 @@ def get_keys_to_not_convert(model):
             if name_to_remove in name:
                 name = name.replace(name_to_remove, "")
         filtered_module_names.append(name)
-
     return filtered_module_names
-
-
 def has_4bit_bnb_layers(model):
     """Check if we have `bnb.nn.Linear4bit` or `bnb.nn.Linear8bitLt` layers inside our model"""
     # bitsandbytes will initialize CUDA on import, so it needs to be imported lazily
     import bitsandbytes as bnb
-
     for m in model.modules():
         if isinstance(m, bnb.nn.Linear4bit):
             return True
     return False
-
-
 def get_parameter_device(parameter: nn.Module):
     return next(parameter.parameters()).device
-
-
 def quantize_and_offload_8bit(model, param, param_name, new_dtype, offload_folder, offload_index, fp16_statistics):
     # if it is not quantized, we quantize and offload the quantized weights and the SCB stats
     if fp16_statistics is None:
@@ -421,5 +371,4 @@ def quantize_and_offload_8bit(model, param, param_name, new_dtype, offload_folde
     else:
         offload_weight(param, param_name, offload_folder, index=offload_index)
         offload_weight(fp16_statistics, param_name.replace("weight", "SCB"), offload_folder, index=offload_index)
-
     set_module_tensor_to_device(model, param_name, "meta", dtype=new_dtype, value=torch.empty(*param.size()))

src/utils/constants.py

@@ -21,9 +21,7 @@ FSDP_PYTORCH_VERSION = "2.1.0"
 FSDP_MODEL_NAME = "pytorch_model_fsdp"
 DEEPSPEED_MULTINODE_LAUNCHERS = ["pdsh", "standard", "openmpi", "mvapich", "mpich"]
 TORCH_DYNAMO_MODES = ["default", "reduce-overhead", "max-autotune"]
-
 STR_OPERATION_TO_FUNC = {">": op.gt, ">=": op.ge, "==": op.eq, "!=": op.ne, "<=": op.le, "<": op.lt}
-
 # These are the args for `torch.distributed.launch` for pytorch < 1.9
 TORCH_LAUNCH_PARAMS = [
     "nnodes",
@@ -50,6 +48,5 @@ TORCH_LAUNCH_PARAMS = [
     "master_addr",
     "master_port",
 ]
-
 CUDA_DISTRIBUTED_TYPES = ["DEEPSPEED", "MULTI_GPU", "FSDP", "MEGATRON_LM"]
 TORCH_DISTRIBUTED_OPERATION_TYPES = CUDA_DISTRIBUTED_TYPES + ["MULTI_NPU", "MULTI_XPU", "MULTI_CPU"]

src/utils/dataclasses.py

@@ -7,41 +7,32 @@ class KwargsHandler:
     """
     def to_dict(self):
         return copy.deepcopy(self.__dict__)
-
     def to_kwargs(self):
         """
         Returns a dictionary containing the attributes with values different from the default of this class.
         """
         # import clear_environment here to avoid circular import problem
         from .other import clear_environment
-
         with clear_environment():
             default_dict = self.__class__().to_dict()
         this_dict = self.to_dict()
         return {k: v for k, v in this_dict.items() if default_dict[k] != v}
-
-
 @dataclass
 class AutocastKwargs(KwargsHandler):
     """
     Use this object in your [`Accelerator`] to customize how `torch.autocast` behaves. Please refer to the
     documentation of this [context manager](https://pytorch.org/docs/stable/amp.html#torch.autocast) for more
     information on each argument.
-
     Example:
-
     ```python
     from accelerate import Accelerator
     from accelerate.utils import AutocastKwargs
-
     kwargs = AutocastKwargs(cache_enabled=True)
     accelerator = Accelerator(kwargs_handlers=[kwargs])
     ```
     """
     enabled: bool = True
     cache_enabled: bool = None
-
-
 @dataclass
 class DistributedDataParallelKwargs(KwargsHandler):
     """
@@ -49,21 +40,14 @@ class DistributedDataParallelKwargs(KwargsHandler):
     `torch.nn.parallel.DistributedDataParallel`. Please refer to the documentation of this
     [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) for more
     information on each argument.
-
     <Tip warning={true}>
-
     `gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.
-
     `static_graph` is only available in PyTorch 1.11.0 and later versions.
-
     </Tip>
-
     Example:
-
     ```python
     from accelerate import Accelerator
     from accelerate.utils import DistributedDataParallelKwargs
-
     kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
     accelerator = Accelerator(kwargs_handlers=[kwargs])
     ```
@@ -75,27 +59,19 @@ class DistributedDataParallelKwargs(KwargsHandler):
     check_reduction: bool = False
     gradient_as_bucket_view: bool = False
     static_graph: bool = False
-
-
 @dataclass
 class GradScalerKwargs(KwargsHandler):
     """
     Use this object in your [`Accelerator`] to customize the behavior of mixed precision, specifically how the
     `torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this
     [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) for more information on each argument.
-
     <Tip warning={true}>
-
     `GradScaler` is only available in PyTorch 1.5.0 and later versions.
-
     </Tip>
-
     Example:
-
     ```python
     from accelerate import Accelerator
     from accelerate.utils import GradScalerKwargs
-
     kwargs = GradScalerKwargs(backoff_filter=0.25)
     accelerator = Accelerator(kwargs_handlers=[kwargs])
     ```
@@ -105,8 +81,6 @@ class GradScalerKwargs(KwargsHandler):
     backoff_factor: float = 0.5
     growth_interval: int = 2000
     enabled: bool = True
-
-
 @dataclass
 class InitProcessGroupKwargs(KwargsHandler):
     """
@@ -114,12 +88,10 @@ class InitProcessGroupKwargs(KwargsHandler):
     to the documentation of this
     [method](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) for more
     information on each argument.
-
     ```python
     from datetime import timedelta
     from accelerate import Accelerator
     from accelerate.utils import InitProcessGroupKwargs
-
     kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
     accelerator = Accelerator(kwargs_handlers=[kwargs])
     ```
@@ -127,45 +99,32 @@ class InitProcessGroupKwargs(KwargsHandler):
     backend: Optional[str] = "nccl"
     init_method: Optional[str] = None
     timeout: timedelta = timedelta(seconds=1800)
-
-
 # Literals
 Backend = Literal["msamp", "te"]
 OptLevel = Literal["O1", "O2"]
 FP8Format = Literal["E4M3", "HYBRID"]
 AmaxComputeAlgorithm = Literal["max", "most_recent"]
-
-
 @dataclass
 class FP8RecipeKwargs(KwargsHandler):
     """
     Use this object in your [`Accelerator`] to customize the initialization of the recipe for FP8 mixed precision
     training with `transformer-engine` or `ms-amp`.
-
     <Tip>
-
         For more information on `transformer-engine` args, please refer to the API
         [documentation](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/api/common.html).
-
         For more information on the `ms-amp` args, please refer to the Optimization Level
         [documentation](https://azure.github.io/MS-AMP/docs/user-tutorial/optimization-level).
-
     </Tip>
-
     ```python
     from accelerate import Accelerator
     from accelerate.utils import FP8RecipeKwargs
-
     kwargs = FP8RecipeKwargs(backend="te", fp8_format="HYBRID")
     accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=[kwargs])
     ```
-
     To use MS-AMP as an engine, pass `backend="msamp"` and the `optimization_level`:
-
     ```python
     kwargs = FP8RecipeKwargs(backend="msamp", optimization_level="02")
     ```
-
     Args:
         backend (`str`, *optional*, defaults to "msamp"):
             Which FP8 engine to use. Must be one of `"msamp"` (MS-AMP) or `"te"` (TransformerEngine).
@@ -200,7 +159,6 @@ class FP8RecipeKwargs(KwargsHandler):
     amax_history_len: int = 1
     amax_compute_algo: AmaxComputeAlgorithm = "most_recent"
     override_linear_precision: Tuple[bool, bool, bool] = (False, False, False)
-
     def __post_init__(self):
         self.backend = self.backend.upper()
         if self.backend not in get_args(Backend):
@@ -215,37 +173,26 @@ class FP8RecipeKwargs(KwargsHandler):
         elif self.backend == "MSAMP":
             if self.opt_level not in get_args(OptLevel):
                 raise ValueError(f"`optimization_level` must be one of {' or '.join(get_args(OptLevel))}")
-
-
 class EnumWithContains(enum.EnumMeta):
     "A metaclass that adds the ability to check if `self` contains an item with the `in` operator"
-
     def __contains__(cls, item):
         try:
             cls(item)
         except ValueError:
             return False
         return True
-
-
 class BaseEnum(enum.Enum, metaclass=EnumWithContains):
     "An enum class that can get the value of an item with `str(Enum.key)`"
-
     def __str__(self):
         return self.value
-
     @classmethod
     def list(cls):
         "Method to list all the possible items in `cls`"
         return list(map(str, cls))
-
-
 class DistributedType(str, enum.Enum):
     """
     Represents a type of distributed environment.
-
     Values:
-
         - **NO** -- Not a distributed environment, just a single process.
         - **MULTI_CPU** -- Distributed on multiple CPU nodes.
         - **MULTI_GPU** -- Distributed on multiple GPUs.
@@ -264,14 +211,10 @@ class DistributedType(str, enum.Enum):
     FSDP = "FSDP"
     TPU = "TPU"
     MEGATRON_LM = "MEGATRON_LM"
-
-
 class SageMakerDistributedType(str, enum.Enum):
     """
     Represents a type of distributed environment.
-
     Values:
-
         - **NO** -- Not a distributed environment, just a single process.
         - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.
         - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.
@@ -280,28 +223,20 @@ class SageMakerDistributedType(str, enum.Enum):
     NO = "NO"
     DATA_PARALLEL = "DATA_PARALLEL"
     MODEL_PARALLEL = "MODEL_PARALLEL"
-
-
 class ComputeEnvironment(str, enum.Enum):
     """
     Represents a type of the compute environment.
-
     Values:
-
         - **LOCAL_MACHINE** -- private/custom cluster hardware.
         - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.
     """
     # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.
     LOCAL_MACHINE = "LOCAL_MACHINE"
     AMAZON_SAGEMAKER = "AMAZON_SAGEMAKER"
-
-
 class DynamoBackend(str, BaseEnum):
     """
     Represents a dynamo backend (see https://github.com/pytorch/torchdynamo).
-
     Values:
-
         - **NO** -- Do not use torch dynamo.
         - **EAGER** -- Uses PyTorch to run the extracted GraphModule. This is quite useful in debugging TorchDynamo
           issues.
@@ -325,7 +260,6 @@ class DynamoBackend(str, BaseEnum):
         - **IPEX** -- Uses IPEX for inference on CPU. Inference only. [Read
           more](https://github.com/intel/intel-extension-for-pytorch).
         - **TVM** -- Uses Apach TVM for inference optimizations. [Read more](https://tvm.apache.org/)
-
     """
     # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.
     NO = "NO"
@@ -341,13 +275,9 @@ class DynamoBackend(str, BaseEnum):
     TENSORRT = "TENSORRT"
     IPEX = "IPEX"
     TVM = "TVM"
-
-
 class LoggerType(BaseEnum):
     """Represents a type of supported experiment tracker
-
     Values:
-
         - **ALL** -- all available trackers in the environment that are supported
         - **TENSORBOARD** -- TensorBoard as an experiment tracker
         - **WANDB** -- wandb as an experiment tracker
@@ -362,13 +292,9 @@ class LoggerType(BaseEnum):
     MLFLOW = "mlflow"
     CLEARML = "clearml"
     DVCLIVE = "dvclive"
-
-
 class PrecisionType(BaseEnum):
     """Represents a type of precision used on floating point values
-
     Values:
-
         - **NO** -- using full precision (FP32)
         - **FP16** -- using half precision
         - **BF16** -- using brain floating point precision
@@ -377,8 +303,6 @@ class PrecisionType(BaseEnum):
     FP8 = "fp8"
     FP16 = "fp16"
     BF16 = "bf16"
-
-
 class RNGType(BaseEnum):
     TORCH = "torch"
     CUDA = "cuda"
@@ -386,25 +310,17 @@ class RNGType(BaseEnum):
     XLA = "xla"
     XPU = "xpu"
     GENERATOR = "generator"
-
-
 class CustomDtype(enum.Enum):
     r"""
     An enum that contains multiple custom dtypes that can be used for `infer_auto_device_map`.
     """
     FP8 = "fp8"
     INT4 = "int4"
-
-
 # data classes
-
-
 @dataclass
 class TensorInformation:
     shape: torch.Size
     dtype: torch.dtype
-
-
 @dataclass
 class ProjectConfiguration:
     """
@@ -421,17 +337,14 @@ class ProjectConfiguration:
         default=False,
         metadata={"help": "Whether saved states should be automatically iteratively named."},
     )
-
     total_limit: int = field(
         default=None,
         metadata={"help": "The maximum number of total saved states to keep."},
     )
-
     iteration: int = field(
         default=0,
         metadata={"help": "The current save iteration."},
     )
-
     save_on_each_node: bool = field(
         default=False,
         metadata={
@@ -441,17 +354,13 @@ class ProjectConfiguration:
             )
         },
     )
-
     def set_directories(self, project_dir: str = None):
         "Sets `self.project_dir` and `self.logging_dir` to the appropriate values."
         self.project_dir = project_dir
         if self.logging_dir is None:
             self.logging_dir = project_dir
-
     def __post_init__(self):
         self.set_directories(self.project_dir)
-
-
 @dataclass
 class GradientAccumulationPlugin(KwargsHandler):
     """
@@ -470,8 +379,6 @@ class GradientAccumulationPlugin(KwargsHandler):
             "help": "Whether to synchronize setting the gradients when at the end of the dataloader. Should only be set to `False` if you know what you're doing."
         },
     )
-
-
 @dataclass
 class TorchDynamoPlugin(KwargsHandler):
     """
@@ -488,7 +395,6 @@ class TorchDynamoPlugin(KwargsHandler):
     dynamic: bool = field(default=None, metadata={"help": "Whether to use dynamic shape for tracing"})
     options: Any = field(default=None, metadata={"help": "A dictionary of options to pass to the backend."})
     disable: bool = field(default=False, metadata={"help": "Turn torch.compile() into a no-op for testing"})
-
     def __post_init__(self):
         prefix = "ACCELERATE_DYNAMO_"
         if self.backend is None:
@@ -500,13 +406,10 @@ class TorchDynamoPlugin(KwargsHandler):
             self.fullgraph = str_to_bool(os.environ.get(prefix + "USE_FULLGRAPH", "False")) == 1
         if self.dynamic is None:
             self.dynamic = str_to_bool(os.environ.get(prefix + "USE_DYNAMIC", "False")) == 1
-
     def to_dict(self):
         dynamo_config = copy.deepcopy(self.__dict__)
         dynamo_config["backend"] = dynamo_config["backend"].value.lower()
         return dynamo_config
-
-
 @dataclass
 class DeepSpeedPlugin:
     """
@@ -560,41 +463,31 @@ class DeepSpeedPlugin:
         default=None,
         metadata={"help": "Flag to indicate whether to save 16-bit model. Only applicable with ZeRO Stage-3."},
     )
-
     def __post_init__(self):
         from .deepspeed import HfDeepSpeedConfig
-
         if self.gradient_accumulation_steps is None:
             gas = os.environ.get("ACCELERATE_GRADIENT_ACCUMULATION_STEPS", "auto")
             self.gradient_accumulation_steps = int(gas) if gas.isdigit() else gas
-
         if self.gradient_clipping is None:
             gradient_clipping = os.environ.get("ACCELERATE_GRADIENT_CLIPPING", "none")
             if gradient_clipping != "none":
                 self.gradient_clipping = float(gradient_clipping)
-
         if self.zero_stage is None:
             self.zero_stage = int(os.environ.get("ACCELERATE_DEEPSPEED_ZERO_STAGE", 2))
-
         if self.offload_optimizer_device is None:
             self.offload_optimizer_device = os.environ.get("ACCELERATE_DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE", "none")
-
         if self.offload_param_device is None:
             self.offload_param_device = os.environ.get("ACCELERATE_DEEPSPEED_OFFLOAD_PARAM_DEVICE", "none")
-
         if self.offload_optimizer_nvme_path is None:
             self.offload_optimizer_nvme_path = os.environ.get(
                 "ACCELERATE_DEEPSPEED_OFFLOAD_OPTIMIZER_NVME_PATH", "none"
             )
-
         if self.offload_param_nvme_path is None:
             self.offload_param_nvme_path = os.environ.get("ACCELERATE_DEEPSPEED_OFFLOAD_PARAM_NVME_PATH", "none")
-
         if self.zero3_save_16bit_model is None:
             self.zero3_save_16bit_model = (
                 os.environ.get("ACCELERATE_DEEPSPEED_ZERO3_SAVE_16BIT_MODEL", "false") == "true"
             )
-
         if self.hf_ds_config is None:
             self.hf_ds_config = os.environ.get("ACCELERATE_DEEPSPEED_CONFIG_FILE", "none")
         if (
@@ -608,7 +501,6 @@ class DeepSpeedPlugin:
                 self.hf_ds_config.config["gradient_accumulation_steps"] = 1
             if "zero_optimization" not in self.hf_ds_config.config:
                 raise ValueError("Please specify the ZeRO optimization config in the DeepSpeed config.")
-
             self._deepspeed_config_checks()
             plugin_to_config_mapping = {
                 "gradient_accumulation_steps": "gradient_accumulation_steps",
@@ -624,7 +516,6 @@ class DeepSpeedPlugin:
             for key in kwargs.keys():
                 self.fill_match(key, **kwargs, must_match=False)
             self.hf_ds_config.set_stage_and_offload()
-
             # filling the missing values in the class attributes from the DeepSpeed config
             # when using the DeepSpeed config file.
             for key, value in plugin_to_config_mapping.items():
@@ -654,7 +545,6 @@ class DeepSpeedPlugin:
             if self.gradient_clipping:
                 config["gradient_clipping"] = self.gradient_clipping
             self.hf_ds_config = HfDeepSpeedConfig(config)
-
         self.deepspeed_config = self.hf_ds_config.config
         self.deepspeed_config["steps_per_print"] = float("inf")  # this will stop deepspeed from logging @ stdout
         if self.zero3_init_flag is None:
@@ -664,13 +554,11 @@ class DeepSpeedPlugin:
         if self.zero3_init_flag and not self.hf_ds_config.is_zero3():
             warnings.warn("DeepSpeed Zero3 Init flag is only applicable for ZeRO Stage 3. Setting it to False.")
             self.zero3_init_flag = False
-
     def fill_match(self, ds_key_long, mismatches=None, must_match=True, **kwargs):
         mismatches = [] if mismatches is None else mismatches
         config, ds_key = self.hf_ds_config.find_config_node(ds_key_long)
         if config is None:
             return
-
         if config.get(ds_key) == "auto":
             if ds_key_long in kwargs:
                 config[ds_key] = kwargs[ds_key_long]
@@ -681,15 +569,12 @@ class DeepSpeedPlugin:
                     f"Please specify `{ds_key_long}` without `auto`(set to correct value) in the DeepSpeed config file or "
                     "pass it in kwargs."
                 )
-
         if not must_match:
             return
-
         ds_val = config.get(ds_key)
         if ds_val is not None and ds_key_long in kwargs:
             if ds_val != kwargs[ds_key_long]:
                 mismatches.append(f"- ds {ds_key_long}={ds_val} vs arg {ds_key_long}={kwargs[ds_key_long]}")
-
     def deepspeed_config_process(self, prefix="", mismatches=None, config=None, must_match=True, **kwargs):
         """Process the DeepSpeed config with the values from the kwargs."""
         mismatches = [] if mismatches is None else mismatches
@@ -708,7 +593,6 @@ class DeepSpeedPlugin:
                 "Please correct the following DeepSpeed config values that mismatch kwargs "
                 f" values:\n{mismatches_msg}\nThe easiest method is to set these DeepSpeed config values to 'auto'."
             )
-
     def set_mixed_precision(self, mixed_precision):
         ds_config = self.deepspeed_config
         kwargs = {
@@ -721,7 +605,6 @@ class DeepSpeedPlugin:
         elif mixed_precision == "bf16":
             if "bf16" not in ds_config:
                 ds_config["bf16"] = {"enabled": True}
-
         if mixed_precision != "no":
             diff_dtype = "bf16" if mixed_precision == "fp16" else "fp16"
             if str(ds_config.get(diff_dtype, {}).get("enabled", "False")).lower() == "true":
@@ -733,10 +616,8 @@ class DeepSpeedPlugin:
                 ds_config[dtype] = {"enabled": False}
         self.fill_match("fp16.enabled", must_match=False, **kwargs)
         self.fill_match("bf16.enabled", must_match=False, **kwargs)
-
     def set_deepspeed_weakref(self):
         from .imports import is_transformers_available
-
         if self.zero3_init_flag:
             if not is_transformers_available():
                 raise Exception(
@@ -753,17 +634,13 @@ class DeepSpeedPlugin:
                 ds_config["train_micro_batch_size_per_gpu"] = 1
             if ds_config.get("train_batch_size", None) == "auto":
                 del ds_config["train_batch_size"]
-
             if compare_versions("transformers", "<", "4.33"):
                 from transformers.deepspeed import HfDeepSpeedConfig
             else:
                 from transformers.integrations import HfDeepSpeedConfig
-
             self.dschf = HfDeepSpeedConfig(ds_config)  # keep this object alive # noqa
-
     def is_zero3_init_enabled(self):
         return self.zero3_init_flag
-
     @contextmanager
     def zero3_init_context_manager(self, enable=False):
         old = self.zero3_init_flag
@@ -777,7 +654,6 @@ class DeepSpeedPlugin:
             self.zero3_init_flag = old
             self.dschf = None
             self.set_deepspeed_weakref()
-
     def _deepspeed_config_checks(self):
         env_variable_names_to_ignore = [
             "ACCELERATE_GRADIENT_ACCUMULATION_STEPS",
@@ -793,9 +669,7 @@ class DeepSpeedPlugin:
         env_variable_names_to_ignore = [
             name.replace("ACCELERATE_", "").replace("DEEPSPEED_", "").lower() for name in env_variable_names_to_ignore
         ]
-
         deepspeed_fields_from_accelerate_config = os.environ.get("ACCELERATE_CONFIG_DS_FIELDS", "").split(",")
-
         if any(name in env_variable_names_to_ignore for name in deepspeed_fields_from_accelerate_config):
             raise ValueError(
                 f"When using `deepspeed_config_file`, the following accelerate config variables will be ignored: {env_variable_names_to_ignore}.\n"
@@ -804,8 +678,6 @@ class DeepSpeedPlugin:
                 "The easiest method is to create a new config following the questionnaire via `accelerate config`.\n"
                 "It will only ask for the necessary config variables when using `deepspeed_config_file`."
             )
-
-
 @dataclass
 class FullyShardedDataParallelPlugin:
     """
@@ -912,10 +784,8 @@ class FullyShardedDataParallelPlugin:
             "for reduced memory usage."
         },
     )
-
     def __post_init__(self):
         from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy
-
         prefix = "FSDP_"
         if self.sharding_strategy is None:
             sharding_strategy = os.environ.get(prefix + "SHARDING_STRATEGY", "FULL_SHARD")
@@ -925,18 +795,15 @@ class FullyShardedDataParallelPlugin:
                 else int(sharding_strategy)
             )
             self.sharding_strategy = ShardingStrategy(sharding_strategy)
-
         if self.cpu_offload is None:
             if str_to_bool(os.environ.get(prefix + "OFFLOAD_PARAMS", "False")) == 1:
                 self.cpu_offload = CPUOffload(offload_params=True)
             else:
                 self.cpu_offload = CPUOffload(offload_params=False)
-
         if self.backward_prefetch is None:
             prefetch_policy = os.environ.get(prefix + "BACKWARD_PREFETCH", "NO_PREFETCH")
             if prefetch_policy != FSDP_BACKWARD_PREFETCH[-1]:
                 self.backward_prefetch = BackwardPrefetch(FSDP_BACKWARD_PREFETCH.index(prefetch_policy) + 1)
-
         if self.state_dict_type is None:
             state_dict_type_policy = os.environ.get(prefix + "STATE_DICT_TYPE", "FULL_STATE_DICT")
             self.set_state_dict_type(state_dict_type_policy)
@@ -944,7 +811,6 @@ class FullyShardedDataParallelPlugin:
         self.sync_module_states = str_to_bool(os.environ.get(prefix + "SYNC_MODULE_STATES", "True")) == 1
         self.forward_prefetch = str_to_bool(os.environ.get(prefix + "FORWARD_PREFETCH", "False")) == 1
         self.activation_checkpointing = str_to_bool(os.environ.get(prefix + "ACTIVATION_CHECKPOINTING", "False")) == 1
-
         if self.sync_module_states:
             if is_npu_available():
                 device = torch.npu.current_device()
@@ -957,12 +823,10 @@ class FullyShardedDataParallelPlugin:
                     "There are currently no available devices found, must be one of 'XPU', 'CUDA', or 'NPU'."
                 )
             self.param_init_fn = lambda x: x.to_empty(device=device, recurse=False)
-
     @staticmethod
     def get_module_class_from_name(module, name):
         """
         Gets a class from a module by its name.
-
         Args:
             module (`torch.nn.Module`): The module to get the class from.
             name (`str`): The name of the class.
@@ -977,10 +841,8 @@ class FullyShardedDataParallelPlugin:
                 module_class = FullyShardedDataParallelPlugin.get_module_class_from_name(child_module, name)
                 if module_class is not None:
                     return module_class
-
     def set_auto_wrap_policy(self, model):
         from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy, transformer_auto_wrap_policy
-
         default_transformer_cls_names_to_wrap = (
             ",".join(model._no_split_modules) if getattr(model, "_no_split_modules", None) is not None else ""
         )
@@ -997,7 +859,6 @@ class FullyShardedDataParallelPlugin:
                         raise Exception("Could not find the transformer layer class to wrap in the model.")
                     else:
                         transformer_cls_to_wrap.add(transformer_cls)
-
                 self.auto_wrap_policy = functools.partial(
                     transformer_auto_wrap_policy,
                     # Transformer layer class to wrap
@@ -1009,7 +870,6 @@ class FullyShardedDataParallelPlugin:
                     self.auto_wrap_policy = functools.partial(
                         size_based_auto_wrap_policy, min_num_params=min_num_params
                     )
-
     def set_mixed_precision(self, mixed_precision):
         if mixed_precision == "fp16":
             dtype = torch.float16
@@ -1018,26 +878,20 @@ class FullyShardedDataParallelPlugin:
         else:
             raise ValueError(f"Unknown mixed precision value: {mixed_precision}")
         from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
-
         if self.mixed_precision_policy is None:
             self.mixed_precision_policy = MixedPrecision(param_dtype=dtype, reduce_dtype=dtype, buffer_dtype=dtype)
-
     def set_state_dict_type(self, state_dict_type_policy):
         from torch.distributed.fsdp.fully_sharded_data_parallel import (
             FullOptimStateDictConfig,
             FullStateDictConfig,
             StateDictType,
         )
-
         self.state_dict_type = StateDictType(FSDP_STATE_DICT_TYPE.index(state_dict_type_policy) + 1)
-
         if self.state_dict_type == StateDictType.FULL_STATE_DICT:
             if self.state_dict_config is None:
                 self.state_dict_config = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
             if self.optim_state_dict_config is None:
                 self.optim_state_dict_config = FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True)
-
-
 @dataclass
 class MegatronLMPlugin:
     """
@@ -1169,7 +1023,6 @@ class MegatronLMPlugin:
         default=False,
         metadata={"help": "Whether to return logits from the model."},
     )
-
     # custom train step args
     custom_train_step_class: Optional[Any] = field(
         default=None,
@@ -1179,7 +1032,6 @@ class MegatronLMPlugin:
         default=None,
         metadata={"help": "Custom train step kwargs."},
     )
-
     # custom model args
     custom_model_provider_function: Optional[Callable] = field(
         default=None,
@@ -1189,14 +1041,12 @@ class MegatronLMPlugin:
         default=None,
         metadata={"help": "Custom prepare model function."},
     )
-
     # remaining args such as enabling Alibi/ROPE positional embeddings,
     # wandb logging, Multi-Query Attention, etc.
     other_megatron_args: Optional[Dict[str, Any]] = field(
         default=None,
         metadata={"help": "Other Megatron-LM arguments. Please refer Megatron-LM"},
     )
-
     def __post_init__(self):
         prefix = "MEGATRON_LM_"
         if self.tp_degree is None:
@@ -1215,18 +1065,15 @@ class MegatronLMPlugin:
             )
         if self.sequence_parallelism is None:
             self.sequence_parallelism = str_to_bool(os.environ.get(prefix + "SEQUENCE_PARALLELISM", "False")) == 1
-
         if self.pp_degree > 1 or self.use_distributed_optimizer:
             self.DDP_impl = "local"
         else:
             self.DDP_impl = "torch"
-
         if self.consumed_samples is not None:
             if len(self.consumed_samples) == 1:
                 self.consumed_samples.extend([0, 0])
             elif len(self.consumed_samples) == 2:
                 self.consumed_samples.append(0)
-
         self.megatron_lm_default_args = {
             "tensor_model_parallel_size": self.tp_degree,
             "pipeline_model_parallel_size": self.pp_degree,
@@ -1253,7 +1100,6 @@ class MegatronLMPlugin:
                 self.set_tensorboard_logging_options()
         if self.other_megatron_args is not None:
             self.megatron_lm_default_args.update(self.other_megatron_args)
-
     def set_network_size_args(self, model, batch_data=None):
         # Check if the model is either BERT, GPT or T5 else raise error
         # set 'num_layers', 'hidden_size', 'num_attention_heads', 'max_position_embeddings'
@@ -1317,7 +1163,6 @@ class MegatronLMPlugin:
                     self.decoder_seq_length = batch_data["labels"].shape[1]
                 else:
                     self.decoder_seq_length = max_position_embeddings
-
             self.megatron_lm_default_args["encoder_seq_length"] = self.encoder_seq_length
             self.megatron_lm_default_args["decoder_seq_length"] = self.decoder_seq_length
         else:
@@ -1325,7 +1170,6 @@ class MegatronLMPlugin:
                 "🤗 Accelerate Megatron-LM integration supports only BERT, GPT and T5 model. "
                 "Please check the model you are using is one of those."
             )
-
         self.megatron_lm_default_args["model_type_name"] = model_type_name
         self.megatron_lm_default_args["num_layers"] = num_layers
         self.megatron_lm_default_args["hidden_size"] = hidden_size
@@ -1336,7 +1180,6 @@ class MegatronLMPlugin:
         self.megatron_lm_default_args["model_return_dict"] = model.config.return_dict
         if model_type_name == "bert":
             self.megatron_lm_default_args["num_labels"] = num_labels
-
     def set_mixed_precision(self, mixed_precision):
         if mixed_precision == "fp16":
             self.megatron_lm_default_args["fp16"] = True
@@ -1344,7 +1187,6 @@ class MegatronLMPlugin:
             self.megatron_lm_default_args["bf16"] = True
             self.DDP_impl = "local"
             self.megatron_lm_default_args["DDP_impl"] = self.DDP_impl
-
     def set_training_args(self, micro_batch_size, dp_degree):
         self.data_parallel_size = dp_degree
         self.micro_batch_size = micro_batch_size
@@ -1352,7 +1194,6 @@ class MegatronLMPlugin:
         self.megatron_lm_default_args["data_parallel_size"] = self.data_parallel_size
         self.megatron_lm_default_args["micro_batch_size"] = self.micro_batch_size
         self.megatron_lm_default_args["global_batch_size"] = self.global_batch_size
-
     def set_optimizer_type(self, optimizer):
         optimizer_name = optimizer.__class__.__name__.lower()
         if "adam" in optimizer_name:
@@ -1365,10 +1206,8 @@ class MegatronLMPlugin:
             self.megatron_lm_default_args["sgd_momentum"] = optimizer.defaults["momentum"]
         else:
             raise ValueError(f"Optimizer {optimizer_name} is not supported by Megatron-LM")
-
         self.megatron_lm_default_args["lr"] = optimizer.defaults["lr"]
         self.megatron_lm_default_args["weight_decay"] = optimizer.defaults["weight_decay"]
-
     def set_scheduler_args(self, scheduler):
         if self.train_iters is None:
             self.train_iters = scheduler.total_num_steps // self.megatron_lm_default_args["data_parallel_size"]
@@ -1384,7 +1223,6 @@ class MegatronLMPlugin:
                     "Ignoring `lr_warmup_samples` as `lr_warmup_iters` based on scheduler is being used for training."
                 )
             self.lr_warmup_samples = 0
-
         self.megatron_lm_default_args["train_iters"] = self.train_iters
         self.megatron_lm_default_args["lr_warmup_iters"] = self.lr_warmup_iters
         self.megatron_lm_default_args["train_samples"] = self.train_samples
@@ -1397,10 +1235,8 @@ class MegatronLMPlugin:
         self.megatron_lm_default_args["start_weight_decay"] = self.start_weight_decay
         self.megatron_lm_default_args["end_weight_decay"] = self.end_weight_decay
         self.megatron_lm_default_args["min_lr"] = self.min_lr
-
     def set_tensorboard_logging_options(self):
         from megatron.arguments import _add_logging_args
-
         parser = argparse.ArgumentParser()
         parser = _add_logging_args(parser)
         logging_args = parser.parse_known_args()
@@ -1410,35 +1246,28 @@ class MegatronLMPlugin:
                 self.megatron_lm_default_args[key] = True
             elif key.startswith("no_log_"):
                 self.megatron_lm_default_args[key.replace("no_", "")] = True
-
-
 @dataclass
 class BnbQuantizationConfig:
     """
     A plugin to enable BitsAndBytes 4bit and 8bit quantization
     """
     load_in_8bit: bool = field(default=False, metadata={"help": "enable 8bit quantization."})
-
     llm_int8_threshold: float = field(
         default=6.0, metadata={"help": "value of the outliner threshold. only relevant when load_in_8bit=True"}
     )
-
     load_in_4bit: bool = field(default=False, metadata={"help": "enable 4bit quantization."})
-
     bnb_4bit_quant_type: str = field(
         default="fp4",
         metadata={
             "help": "set the quantization data type in the `bnb.nn.Linear4Bit` layers. Options are {'fp4','np4'}."
         },
     )
-
     bnb_4bit_use_double_quant: bool = field(
         default=False,
         metadata={
             "help": "enable nested quantization where the quantization constants from the first quantization are quantized again."
         },
     )
-
     bnb_4bit_compute_dtype: bool = field(
         default="fp16",
         metadata={
@@ -1446,7 +1275,6 @@ class BnbQuantizationConfig:
             "fp32, but computation can be set to bf16 for speedups. Options are {'fp32','fp16','bf16'}."
         },
     )
-
     torch_dtype: torch.dtype = field(
         default=None,
         metadata={
@@ -1454,46 +1282,36 @@ class BnbQuantizationConfig:
             "to `torch.float16` for 8 bit model and use the same dtype as the compute dtype for 4 bit model "
         },
     )
-
     skip_modules: List[str] = field(
         default=None,
         metadata={
             "help": "an explicit list of the modules that we don't quantize. The dtype of these modules will be `torch_dtype`."
         },
     )
-
     keep_in_fp32_modules: List[str] = field(
         default=None,
         metadata={"help": "an explicit list of the modules that we don't quantize. We keep them in `torch.float32`."},
     )
-
     def __post_init__(self):
         """
         Safety checker that arguments are correct - also replaces some NoneType arguments with their default values.
         """
         if not isinstance(self.load_in_8bit, bool):
             raise ValueError("load_in_8bit must be a boolean")
-
         if not isinstance(self.load_in_4bit, bool):
             raise ValueError("load_in_4bit must be a boolean")
-
         if self.load_in_4bit and self.load_in_8bit:
             raise ValueError("load_in_4bit and load_in_8 can't be both True")
-
         if not self.load_in_4bit and not self.load_in_8bit:
             raise ValueError("load_in_4bit and load_in_8 can't be both False")
-
         if not isinstance(self.llm_int8_threshold, (int, float)):
             raise ValueError("llm_int8_threshold must be a float or an int")
-
         if not isinstance(self.bnb_4bit_quant_type, str):
             raise ValueError("bnb_4bit_quant_type must be a string")
         elif self.bnb_4bit_quant_type not in ["fp4", "nf4"]:
             raise ValueError(f"bnb_4bit_quant_type must be in ['fp4','nf4'] but found {self.bnb_4bit_quant_type}")
-
         if not isinstance(self.bnb_4bit_use_double_quant, bool):
             raise ValueError("bnb_4bit_use_double_quant must be a boolean")
-
         if isinstance(self.bnb_4bit_compute_dtype, str):
             if self.bnb_4bit_compute_dtype == "fp32":
                 self.bnb_4bit_compute_dtype = torch.float32
@@ -1507,22 +1325,16 @@ class BnbQuantizationConfig:
                 )
         elif not isinstance(self.bnb_4bit_compute_dtype, torch.dtype):
             raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype")
-
         if self.skip_modules is not None and not isinstance(self.skip_modules, list):
             raise ValueError("skip_modules must be a list of strings")
-
         if self.keep_in_fp32_modules is not None and not isinstance(self.keep_in_fp32_modules, list):
             raise ValueError("keep_in_fp_32_modules must be a list of strings")
-
         if self.load_in_4bit:
             self.target_dtype = CustomDtype.INT4
-
         if self.load_in_8bit:
             self.target_dtype = torch.int8
-
         if self.load_in_4bit and self.llm_int8_threshold != 6.0:
             warnings.warn("llm_int8_threshold can only be used for model loaded in 8bit")
-
         if isinstance(self.torch_dtype, str):
             if self.torch_dtype == "fp32":
                 self.torch_dtype = torch.float32
@@ -1534,9 +1346,7 @@ class BnbQuantizationConfig:
                 raise ValueError(f"torch_dtype must be in ['fp32','fp16','bf16'] but found {self.torch_dtype}")
         if self.load_in_8bit and self.torch_dtype is None:
             self.torch_dtype = torch.float16
-
         if self.load_in_4bit and self.torch_dtype is None:
             self.torch_dtype = self.bnb_4bit_compute_dtype
-
         if not isinstance(self.torch_dtype, torch.dtype):
             raise ValueError("torch_dtype must be a torch.dtype")

src/utils/deepspeed.py

@@ -1,18 +1,14 @@
 class HfDeepSpeedConfig:
     """
     This object contains a DeepSpeed configuration dictionary and can be quickly queried for things like zero stage.
-
     A `weakref` of this object is stored in the module's globals to be able to access the config from areas where
     things like the Trainer object is not available (e.g. `from_pretrained` and `_get_resized_embeddings`). Therefore
     it's important that this object remains alive while the program is still running.
-
     [`Trainer`] uses the `HfTrainerDeepSpeedConfig` subclass instead. That subclass has logic to sync the configuration
     with values of [`TrainingArguments`] by replacing special placeholder values: `"auto"`. Without this special logic
     the DeepSpeed configuration is not modified in any way.
-
     Args:
         config_file_or_dict (`Union[str, Dict]`): path to DeepSpeed config file or dict.
-
     """
     def __init__(self, config_file_or_dict):
         if isinstance(config_file_or_dict, dict):
@@ -30,17 +26,13 @@ class HfDeepSpeedConfig:
                 raise ValueError(
                     f"Expected a string path to an existing deepspeed config, or a dictionary, or a base64 encoded string. Received: {config_file_or_dict}"
                 )
-
         self.config = config
-
         self.set_stage_and_offload()
-
     def set_stage_and_offload(self):
         # zero stage - this is done as early as possible, before model is created, to allow
         # ``is_deepspeed_zero3_enabled`` query and getting to the early deepspeed config object
         # during ``zero.Init()`` which needs to know the dtype, and some other hparams.
         self._stage = self.get_value("zero_optimization.stage", -1)
-
         # offload
         self._offload = False
         if self.is_zero2() or self.is_zero3():
@@ -53,10 +45,8 @@ class HfDeepSpeedConfig:
             )
             if len(offload_devices & offload_devices_valid) > 0:
                 self._offload = True
-
     def find_config_node(self, ds_key_long):
         config = self.config
-
         # find the config node of interest if it exists
         nodes = ds_key_long.split(".")
         ds_key = nodes.pop()
@@ -64,9 +54,7 @@ class HfDeepSpeedConfig:
             config = config.get(node)
             if config is None:
                 return None, ds_key
-
         return config, ds_key
-
     def get_value(self, ds_key_long, default=None):
         """
         Returns the set value or `default` if no value is set
@@ -75,15 +63,12 @@ class HfDeepSpeedConfig:
         if config is None:
             return default
         return config.get(ds_key, default)
-
     def del_config_sub_tree(self, ds_key_long, must_exist=False):
         """
         Deletes a sub-section of the config file if it's found.
-
         Unless `must_exist` is `True` the section doesn't have to exist.
         """
         config = self.config
-
         # find the config node of interest if it exists
         nodes = ds_key_long.split(".")
         for node in nodes:
@@ -94,20 +79,16 @@ class HfDeepSpeedConfig:
                     raise ValueError(f"Can't find {ds_key_long} entry in the config: {self.config}")
                 else:
                     return
-
         # if found remove it
         if parent_config is not None:
             parent_config.pop(node)
-
     def is_true(self, ds_key_long):
         """
         Returns `True`/``False` only if the value is set, always `False` otherwise. So use this method to ask the very
         specific question of whether the value is set to `True` (and it's not set to `False`` or isn't set).
-
         """
         value = self.get_value(ds_key_long)
         return False if value is None else bool(value)
-
     def is_false(self, ds_key_long):
         """
         Returns `True`/``False` only if the value is set, always `False` otherwise. So use this method to ask the very
@@ -115,31 +96,23 @@ class HfDeepSpeedConfig:
         """
         value = self.get_value(ds_key_long)
         return False if value is None else not bool(value)
-
     def is_zero2(self):
         return self._stage == 2
-
     def is_zero3(self):
         return self._stage == 3
-
     def is_offload(self):
         return self._offload
-
-
 class DeepSpeedEngineWrapper:
     """
     Internal wrapper for deepspeed.runtime.engine.DeepSpeedEngine. This is used to follow conventional training loop.
-
     Args:
         engine (deepspeed.runtime.engine.DeepSpeedEngine): deepspeed engine to wrap
     """
     def __init__(self, engine):
         self.engine = engine
-
     def backward(self, loss, **kwargs):
         # runs backpropagation and handles mixed precision
         self.engine.backward(loss, **kwargs)
-
         # Deepspeed's `engine.step` performs the following operations:
         # - gradient accumulation check
         # - gradient clipping
@@ -151,12 +124,9 @@ class DeepSpeedEngineWrapper:
         # and this plugin overrides the above calls with no-ops when Accelerate runs under
         # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabling a simple
         # training loop that works transparently under many training regimes.
-
-
 class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):
     """
     Internal wrapper around a deepspeed optimizer.
-
     Args:
         optimizer (`torch.optim.optimizer.Optimizer`):
             The optimizer to wrap.
@@ -164,25 +134,19 @@ class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):
     def __init__(self, optimizer):
         super().__init__(optimizer, device_placement=False, scaler=None)
         self.__has_overflow__ = hasattr(self.optimizer, "overflow")
-
     def zero_grad(self, set_to_none=None):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed
-
     def step(self):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed
-
     @property
     def step_was_skipped(self):
         """Whether or not the optimizer step was done, or skipped because of gradient overflow."""
         if self.__has_overflow__:
             return self.optimizer.overflow
         return False
-
-
 class DeepSpeedSchedulerWrapper(AcceleratedScheduler):
     """
     Internal wrapper around a deepspeed scheduler.
-
     Args:
         scheduler (`torch.optim.lr_scheduler.LambdaLR`):
             The scheduler to wrap.
@@ -190,16 +154,12 @@ class DeepSpeedSchedulerWrapper(AcceleratedScheduler):
     """
     def __init__(self, scheduler, optimizers):
         super().__init__(scheduler, optimizers)
-
     def step(self):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed
-
-
 class DummyOptim:
     """
     Dummy optimizer presents model parameters or param groups, this is primarily used to follow conventional training
     loop when optimizer config is specified in the deepspeed config file.
-
     Args:
         lr (float):
             Learning rate.
@@ -215,13 +175,10 @@ class DummyOptim:
         self.lr = lr
         self.weight_decay = weight_decay
         self.kwargs = kwargs
-
-
 class DummyScheduler:
     """
     Dummy scheduler presents model parameters or param groups, this is primarily used to follow conventional training
     loop when scheduler config is specified in the deepspeed config file.
-
     Args:
         optimizer (`torch.optim.optimizer.Optimizer`):
             The optimizer to wrap.

src/utils/environment.py

@@ -1,7 +1,6 @@
 def str_to_bool(value) -> int:
     """
     Converts a string representation of truth to `True` (1) or `False` (0).
-
     True values are `y`, `yes`, `t`, `true`, `on`, and `1`; False value are `n`, `no`, `f`, `false`, `off`, and `0`;
     """
     value = value.lower()
@@ -11,8 +10,6 @@ def str_to_bool(value) -> int:
         return 0
     else:
         raise ValueError(f"invalid truth value {value}")
-
-
 def get_int_from_env(env_keys, default):
     """Returns the first positive env value found in the `env_keys` list or the default."""
     for e in env_keys:
@@ -20,30 +17,21 @@ def get_int_from_env(env_keys, default):
         if val >= 0:
             return val
     return default
-
-
 def parse_flag_from_env(key, default=False):
     """Returns truthy value for `key` from the env if available else the default."""
     value = os.environ.get(key, str(default))
     return str_to_bool(value) == 1  # As its name indicates `str_to_bool` actually returns an int...
-
-
 def parse_choice_from_env(key, default="no"):
     value = os.environ.get(key, str(default))
     return value
-
-
 def are_libraries_initialized(*library_names: str) -> Dict[str, bool]:
     """
     Checks if any of `library_names` are imported in the environment. Will return results as a `key:bool` pair.
     """
     return [lib_name for lib_name in library_names if lib_name in sys.modules.keys()]
-
-
 def get_gpu_info():
     """
     Gets GPU count and names using `nvidia-smi` instead of torch to not initialize CUDA.
-
     Largely based on the `gputil` library.
     """
     if platform.system() == "Windows":
@@ -64,13 +52,10 @@ def get_gpu_info():
     gpu_count = len(gpus)
     gpu_names = [gpu.split(",")[1].strip() for gpu in gpus]
     return gpu_names, gpu_count
-
-
 def check_cuda_p2p_ib_support():
     """
     Checks if the devices being used have issues with P2P and IB communications, namely any consumer GPU hardware after
     the 3090.
-
     Noteably uses `nvidia-smi` instead of torch to not initialize CUDA.
     """
     try:
@@ -86,12 +71,9 @@ def check_cuda_p2p_ib_support():
     except Exception:
         pass
     return True
-
-
 def check_fp8_capability():
     """
     Checks if all the current GPUs available support FP8.
-
     Notably must initialize `torch.cuda` to check.
     """
     cuda_device_capacity = torch.cuda.get_device_capability()

src/utils/fsdp_utils.py

@@ -1,16 +1,12 @@
 logger = get_logger(__name__)
-
-
 def save_fsdp_model(fsdp_plugin, accelerator, model, output_dir, model_index=0):
     os.makedirs(output_dir, exist_ok=True)
-
     if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
         # FSDP raises error when single GPU is used with `offload_to_cpu=True` for FULL_STATE_DICT
         # so, only enable it when num_processes>1
         is_multi_process = accelerator.num_processes > 1
         fsdp_plugin.state_dict_config.offload_to_cpu = is_multi_process
         fsdp_plugin.state_dict_config.rank0_only = is_multi_process
-
     with FSDP.state_dict_type(
         model, fsdp_plugin.state_dict_type, fsdp_plugin.state_dict_config, fsdp_plugin.optim_state_dict_config
     ):
@@ -37,15 +33,12 @@ def save_fsdp_model(fsdp_plugin, accelerator, model, output_dir, model_index=0):
             os.makedirs(ckpt_dir, exist_ok=True)
             logger.info(f"Saving model to {ckpt_dir}")
             state_dict = {"model": state_dict}
-
             dist_cp.save_state_dict(
                 state_dict=state_dict,
                 storage_writer=dist_cp.FileSystemWriter(ckpt_dir),
                 planner=DefaultSavePlanner(),
             )
             logger.info(f"Model saved to {ckpt_dir}")
-
-
 def load_fsdp_model(fsdp_plugin, accelerator, model, input_dir, model_index=0):
     accelerator.wait_for_everyone()
     if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
@@ -97,8 +90,6 @@ def load_fsdp_model(fsdp_plugin, accelerator, model, input_dir, model_index=0):
             logger.info(f"Model loaded from {ckpt_dir}")
         load_result = model.load_state_dict(state_dict)
     return load_result
-
-
 def save_fsdp_optimizer(fsdp_plugin, accelerator, optimizer, model, output_dir, optimizer_index=0):
     os.makedirs(output_dir, exist_ok=True)
     with FSDP.state_dict_type(
@@ -124,8 +115,6 @@ def save_fsdp_optimizer(fsdp_plugin, accelerator, optimizer, model, output_dir,
                 planner=DefaultSavePlanner(),
             )
             logger.info(f"Optimizer state saved in {ckpt_dir}")
-
-
 def load_fsdp_optimizer(fsdp_plugin, accelerator, optimizer, model, input_dir, optimizer_index=0):
     accelerator.wait_for_everyone()
     with FSDP.state_dict_type(

src/utils/imports.py

@@ -1,7 +1,5 @@
 # Cache this result has it's a C FFI call which can be pretty time-consuming
 _torch_distributed_available = torch.distributed.is_available()
-
-
 def _is_package_available(pkg_name):
     # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
     package_exists = importlib.util.find_spec(pkg_name) is not None
@@ -11,12 +9,8 @@ def _is_package_available(pkg_name):
             return True
         except importlib.metadata.PackageNotFoundError:
             return False
-
-
 def is_torch_distributed_available() -> bool:
     return _torch_distributed_available
-
-
 def is_ccl_available():
     try:
         pass
@@ -30,12 +24,8 @@ def is_ccl_available():
         importlib.util.find_spec("torch_ccl") is not None
         or importlib.util.find_spec("oneccl_bindings_for_pytorch") is not None
     )
-
-
 def get_ccl_version():
     return importlib.metadata.version("oneccl_bind_pt")
-
-
 def is_msamp_available():
     package_exists = importlib.util.find_spec("msamp") is not None
     if package_exists:
@@ -46,16 +36,10 @@ def is_msamp_available():
         except importlib.metadata.PackageNotFoundError:
             return False
     return False
-
-
 def is_transformer_engine_available():
     return _is_package_available("transformer_engine")
-
-
 def is_fp8_available():
     return is_msamp_available() or is_transformer_engine_available()
-
-
 def is_cuda_available():
     """
     Checks if `cuda` is available via an `nvml-based` check which won't trigger the drivers and leave cuda
@@ -67,8 +51,6 @@ def is_cuda_available():
     finally:
         os.environ.pop("PYTORCH_NVML_BASED_CUDA_CHECK", None)
     return available
-
-
 @lru_cache
 def is_tpu_available(check_device=True):
     "Checks if `torch_xla` is installed and potentially if a TPU is in the environment"
@@ -84,12 +66,8 @@ def is_tpu_available(check_device=True):
             except RuntimeError:
                 return False
     return _tpu_available
-
-
 def is_deepspeed_available():
     return _is_package_available("deepspeed")
-
-
 def is_bf16_available(ignore_tpu=False):
     "Checks if bf16 is supported, optionally ignoring the TPU"
     if is_tpu_available():
@@ -97,28 +75,20 @@ def is_bf16_available(ignore_tpu=False):
     if is_cuda_available():
         return torch.cuda.is_bf16_supported()
     return True
-
-
 def is_4bit_bnb_available():
     package_exists = _is_package_available("bitsandbytes")
     if package_exists:
         bnb_version = version.parse(importlib.metadata.version("bitsandbytes"))
         return compare_versions(bnb_version, ">=", "0.39.0")
     return False
-
-
 def is_8bit_bnb_available():
     package_exists = _is_package_available("bitsandbytes")
     if package_exists:
         bnb_version = version.parse(importlib.metadata.version("bitsandbytes"))
         return compare_versions(bnb_version, ">=", "0.37.2")
     return False
-
-
 def is_bnb_available():
     return _is_package_available("bitsandbytes")
-
-
 def is_megatron_lm_available():
     if str_to_bool(os.environ.get("ACCELERATE_USE_MEGATRON_LM", "False")) == 1:
         package_exists = importlib.util.find_spec("megatron") is not None
@@ -129,44 +99,26 @@ def is_megatron_lm_available():
             except Exception as e:
                 warnings.warn(f"Parse Megatron version failed. Exception:{e}")
                 return False
-
-
 def is_transformers_available():
     return _is_package_available("transformers")
-
-
 def is_datasets_available():
     return _is_package_available("datasets")
-
-
 def is_timm_available():
     return _is_package_available("timm")
-
-
 def is_aim_available():
     package_exists = _is_package_available("aim")
     if package_exists:
         aim_version = version.parse(importlib.metadata.version("aim"))
         return compare_versions(aim_version, "<", "4.0.0")
     return False
-
-
 def is_tensorboard_available():
     return _is_package_available("tensorboard") or _is_package_available("tensorboardX")
-
-
 def is_wandb_available():
     return _is_package_available("wandb")
-
-
 def is_comet_ml_available():
     return _is_package_available("comet_ml")
-
-
 def is_boto3_available():
     return _is_package_available("boto3")
-
-
 def is_rich_available():
     if _is_package_available("rich"):
         if "ACCELERATE_DISABLE_RICH" in os.environ:
@@ -176,28 +128,17 @@ def is_rich_available():
             return not parse_flag_from_env("ACCELERATE_DISABLE_RICH", False)
         return parse_flag_from_env("ACCELERATE_ENABLE_RICH", False)
     return False
-
-
 def is_sagemaker_available():
     return _is_package_available("sagemaker")
-
-
 def is_tqdm_available():
     return _is_package_available("tqdm")
-
-
 def is_clearml_available():
     return _is_package_available("clearml")
-
-
 def is_pandas_available():
     return _is_package_available("pandas")
-
-
 def is_mlflow_available():
     if _is_package_available("mlflow"):
         return True
-
     if importlib.util.find_spec("mlflow") is not None:
         try:
             _ = importlib.metadata.metadata("mlflow-skinny")
@@ -205,16 +146,11 @@ def is_mlflow_available():
         except importlib.metadata.PackageNotFoundError:
             return False
     return False
-
-
 def is_mps_available():
     return is_torch_version(">=", "1.12") and torch.backends.mps.is_available() and torch.backends.mps.is_built()
-
-
 def is_ipex_available():
     def get_major_and_minor_from_version(full_version):
         return str(version.parse(full_version).major) + "." + str(version.parse(full_version).minor)
-
     _torch_version = importlib.metadata.version("torch")
     if importlib.util.find_spec("intel_extension_for_pytorch") is None:
         return False
@@ -232,17 +168,13 @@ def is_ipex_available():
         )
         return False
     return True
-
-
 @lru_cache
 def is_npu_available(check_device=False):
     "Checks if `torch_npu` is installed and potentially if a NPU is in the environment"
     if importlib.util.find_spec("torch") is None or importlib.util.find_spec("torch_npu") is None:
         return False
-
     import torch
     import torch_npu  # noqa: F401
-
     if check_device:
         try:
             # Will raise a RuntimeError if no NPU is found
@@ -251,8 +183,6 @@ def is_npu_available(check_device=False):
         except RuntimeError:
             return False
     return hasattr(torch, "npu") and torch.npu.is_available()
-
-
 @lru_cache
 def is_xpu_available(check_device=False):
     "check if user disables it explicitly"
@@ -261,14 +191,11 @@ def is_xpu_available(check_device=False):
     "Checks if `intel_extension_for_pytorch` is installed and potentially if a XPU is in the environment"
     if is_ipex_available():
         import torch
-
         if is_torch_version("<=", "1.12"):
             return False
     else:
         return False
-
     import intel_extension_for_pytorch  # noqa: F401
-
     if check_device:
         try:
             # Will raise a RuntimeError if no XPU  is found
@@ -277,7 +204,5 @@ def is_xpu_available(check_device=False):
         except RuntimeError:
             return False
     return hasattr(torch, "xpu") and torch.xpu.is_available()
-
-
 def is_dvclive_available():
     return _is_package_available("dvclive")

src/utils/launch.py

@@ -7,8 +7,6 @@ def _filter_args(args, parser, default_args=[]):
         if key in vars(new_args).keys():
             setattr(new_args, key, value)
     return new_args
-
-
 def prepare_simple_launcher_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict[str, str]]:
     """
     Prepares and returns the command list and an environment with the correct simple launcher environment variables.
@@ -22,7 +20,6 @@ def prepare_simple_launcher_cmd_env(args: argparse.Namespace) -> Tuple[List[str]
             cmd.append("-m")
     cmd.append(args.training_script)
     cmd.extend(args.training_script_args)
-
     current_env = os.environ.copy()
     current_env["ACCELERATE_USE_CPU"] = str(args.cpu or args.use_cpu)
     if args.debug:
@@ -40,16 +37,13 @@ def prepare_simple_launcher_cmd_env(args: argparse.Namespace) -> Tuple[List[str]
     elif args.num_processes > 1:
         current_env["MASTER_ADDR"] = args.main_process_ip if args.main_process_ip is not None else "127.0.0.1"
         current_env["MASTER_PORT"] = str(args.main_process_port) if args.main_process_port is not None else "29500"
-
     try:
         mixed_precision = PrecisionType(args.mixed_precision.lower())
     except ValueError:
         raise ValueError(
             f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."
         )
-
     current_env["ACCELERATE_MIXED_PRECISION"] = str(mixed_precision)
-
     try:
         dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
     except ValueError:
@@ -60,14 +54,11 @@ def prepare_simple_launcher_cmd_env(args: argparse.Namespace) -> Tuple[List[str]
     current_env["ACCELERATE_DYNAMO_MODE"] = args.dynamo_mode
     current_env["ACCELERATE_DYNAMO_USE_FULLGRAPH"] = str(args.dynamo_use_fullgraph)
     current_env["ACCELERATE_DYNAMO_USE_DYNAMIC"] = str(args.dynamo_use_dynamic)
-
     current_env["OMP_NUM_THREADS"] = str(args.num_cpu_threads_per_process)
     if is_ipex_available():
         current_env["ACCELERATE_USE_IPEX"] = str(args.ipex).lower()
         current_env["ACCELERATE_USE_XPU"] = str(args.use_xpu).lower()
     return cmd, current_env
-
-
 def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
     """
     Prepares and returns an environment with the correct multi-GPU environment variables.
@@ -89,10 +80,8 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
         setattr(args, "nproc_per_node", str(num_processes))
         if main_process_port is not None:
             setattr(args, "master_port", str(main_process_port))
-
     if main_process_port is None:
         main_process_port = 29500
-
     # only need to check port availability in main process, in case we have to start multiple launchers on the same machine
     # for some reasons like splitting log files.
     need_port_check = num_machines <= 1 or int(args.machine_rank) == 0
@@ -102,14 +91,12 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
             "Please specify a different port (such as using the `----main_process_port` flag or specifying a different `main_process_port` in your config file)"
             " and rerun your script. To automatically use the next open port (on a single node), you can set this to `0`."
         )
-
     if args.module and args.no_python:
         raise ValueError("--module and --no_python cannot be used together")
     elif args.module:
         setattr(args, "module", True)
     elif args.no_python:
         setattr(args, "no_python", True)
-
     current_env = os.environ.copy()
     if args.debug:
         current_env["ACCELERATE_DEBUG_MODE"] = "true"
@@ -126,9 +113,7 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
         mixed_precision = PrecisionType(mixed_precision)
     except ValueError:
         raise ValueError(f"Unknown mixed_precision mode: {mixed_precision}. Choose between {PrecisionType.list()}.")
-
     current_env["ACCELERATE_MIXED_PRECISION"] = str(mixed_precision)
-
     try:
         dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
     except ValueError:
@@ -139,12 +124,10 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
     current_env["ACCELERATE_DYNAMO_MODE"] = args.dynamo_mode
     current_env["ACCELERATE_DYNAMO_USE_FULLGRAPH"] = str(args.dynamo_use_fullgraph)
     current_env["ACCELERATE_DYNAMO_USE_DYNAMIC"] = str(args.dynamo_use_dynamic)
-
     if args.use_fsdp:
         current_env["ACCELERATE_USE_FSDP"] = "true"
         if args.fsdp_cpu_ram_efficient_loading and not args.fsdp_sync_module_states:
             raise ValueError("When using `--fsdp_cpu_ram_efficient_loading` set `--fsdp_sync_module_states` to `True`")
-
         current_env["FSDP_SHARDING_STRATEGY"] = str(args.fsdp_sharding_strategy)
         current_env["FSDP_OFFLOAD_PARAMS"] = str(args.fsdp_offload_params).lower()
         current_env["FSDP_MIN_NUM_PARAMS"] = str(args.fsdp_min_num_params)
@@ -167,7 +150,6 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
         current_env["FSDP_USE_ORIG_PARAMS"] = str(args.fsdp_use_orig_params).lower()
         current_env["FSDP_CPU_RAM_EFFICIENT_LOADING"] = str(args.fsdp_cpu_ram_efficient_loading).lower()
         current_env["FSDP_SYNC_MODULE_STATES"] = str(args.fsdp_sync_module_states).lower()
-
     if args.use_megatron_lm:
         prefix = "MEGATRON_LM_"
         current_env["ACCELERATE_USE_MEGATRON_LM"] = "true"
@@ -182,11 +164,8 @@ def prepare_multi_gpu_env(args: argparse.Namespace) -> Dict[str, str]:
             current_env[prefix + "RECOMPUTE_ACTIVATIONS"] = str(args.megatron_lm_recompute_activations)
         if args.megatron_lm_use_distributed_optimizer is not None:
             current_env[prefix + "USE_DISTRIBUTED_OPTIMIZER"] = str(args.megatron_lm_use_distributed_optimizer)
-
     current_env["OMP_NUM_THREADS"] = str(args.num_cpu_threads_per_process)
     return current_env
-
-
 def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict[str, str]]:
     """
     Prepares and returns the command list and an environment with the correct DeepSpeed environment variables.
@@ -196,12 +175,10 @@ def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict
     main_process_ip = getattr(args, "main_process_ip")
     main_process_port = getattr(args, "main_process_port")
     cmd = None
-
     # make sure launcher is not None
     if args.deepspeed_multinode_launcher is None:
         # set to default pdsh
         setattr(args, "deepspeed_multinode_launcher", DEEPSPEED_MULTINODE_LAUNCHERS[0])
-
     if num_machines > 1 and args.deepspeed_multinode_launcher != DEEPSPEED_MULTINODE_LAUNCHERS[1]:
         cmd = ["deepspeed", "--no_local_rank"]
         cmd.extend(["--hostfile", str(args.deepspeed_hostfile), "--launcher", str(args.deepspeed_multinode_launcher)])
@@ -243,10 +220,8 @@ def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict
         setattr(args, "nproc_per_node", str(num_processes))
         if main_process_port is not None:
             setattr(args, "master_port", str(main_process_port))
-
     if main_process_port is None:
         main_process_port = 29500
-
     # only need to check port availability in main process, in case we have to start multiple launchers on the same machine
     # for some reasons like splitting log files.
     need_port_check = num_machines <= 1 or int(args.machine_rank) == 0
@@ -256,14 +231,12 @@ def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict
             "Please specify a different port (such as using the `----main_process_port` flag or specifying a different `main_process_port` in your config file)"
             " and rerun your script. To automatically use the next open port (on a single node), you can set this to `0`."
         )
-
     if args.module and args.no_python:
         raise ValueError("--module and --no_python cannot be used together")
     elif args.module:
         setattr(args, "module", True)
     elif args.no_python:
         setattr(args, "no_python", True)
-
     current_env = os.environ.copy()
     if args.debug:
         current_env["ACCELERATE_DEBUG_MODE"] = "true"
@@ -281,7 +254,6 @@ def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict
         raise ValueError(
             f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."
         )
-
     current_env["PYTHONPATH"] = env_var_path_add("PYTHONPATH", os.path.abspath("."))
     current_env["ACCELERATE_MIXED_PRECISION"] = str(mixed_precision)
     current_env["ACCELERATE_CONFIG_DS_FIELDS"] = str(args.deepspeed_fields_from_accelerate_config).lower()
@@ -303,8 +275,6 @@ def prepare_deepspeed_cmd_env(args: argparse.Namespace) -> Tuple[List[str], Dict
     if args.deepspeed_config_file is not None:
         current_env["ACCELERATE_DEEPSPEED_CONFIG_FILE"] = str(args.deepspeed_config_file)
     return cmd, current_env
-
-
 def prepare_tpu(
     args: argparse.Namespace, current_env: Dict[str, str], pod: bool = False
 ) -> Tuple[argparse.Namespace, Dict[str, str]]:
@@ -323,23 +293,18 @@ def prepare_tpu(
         args.vm = args.tpu_vm
         args.tpu = args.tpu_name
     return args, current_env
-
-
 def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:
     if len(nargs) < 0:
         return {}
     # helper function to infer type for argsparser
-
     def _infer_type(s):
         try:
             s = float(s)
-
             if s // 1 == s:
                 return int(s)
             return s
         except ValueError:
             return s
-
     parser = argparse.ArgumentParser()
     _, unknown = parser.parse_known_args(nargs)
     for index, argument in enumerate(unknown):
@@ -360,20 +325,16 @@ def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:
                 parser.add_argument(argument, type=_infer_type)
             else:
                 parser.add_argument(argument, action=action)
-
     return {
         key: (literal_eval(value) if value in ("True", "False") else value)
         for key, value in parser.parse_args(nargs).__dict__.items()
     }
-
-
 def prepare_sagemager_args_inputs(
     sagemaker_config: SageMakerConfig, args: argparse.Namespace
 ) -> Tuple[argparse.Namespace, Dict[str, Any]]:
     # configure environment
     print("Configuring Amazon SageMaker environment")
     os.environ["AWS_DEFAULT_REGION"] = sagemaker_config.region
-
     # configure credentials
     if sagemaker_config.profile is not None:
         os.environ["AWS_PROFILE"] = sagemaker_config.profile
@@ -384,7 +345,6 @@ def prepare_sagemager_args_inputs(
         raise EnvironmentError(
             "You need to provide an aws_access_key_id and aws_secret_access_key when not using aws_profile"
         )
-
     # extract needed arguments
     source_dir = os.path.dirname(args.training_script)
     if not source_dir:  # checks if string is empty
@@ -392,24 +352,20 @@ def prepare_sagemager_args_inputs(
     entry_point = os.path.basename(args.training_script)
     if not entry_point.endswith(".py"):
         raise ValueError(f'Your training script should be a python script and not "{entry_point}"')
-
     print("Converting Arguments to Hyperparameters")
     hyperparameters = _convert_nargs_to_dict(args.training_script_args)
-
     try:
         mixed_precision = PrecisionType(args.mixed_precision.lower())
     except ValueError:
         raise ValueError(
             f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."
         )
-
     try:
         dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
     except ValueError:
         raise ValueError(
             f"Unknown dynamo backend: {args.dynamo_backend.upper()}. Choose between {DynamoBackend.list()}."
         )
-
     # Environment variables to be set for use during training job
     environment = {
         "ACCELERATE_USE_SAGEMAKER": "true",
@@ -424,7 +380,6 @@ def prepare_sagemager_args_inputs(
     distribution = None
     if sagemaker_config.distributed_type == SageMakerDistributedType.DATA_PARALLEL:
         distribution = {"smdistributed": {"dataparallel": {"enabled": True}}}
-
     # configure sagemaker inputs
     sagemaker_inputs = None
     if sagemaker_config.sagemaker_inputs_file is not None:
@@ -437,7 +392,6 @@ def prepare_sagemager_args_inputs(
                 l = line.split("\t")
                 sagemaker_inputs[l[0]] = l[1].strip()
         print(f"Loaded SageMaker Inputs: {sagemaker_inputs}")
-
     # configure sagemaker metrics
     sagemaker_metrics = None
     if sagemaker_config.sagemaker_metrics_file is not None:
@@ -454,7 +408,6 @@ def prepare_sagemager_args_inputs(
                 }
                 sagemaker_metrics.append(metric_dict)
         print(f"Loaded SageMaker Metrics: {sagemaker_metrics}")
-
     # configure session
     print("Creating Estimator")
     args = {
@@ -474,12 +427,9 @@ def prepare_sagemager_args_inputs(
         "environment": environment,
         "metric_definitions": sagemaker_metrics,
     }
-
     if sagemaker_config.additional_args is not None:
         args = merge_dicts(sagemaker_config.additional_args, args)
     return args, sagemaker_inputs
-
-
 def env_var_path_add(env_var_name, path_to_add):
     """
     Extends a path-based environment variable's value with a new path and returns the updated value. It's up to the
@@ -488,12 +438,9 @@ def env_var_path_add(env_var_name, path_to_add):
     paths = [p for p in os.environ.get(env_var_name, "").split(":") if len(p) > 0]
     paths.append(str(path_to_add))
     return ":".join(paths)
-
-
 class PrepareForLaunch:
     """
     Prepare a function that will launched in a distributed setup.
-
     Args:
         launcher (`Callable`):
             The function to launch.
@@ -506,7 +453,6 @@ class PrepareForLaunch:
         self.launcher = launcher
         self.distributed_type = DistributedType(distributed_type)
         self.debug = debug
-
     def __call__(self, index, *args):
         if self.debug:
             world_size = int(os.environ.get("WORLD_SIZE"))
@@ -528,6 +474,5 @@ class PrepareForLaunch:
             nproc = int(os.environ.get("NPROC", 1))
             node_rank = int(os.environ.get("NODE_RANK", 0))
             os.environ["RANK"] = str(nproc * node_rank + index)
-
         os.environ["FORK_LAUNCHED"] = str(1)
         self.launcher(*args)

src/utils/megatron_lm.py

@@ -37,8 +37,6 @@ def model_provider_func(pre_process=True, post_process=True, add_encoder=True, a
     else:
         raise ValueError(f"Unsupported model type: {args.model_type_name}")
     return model
-
-
 def prepare_model(accelerator):
     accelerator.print("Preparing model")
     args = get_args()
@@ -58,13 +56,10 @@ def prepare_model(accelerator):
                 args.pipeline_model_parallel_split_rank = args.pipeline_model_parallel_size // 2
         model = get_model(model_provider_func, model_type)
     return model
-
-
 # dataloader utilities
 class MegatronLMDummyDataLoader:
     """
     Dummy dataloader presents model parameters or param groups, this is primarily used to follow conventional training
-
     Args:
         **dataset_kwargs: Megatron data arguments.
     """
@@ -76,12 +71,10 @@ class MegatronLMDummyDataLoader:
         self.dataset_args = vars(data_args[0])
         self.dataset_args.update(dataset_kwargs)
         self.dataset_args["megatron_dataset_flag"] = True
-
     def set_megatron_data_args(self):
         args = get_args()
         for key, value in self.dataset_args.items():
             setattr(args, key, value)
-
     def get_train_valid_test_datasets_provider(self):
         def train_valid_test_datasets_provider(train_val_test_num_samples):
             """Build train, valid, and test datasets."""
@@ -127,15 +120,12 @@ class MegatronLMDummyDataLoader:
                 from megatron.data.dataset_utils import build_train_valid_test_datasets
             train_ds, valid_ds, test_ds = build_train_valid_test_datasets(**dataset_args)
             return train_ds, valid_ds, test_ds
-
         return train_valid_test_datasets_provider
-
     def build_pretraining_data_loader(self, dataset, consumed_samples):
         if dataset is None:
             return None
         args = get_args()
         micro_batch_size = args.micro_batch_size * args.num_micro_batches
-
         # Megatron sampler
         if args.dataloader_type == "single":
             batch_sampler = MegatronPretrainingSampler(
@@ -157,24 +147,18 @@ class MegatronLMDummyDataLoader:
             )
         else:
             raise Exception("{} dataloader type is not supported.".format(args.dataloader_type))
-
         # Torch dataloader.
         return torch.utils.data.DataLoader(
             dataset, batch_sampler=batch_sampler, num_workers=args.num_workers, pin_memory=True
         )
-
     def build_train_valid_test_data_iterators(self):
         def cyclic_iter(iter):
             while True:
                 for x in iter:
                     yield x
-
         args = get_args()
-
         (train_dataloader, valid_dataloader, test_dataloader) = (None, None, None)
-
         print_rank_0("> building train, validation, and test datasets ...")
-
         # Backward compatibility, assume fixed batch size.
         if args.iteration > 0 and args.consumed_train_samples == 0:
             assert args.train_samples is None, "only backward compatiblity support for iteration-based training"
@@ -184,7 +168,6 @@ class MegatronLMDummyDataLoader:
                 args.consumed_valid_samples = (
                     (args.iteration // args.eval_interval) * args.eval_iters * args.global_batch_size
                 )
-
         # Data loader only on rank 0 of each model parallel group.
         if mpu.get_tensor_model_parallel_rank() == 0:
             # Number of train/valid/test samples.
@@ -203,16 +186,13 @@ class MegatronLMDummyDataLoader:
             print_rank_0("    train:      {}".format(train_val_test_num_samples[0]))
             print_rank_0("    validation: {}".format(train_val_test_num_samples[1]))
             print_rank_0("    test:       {}".format(train_val_test_num_samples[2]))
-
             # Build the datasets.
             train_valid_test_datasets_provider = self.get_train_valid_test_datasets_provider()
             train_ds, valid_ds, test_ds = train_valid_test_datasets_provider(train_val_test_num_samples)
-
             # Build dataloders.
             train_dataloader = self.build_pretraining_data_loader(train_ds, args.consumed_train_samples)
             valid_dataloader = self.build_pretraining_data_loader(valid_ds, args.consumed_valid_samples)
             test_dataloader = self.build_pretraining_data_loader(test_ds, 0)
-
             # Flags to know if we need to do training/validation/testing.
             do_train = train_dataloader is not None and args.train_iters > 0
             do_valid = valid_dataloader is not None and args.eval_iters > 0
@@ -221,7 +201,6 @@ class MegatronLMDummyDataLoader:
             flags = torch.cuda.LongTensor([int(do_train), int(do_valid), int(do_test)])
         else:
             flags = torch.cuda.LongTensor([0, 0, 0])
-
         # Broadcast num tokens.
         torch.distributed.broadcast(
             flags, mpu.get_tensor_model_parallel_src_rank(), group=mpu.get_tensor_model_parallel_group()
@@ -229,39 +208,31 @@ class MegatronLMDummyDataLoader:
         args.do_train = flags[0].item()
         args.do_valid = flags[1].item()
         args.do_test = flags[2].item()
-
         # Build iterators.
         dl_type = args.dataloader_type
         assert dl_type in ["single", "cyclic"]
-
         if train_dataloader is not None:
             train_data_iterator = (
                 iter(train_dataloader) if dl_type == "single" else iter(cyclic_iter(train_dataloader))
             )
         else:
             train_data_iterator = None
-
         if valid_dataloader is not None:
             valid_data_iterator = (
                 iter(valid_dataloader) if dl_type == "single" else iter(cyclic_iter(valid_dataloader))
             )
         else:
             valid_data_iterator = None
-
         if test_dataloader is not None:
             test_data_iterator = iter(test_dataloader) if dl_type == "single" else iter(cyclic_iter(test_dataloader))
         else:
             test_data_iterator = None
-
         return train_data_iterator, valid_data_iterator, test_data_iterator
-
-
 def prepare_data_loader(accelerator, dataloader):
     accelerator.print("Preparing dataloader")
     args = get_args()
     if not args.megatron_dataset_flag:
         from ..data_loader import _PYTORCH_DATALOADER_KWARGS, prepare_data_loader
-
         args = get_args()
         micro_batch_size = args.micro_batch_size * args.num_micro_batches
         kwargs = {k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k]) for k in _PYTORCH_DATALOADER_KWARGS}
@@ -276,7 +247,6 @@ def prepare_data_loader(accelerator, dataloader):
         else:
             del kwargs["batch_sampler"]
             kwargs["batch_size"] = micro_batch_size
-
         dataloader = torch.utils.data.DataLoader(dataloader.dataset, **kwargs)
         return prepare_data_loader(
             dataloader,
@@ -303,38 +273,28 @@ def prepare_data_loader(accelerator, dataloader):
             test_data_iterator,
         ) = dataloader.build_train_valid_test_data_iterators()
         return train_data_iterator, valid_data_iterator, test_data_iterator
-
-
 # optimizer utilities
 class MegatronLMOptimizerWrapper(AcceleratedOptimizer):
     def __init__(self, optimizer):
         super().__init__(optimizer, device_placement=False, scaler=None)
-
     def zero_grad(self, set_to_none=None):
         pass  # `model(**batch)` is doing that automatically. Therefore, it's implementation is not needed
-
     def step(self):
         pass  # `model(**batch)` is doing that automatically. Therefore, it's implementation is not needed
-
     @property
     def step_was_skipped(self):
         """Whether or not the optimizer step was done, or skipped because of gradient overflow."""
         return self.optimizer.skipped_iter
-
-
 def prepare_optimizer(accelerator, model):
     accelerator.print("Preparing optimizer")
     args = get_args()
     optimizer = get_megatron_optimizer(model, args.no_wd_decay_cond, args.scale_lr_cond, args.lr_mult)
     return optimizer
-
-
 # scheduler utilities
 class MegatronLMDummyScheduler:
     """
     Dummy scheduler presents model parameters or param groups, this is primarily used to follow conventional training
     loop when scheduler config is specified in the deepspeed config file.
-
     Args:
         optimizer (`torch.optim.optimizer.Optimizer`):
             The optimizer to wrap.
@@ -350,43 +310,29 @@ class MegatronLMDummyScheduler:
         self.total_num_steps = total_num_steps
         self.warmup_num_steps = warmup_num_steps
         self.kwargs = kwargs
-
-
 class MegatronLMSchedulerWrapper(AcceleratedScheduler):
     def __init__(self, scheduler, optimizers):
         super().__init__(scheduler, optimizers)
-
     def step(self, *args, **kwargs):
         return  # `model(**batch)` is doing that automatically. Therefore, it's implementation is not needed
-
-
 def prepare_scheduler(accelerator, optimizer, scheduler):
     accelerator.print("Preparing scheduler")
     scheduler = get_optimizer_param_scheduler(optimizer)
     return scheduler
-
-
 class AbstractTrainStep(ABC):
     """Abstract class for batching, forward pass and loss handler."""
-
     def __init__(self, name):
         super().__init__()
         self.name = name
-
     def get_batch_func(self):
         pass
-
     def get_forward_step_func(self):
         pass
-
     def get_loss_func(self):
         pass
-
-
 class BertTrainStep(AbstractTrainStep):
     """
     Bert train step class.
-
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
@@ -399,22 +345,18 @@ class BertTrainStep(AbstractTrainStep):
             self.model_output_class = None
         else:
             self.model_output_class = SequenceClassifierOutput
-
     def get_batch_func(self, megatron_dataset_flag):
         def get_batch_megatron(data_iterator):
             """Build the batch."""
-
             # Items and their type.
             keys = ["text", "types", "labels", "is_random", "loss_mask", "padding_mask"]
             datatype = torch.int64
-
             # Broadcast data.
             if data_iterator is not None:
                 data = next(data_iterator)
             else:
                 data = None
             data_b = mpu.broadcast_data(keys, data, datatype)
-
             # Unpack.
             tokens = data_b["text"].long()
             types = data_b["types"].long()
@@ -422,14 +364,11 @@ class BertTrainStep(AbstractTrainStep):
             loss_mask = data_b["loss_mask"].float()
             lm_labels = data_b["labels"].long()
             padding_mask = data_b["padding_mask"].long()
-
             return tokens, types, sentence_order, loss_mask, lm_labels, padding_mask
-
         def get_batch_transformer(data_iterator):
             """Build the batch."""
             data = next(data_iterator)
             data = send_to_device(data, torch.cuda.current_device())
-
             # Unpack.
             tokens = data["input_ids"].long()
             padding_mask = data["attention_mask"].long()
@@ -447,34 +386,27 @@ class BertTrainStep(AbstractTrainStep):
                 sentence_order = data["next_sentence_label"].long()
             else:
                 sentence_order = None
-
             return tokens, types, sentence_order, loss_mask, lm_labels, padding_mask
-
         if megatron_dataset_flag:
             return get_batch_megatron
         else:
             return get_batch_transformer
-
     def get_loss_func(self, pretraining_flag, num_labels):
         def loss_func_pretrain(loss_mask, sentence_order, output_tensor):
             lm_loss_, sop_logits = output_tensor
-
             lm_loss_ = lm_loss_.float()
             loss_mask = loss_mask.float()
             lm_loss = torch.sum(lm_loss_.view(-1) * loss_mask.reshape(-1)) / loss_mask.sum()
-
             if sop_logits is not None:
                 sop_loss = F.cross_entropy(sop_logits.view(-1, 2).float(), sentence_order.view(-1), ignore_index=-1)
                 sop_loss = sop_loss.float()
                 loss = lm_loss + sop_loss
                 averaged_losses = average_losses_across_data_parallel_group([lm_loss, sop_loss])
                 return loss, {"lm loss": averaged_losses[0], "sop loss": averaged_losses[1]}
-
             else:
                 loss = lm_loss
                 averaged_losses = average_losses_across_data_parallel_group([lm_loss])
                 return loss, {"lm loss": averaged_losses[0]}
-
         def loss_func_finetune(labels, logits):
             if num_labels == 1:
                 #  We are doing regression
@@ -488,12 +420,10 @@ class BertTrainStep(AbstractTrainStep):
                 loss = loss_fct(logits, labels)
             averaged_losses = average_losses_across_data_parallel_group([loss])
             return loss, {"loss": averaged_losses[0]}
-
         if pretraining_flag:
             return loss_func_pretrain
         else:
             return loss_func_finetune
-
     def get_forward_step_func(self, pretraining_flag, bert_binary_head):
         def forward_step(data_iterator, model):
             """Forward step."""
@@ -507,14 +437,10 @@ class BertTrainStep(AbstractTrainStep):
             else:
                 logits = model(tokens, padding_mask, tokentype_ids=types)
                 return logits, partial(self.loss_func, labels)
-
         return forward_step
-
-
 class GPTTrainStep(AbstractTrainStep):
     """
     GPT train step class.
-
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
@@ -534,38 +460,31 @@ class GPTTrainStep(AbstractTrainStep):
             self.model_output_class = None
         else:
             self.model_output_class = CausalLMOutputWithCrossAttentions
-
     def get_batch_func(self, megatron_dataset_flag):
         def get_batch_megatron(data_iterator):
             """Generate a batch"""
             # Items and their type.
             keys = ["text"]
             datatype = torch.int64
-
             # Broadcast data.
             if data_iterator is not None:
                 data = next(data_iterator)
             else:
                 data = None
             data_b = mpu.broadcast_data(keys, data, datatype)
-
             # Unpack.
             tokens_ = data_b["text"].long()
             labels = tokens_[:, 1:].contiguous()
             tokens = tokens_[:, :-1].contiguous()
-
             # Get the masks and postition ids.
             attention_mask, loss_mask, position_ids = get_ltor_masks_and_position_ids(
                 tokens, self.eod_token, self.reset_position_ids, self.reset_attention_mask, self.eod_mask_loss
             )
-
             return tokens, labels, loss_mask, attention_mask, position_ids
-
         def get_batch_transformer(data_iterator):
             data = next(data_iterator)
             data = {"input_ids": data["input_ids"]}
             data = send_to_device(data, torch.cuda.current_device())
-
             tokens_ = data["input_ids"].long()
             padding = torch.zeros((tokens_.shape[0], 1), dtype=tokens_.dtype, device=tokens_.device) + self.eod_token
             tokens_ = torch.concat([tokens_, padding], dim=1)
@@ -576,15 +495,12 @@ class GPTTrainStep(AbstractTrainStep):
                 tokens, self.eod_token, self.reset_position_ids, self.reset_attention_mask, True
             )
             return tokens, labels, loss_mask, attention_mask, position_ids
-
         if megatron_dataset_flag:
             return get_batch_megatron
         else:
             return get_batch_transformer
-
     def get_loss_func(self):
         args = get_args()
-
         def loss_func(loss_mask, output_tensor):
             if args.return_logits:
                 losses, logits = output_tensor
@@ -593,33 +509,24 @@ class GPTTrainStep(AbstractTrainStep):
             losses = losses.float()
             loss_mask = loss_mask.view(-1).float()
             loss = torch.sum(losses.view(-1) * loss_mask) / loss_mask.sum()
-
             # Reduce loss for logging.
             averaged_loss = average_losses_across_data_parallel_group([loss])
-
             output_dict = {"lm loss": averaged_loss[0]}
             if args.return_logits:
                 output_dict.update({"logits": logits})
             return loss, output_dict
-
         return loss_func
-
     def get_forward_step_func(self):
         def forward_step(data_iterator, model):
             """Forward step."""
             # Get the batch.
             tokens, labels, loss_mask, attention_mask, position_ids = self.get_batch(data_iterator)
             output_tensor = model(tokens, position_ids, attention_mask, labels=labels)
-
             return output_tensor, partial(self.loss_func, loss_mask)
-
         return forward_step
-
-
 class T5TrainStep(AbstractTrainStep):
     """
     T5 train step class.
-
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
@@ -632,7 +539,6 @@ class T5TrainStep(AbstractTrainStep):
             self.model_output_class = None
         else:
             self.model_output_class = Seq2SeqLMOutput
-
     @staticmethod
     def attn_mask_postprocess(attention_mask):
         # We create a 3D attention mask from a 2D tensor mask.
@@ -645,13 +551,11 @@ class T5TrainStep(AbstractTrainStep):
         # Convert attention mask to binary:
         extended_attention_mask = attention_mask_bss < 0.5
         return extended_attention_mask
-
     @staticmethod
     def get_decoder_mask(seq_length, device):
         attention_mask = torch.tril(torch.ones((1, seq_length, seq_length), device=device))
         attention_mask = attention_mask < 0.5
         return attention_mask
-
     @staticmethod
     def get_enc_dec_mask(attention_mask, dec_seq_length, device):
         batch_size, _ = attention_mask.shape
@@ -663,38 +567,30 @@ class T5TrainStep(AbstractTrainStep):
         attention_mask_bss = attention_mask_bs1 * attention_mask_b1s
         extended_attention_mask = attention_mask_bss < 0.5
         return extended_attention_mask
-
     def get_batch_func(self, megatron_dataset_flag):
         def get_batch_megatron(data_iterator):
             """Build the batch."""
-
             keys = ["text_enc", "text_dec", "labels", "loss_mask", "enc_mask", "dec_mask", "enc_dec_mask"]
             datatype = torch.int64
-
             # Broadcast data.
             if data_iterator is not None:
                 data = next(data_iterator)
             else:
                 data = None
             data_b = mpu.broadcast_data(keys, data, datatype)
-
             # Unpack.
             tokens_enc = data_b["text_enc"].long()
             tokens_dec = data_b["text_dec"].long()
             labels = data_b["labels"].long()
             loss_mask = data_b["loss_mask"].float()
-
             enc_mask = data_b["enc_mask"] < 0.5
             dec_mask = data_b["dec_mask"] < 0.5
             enc_dec_mask = data_b["enc_dec_mask"] < 0.5
-
             return tokens_enc, tokens_dec, loss_mask, labels, enc_mask, dec_mask, enc_dec_mask
-
         def get_batch_transformer(data_iterator):
             """Build the batch."""
             data = next(data_iterator)
             data = send_to_device(data, torch.cuda.current_device())
-
             tokens_enc = data["input_ids"].long()
             labels = data["labels"].long()
             loss_mask = (labels != -100).to(torch.float)
@@ -710,26 +606,19 @@ class T5TrainStep(AbstractTrainStep):
             enc_dec_mask = T5TrainStep.get_enc_dec_mask(
                 data["attention_mask"].long(), tokens_dec.shape[1], tokens_dec.device
             )
-
             return tokens_enc, tokens_dec, loss_mask, labels, enc_mask, dec_mask, enc_dec_mask
-
         if megatron_dataset_flag:
             return get_batch_megatron
         else:
             return get_batch_transformer
-
     def get_loss_func(self):
         def loss_func(loss_mask, output_tensor):
             lm_loss_ = output_tensor.float()
             lm_loss = torch.sum(lm_loss_.view(-1) * loss_mask.reshape(-1)) / loss_mask.sum()
-
             loss = lm_loss
             averaged_losses = average_losses_across_data_parallel_group([lm_loss])
-
             return loss, {"lm loss": averaged_losses[0]}
-
         return loss_func
-
     def get_forward_step_func(self):
         def forward_step(data_iterator, model):
             """Forward step."""
@@ -741,20 +630,14 @@ class T5TrainStep(AbstractTrainStep):
             output_tensor = model(
                 tokens_enc, tokens_dec, enc_mask, dec_mask, enc_dec_mask, tokentype_ids=None, lm_labels=lm_labels
             )
-
             return output_tensor, partial(self.loss_func, loss_mask)
-
         return forward_step
-
-
 # intialize megatron setup
 def initialize(accelerator, extra_args_provider=None, args_defaults={}):
     accelerator.print("Initializing Megatron-LM")
     assert torch.cuda.is_available(), "Megatron requires CUDA."
-
     # Parse arguments
     args = parse_args(extra_args_provider, ignore_unknown_args=True)
-
     # Set defaults
     for key, value in args_defaults.items():
         if getattr(args, key, None) is not None:
@@ -767,17 +650,13 @@ def initialize(accelerator, extra_args_provider=None, args_defaults={}):
                     flush=True,
                 )
         setattr(args, key, value)
-
     if args.use_checkpoint_args or args_defaults.get("use_checkpoint_args", False):
         assert args.load is not None, "--use-checkpoints-args requires --load argument"
         load_args_from_checkpoint(args)
-
     validate_args(args)
-
     # set global args, build tokenizer, and set adlr-autoresume,
     # tensorboard-writer, and timers.
     set_global_variables(args)
-
     # torch.distributed initialization
     def finish_mpu_init():
         args = get_args()
@@ -791,7 +670,6 @@ def initialize(accelerator, extra_args_provider=None, args_defaults={}):
                 assert args.local_rank == device, "expected local-rank to be the same as rank % device-count."
             else:
                 args.local_rank = device
-
             # Set the tensor model-parallel, pipeline model-parallel, and
             # data-parallel communicators.
             if mpu.model_parallel_is_initialized():
@@ -803,23 +681,17 @@ def initialize(accelerator, extra_args_provider=None, args_defaults={}):
                     args.virtual_pipeline_model_parallel_size,
                     args.pipeline_model_parallel_split_rank,
                 )
-
         # Random seeds for reproducibility.
         if args.rank == 0:
             print("> setting random seeds to {} ...".format(args.seed))
         _set_random_seed(args.seed, args.data_parallel_random_init)
-
     args = get_args()
-
     # Megatron's MPU is the master. Complete initialization right away.
     finish_mpu_init()
-
     # Autoresume.
     _init_autoresume()
-
     # Compile dependencies.
     _compile_dependencies()
-
     # Set pytorch JIT layer fusion options and warmup JIT functions.
     set_jit_fusion_options()
     args = get_args()
@@ -829,12 +701,9 @@ def initialize(accelerator, extra_args_provider=None, args_defaults={}):
     else:
         args.bert_binary_head = False
     args.iteration = 0
-
-
 class MegatronEngine(torch.nn.Module):
     """
     Megatron-LM model wrapper
-
     Args:
         accelerator (:class:`~accelerate.Accelerator`): The accelerator object to use.
         model: Megatron-LM model
@@ -861,7 +730,6 @@ class MegatronEngine(torch.nn.Module):
         else:
             raise ValueError(f"Unsupported model type: {args.model_type_name}")
         self.optimizer.skipped_iter = False
-
         # Tracking loss.
         self.total_loss_dict = {}
         self.eval_total_loss_dict = {}
@@ -869,26 +737,21 @@ class MegatronEngine(torch.nn.Module):
         self.report_memory_flag = True
         if args.tensorboard_dir is not None:
             write_args_to_tensorboard()
-
     def train(self):
         for model_module in self.module:
             model_module.train()
         self.log_eval_results()
-
     def eval(self):
         for model_module in self.module:
             model_module.eval()
-
     def train_step(self, **batch_data):
         """
         Training step for Megatron-LM
-
         Args:
             batch_data (:obj:`dict`): The batch data to train on.
         """
         args = get_args()
         timers = get_timers()
-
         if len(batch_data) > 0:
             data_chunks = []
             if args.num_micro_batches > 1:
@@ -901,7 +764,6 @@ class MegatronEngine(torch.nn.Module):
                     )
             else:
                 data_chunks = [batch_data]
-
         if len(self.module) > 1:
             batch_data_iterator = (
                 [iter(data_chunks) for _ in range(len(self.module))]
@@ -910,13 +772,11 @@ class MegatronEngine(torch.nn.Module):
             )
         else:
             batch_data_iterator = iter(data_chunks) if len(batch_data) > 0 else None
-
         # Set grad to zero.
         if args.DDP_impl == "local" and args.use_contiguous_buffers_in_local_ddp:
             for partition in self.module:
                 partition.zero_grad_buffer()
         self.optimizer.zero_grad()
-
         # Forward pass.
         forward_backward_func = get_forward_backward_func()
         losses_reduced = forward_backward_func(
@@ -927,27 +787,22 @@ class MegatronEngine(torch.nn.Module):
             None,
             forward_only=False,
         )
-
         # Empty unused memory.
         if args.empty_unused_memory_level >= 1:
             torch.cuda.empty_cache()
-
         # Reduce gradients.
         timers("backward-reduce-model-grads").start()
         self.optimizer.reduce_model_grads(args, timers)
         timers("backward-reduce-model-grads").stop()
-
         # Update parameters.
         timers("optimizer").start()
         update_successful, grad_norm, num_zeros_in_grad = self.optimizer.step(args, timers)
         timers("optimizer").stop()
-
         # Gather params.
         if update_successful:
             timers("backward-gather-model-params").start()
             self.optimizer.gather_model_params(args, timers)
             timers("backward-gather-model-params").stop()
-
         # Update learning rate.
         if update_successful:
             if self.scheduler is not None:
@@ -956,17 +811,13 @@ class MegatronEngine(torch.nn.Module):
             skipped_iter = 0
         else:
             skipped_iter = 1
-
         self.optimizer.skipped_iter = not update_successful
-
         # Empty unused memory.
         if args.empty_unused_memory_level >= 2:
             torch.cuda.empty_cache()
-
         args.consumed_train_samples += (
             mpu.get_data_parallel_world_size() * args.micro_batch_size * get_num_microbatches()
         )
-
         if mpu.is_pipeline_last_stage(ignore_virtual=True):
             # Average loss across microbatches.
             loss_reduced = {}
@@ -978,11 +829,9 @@ class MegatronEngine(torch.nn.Module):
                     loss_reduced[key] = torch.concat(losses_reduced_for_key)
             return loss_reduced, skipped_iter, grad_norm, num_zeros_in_grad
         return {}, skipped_iter, grad_norm, num_zeros_in_grad
-
     def eval_step(self, **batch_data):
         """
         Evaluation step for Megatron-LM
-
         Args:
             batch_data (:obj:`dict`): The batch data to evaluate on.
         """
@@ -995,7 +844,6 @@ class MegatronEngine(torch.nn.Module):
                 )
         else:
             data_chunks = [batch_data]
-
         if len(self.module) > 1:
             batch_data_iterator = [iter(data_chunks) for _ in range(len(self.module))]
         else:
@@ -1012,11 +860,9 @@ class MegatronEngine(torch.nn.Module):
         # Empty unused memory
         if args.empty_unused_memory_level >= 1:
             torch.cuda.empty_cache()
-
         args.consumed_valid_samples += (
             mpu.get_data_parallel_world_size() * args.micro_batch_size * get_num_microbatches()
         )
-
         if mpu.is_pipeline_last_stage(ignore_virtual=True):
             # Average loss across microbatches.
             loss_reduced = {}
@@ -1029,7 +875,6 @@ class MegatronEngine(torch.nn.Module):
             return loss_reduced
         else:
             return {}
-
     def forward(self, **batch_data):
         # During training, we use train_step()
         # model(**batch_data) performs following operations by delegating it to `self.train_step`:
@@ -1077,12 +922,10 @@ class MegatronEngine(torch.nn.Module):
                     self.eval_total_loss_dict[key + "_num_iters"] = self.eval_total_loss_dict.get(
                         key + "_num_iters", torch.cuda.FloatTensor([0.0])
                     ) + torch.cuda.FloatTensor([1.0])
-
         loss = torch.tensor(0.0, device=args.local_rank)
         for key in loss_dict:
             if len(loss_dict[key].shape) == 0:
                 loss += loss_dict[key]
-
         logits = None
         if "logits" in loss_dict:
             logits = loss_dict["logits"]
@@ -1090,7 +933,6 @@ class MegatronEngine(torch.nn.Module):
         if self.train_step_handler.model_output_class is not None:
             return self.train_step_handler.model_output_class(loss=loss, logits=logits)
         return loss
-
     def log_eval_results(self):
         args = get_args()
         if args.tensorboard_dir is None or self.iteration == 0:
@@ -1110,13 +952,11 @@ class MegatronEngine(torch.nn.Module):
                 writer.add_scalar(f"{key} validation", value.item(), self.iteration)
                 if args.pretraining_flag:
                     writer.add_scalar(f"{key} validation ppl", ppl, self.iteration)
-
         length = len(string) + 1
         print_rank_last("-" * length)
         print_rank_last(string)
         print_rank_last("-" * length)
         self.eval_total_loss_dict = {}
-
     def save_checkpoint(self, output_dir):
         self.log_eval_results()
         args = get_args()
@@ -1124,7 +964,6 @@ class MegatronEngine(torch.nn.Module):
         torch.distributed.barrier()
         save_checkpoint(self.iteration, self.module, self.optimizer, self.scheduler)
         torch.distributed.barrier()
-
     def load_checkpoint(self, input_dir):
         args = get_args()
         args.load = input_dir
@@ -1136,7 +975,6 @@ class MegatronEngine(torch.nn.Module):
         self.iteration = iteration
         if args.fp16 and self.iteration == 0:
             self.optimizer.reload_model_params()
-
     def megatron_generate(
         self,
         inputs,
@@ -1153,7 +991,6 @@ class MegatronEngine(torch.nn.Module):
         """
         Generate method for GPT2 model. This method is used for inference. Supports both greedy and beam search along
         with sampling. Refer the Megatron-LM repo for more details
-
         Args:
             inputs (torch.Tensor): input ids
             attention_mask (torch.Tensor, optional): attention mask. Defaults to None.
@@ -1172,33 +1009,25 @@ class MegatronEngine(torch.nn.Module):
         args = get_args()
         if args.model_type_name != "gpt":
             raise NotImplementedError("Generate method is not implemented for this model")
-
         if args.data_parallel_size > 1:
             raise ValueError("Generate method requires data parallelism to be 1")
-
         if args.sequence_parallel:
             raise ValueError("Generate method requires sequence parallelism to be False")
-
         if args.recompute_granularity is not None:
             raise ValueError("Checkpoint activations cannot be set for inference")
-
         if args.vocab_file is None:
             raise ValueError("Vocab file is required for inference")
-
         # Prepare inputs
         if max_length is None and max_new_tokens is None:
             raise ValueError("`max_length` or `max_new_tokens` are required for inference")
-
         if temperature is None:
             temperature = 1.0
         elif not (0.0 < temperature <= 100.0):
             raise ValueError("temperature must be a positive number less than or equal to 100.0")
-
         if top_k is None:
             top_k = 0
         elif not (0 <= top_k <= 1000):
             raise ValueError("top_k must be a positive number less than or equal to 1000")
-
         if top_p is None:
             top_p = 0.0
         elif top_p > 0.0 and top_k > 0.0:
@@ -1206,19 +1035,15 @@ class MegatronEngine(torch.nn.Module):
         else:
             if not (0.0 <= top_p <= 1.0):
                 raise ValueError("top_p must be less than or equal to 1.0")
-
         top_p_decay = kwargs.get("top_p_decay", 0.0)
         if not (0.0 <= top_p_decay <= 1.0):
             raise ValueError("top_p_decay must be less than or equal to 1.0")
-
         top_p_bound = kwargs.get("top_p_bound", 0.0)
         if not (0.0 <= top_p_bound <= 1.0):
             raise ValueError("top_p_bound must be less than or equal to 1.0")
-
         add_BOS = kwargs.get("add_BOS", False)
         if not (isinstance(add_BOS, bool)):
             raise ValueError("add_BOS must be a boolean")
-
         beam_width = num_beams
         if beam_width is not None:
             if not isinstance(beam_width, int):
@@ -1227,17 +1052,13 @@ class MegatronEngine(torch.nn.Module):
                 raise ValueError("beam_width must be greater than 0")
             if inputs.shape[0] > 1:
                 return "When doing beam_search, batch size must be 1"
-
         tokenizer = get_tokenizer()
-
         stop_token = kwargs.get("stop_token", tokenizer.eod)
         if stop_token is not None:
             if not isinstance(stop_token, int):
                 raise ValueError("stop_token must be an integer")
-
         if length_penalty is None:
             length_penalty = 1.0
-
         sizes_list = None
         prompts_tokens_tensor = None
         prompts_length_tensor = None
@@ -1247,12 +1068,10 @@ class MegatronEngine(torch.nn.Module):
                 prompts_length_tensor = torch.cuda.LongTensor([inputs.shape[1]] * inputs.shape[0])
             else:
                 prompts_length_tensor = attention_mask.sum(axis=-1).cuda()
-
             if max_new_tokens is None:
                 max_new_tokens = max_length - inputs.shape[1]
             if max_new_tokens <= 0:
                 raise ValueError("max_new_tokens must be greater than 0")
-
             if add_BOS:
                 max_length = max_new_tokens + inputs.shape[1] + 1
                 # making sure that `max_length` is a multiple of 4 to leverage fused kernels
@@ -1269,22 +1088,18 @@ class MegatronEngine(torch.nn.Module):
                 max_new_tokens = max_length - inputs.shape[1]
                 padding = torch.cuda.LongTensor([[tokenizer.eod] * max_new_tokens] * inputs.shape[0])
                 prompts_tokens_tensor = torch.concat([inputs.cuda(), padding], axis=-1)
-
             # We need the sizes of these tensors for the boradcast
             sizes_list = [
                 prompts_tokens_tensor.size(0),  # Batch size
                 prompts_tokens_tensor.size(1),
             ]  # Sequence lenght
-
         # First, broadcast the sizes.
         sizes_tensor = broadcast_int_list(2, int_list=sizes_list, rank=0)
-
         # Now that we have the sizes, we can boradcast the tokens
         # and length tensors.
         sizes = sizes_tensor.tolist()
         context_tokens_tensor = broadcast_tensor(sizes, torch.int64, tensor=prompts_tokens_tensor, rank=0)
         context_length_tensor = broadcast_tensor(sizes[0], torch.int64, tensor=prompts_length_tensor, rank=0)
-
         # Run the inference
         random_seed = kwargs.get("random_seed", 0)
         torch.random.manual_seed(random_seed)
@@ -1313,27 +1128,20 @@ class MegatronEngine(torch.nn.Module):
                 use_eod_token_for_early_termination=True,
             )
         return tokens
-
-
 # other utilities
 def avg_losses_across_data_parallel_group(losses):
     """
     Average losses across data parallel group.
-
     Args:
         losses (List[Tensor]): List of losses to average across data parallel group.
     """
     return average_losses_across_data_parallel_group(losses)
-
-
 def gather_across_data_parallel_groups(tensor):
     """
     Recursively gather tensor in a nested list/tuple/dictionary of tensors from data parallel ranks.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to gather across data parallel ranks.
-
     """
     def _gpu_gather_one(tensor):
         if tensor.ndim == 0:
@@ -1344,5 +1152,4 @@ def gather_across_data_parallel_groups(tensor):
         ]
         torch.distributed.all_gather(output_tensors, tensor, group=mpu.get_data_parallel_group())
         return torch.cat(output_tensors, dim=0)
-
     return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)

src/utils/memory.py

@@ -6,19 +6,15 @@ def release_memory(*objects):
     """
     Releases memory from `objects` by setting them to `None` and calls `gc.collect()` and `torch.cuda.empty_cache()`.
     Returned objects should be reassigned to the same variables.
-
     Args:
         objects (`Iterable`):
             An iterable of objects
     Returns:
         A list of `None` objects to replace `objects`
-
     Example:
-
         ```python
         >>> import torch
         >>> from accelerate.utils import release_memory
-
         >>> a = torch.ones(1000, 1000).cuda()
         >>> b = torch.ones(1000, 1000).cuda()
         >>> a, b = release_memory(a, b)
@@ -36,12 +32,9 @@ def release_memory(*objects):
     else:
         torch.cuda.empty_cache()
     return objects
-
-
 def should_reduce_batch_size(exception: Exception) -> bool:
     """
     Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory
-
     Args:
         exception (`Exception`):
             An exception
@@ -54,40 +47,28 @@ def should_reduce_batch_size(exception: Exception) -> bool:
     if isinstance(exception, RuntimeError) and len(exception.args) == 1:
         return any(err in exception.args[0] for err in _statements)
     return False
-
-
 def find_executable_batch_size(function: callable = None, starting_batch_size: int = 128):
     """
     A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or
     CUDNN, the batch size is cut in half and passed to `function`
-
     `function` must take in a `batch_size` parameter as its first argument.
-
     Args:
         function (`callable`, *optional*):
             A function to wrap
         starting_batch_size (`int`, *optional*):
             The batch size to try and fit into memory
-
     Example:
-
     ```python
     >>> from accelerate.utils import find_executable_batch_size
-
-
     >>> @find_executable_batch_size(starting_batch_size=128)
     ... def train(batch_size, model, optimizer):
     ...     ...
-
-
     >>> train(model, optimizer)
     ```
     """
     if function is None:
         return functools.partial(find_executable_batch_size, starting_batch_size=starting_batch_size)
-
     batch_size = starting_batch_size
-
     def decorator(*args, **kwargs):
         nonlocal batch_size
         gc.collect()
@@ -122,5 +103,4 @@ def find_executable_batch_size(function: callable = None, starting_batch_size: i
                     batch_size //= 2
                 else:
                     raise
-
     return decorator

src/utils/modeling.py

@@ -1,13 +1,9 @@
 WEIGHTS_INDEX_NAME = "pytorch_model.bin.index.json"
-
 logger = logging.getLogger(__name__)
-
-
 def check_device_same(first_device, second_device):
     """
     Utility method to check if two `torch` devices are similar. When dealing with CUDA devices, torch throws `False`
     for `torch.device("cuda") == torch.device("cuda:0")` whereas they should be the same
-
     Args:
         first_device (`torch.device`):
             First device to check
@@ -16,29 +12,21 @@ def check_device_same(first_device, second_device):
     """
     if first_device.type != second_device.type:
         return False
-
     if first_device.type == "cuda" and first_device.index is None:
         # In case the first_device is a cuda device and have
         # the index attribute set to `None`, default it to `0`
         first_device = torch.device("cuda", index=0)
-
     if second_device.type == "cuda" and second_device.index is None:
         # In case the second_device is a cuda device and have
         # the index attribute set to `None`, default it to `0`
         second_device = torch.device("cuda", index=0)
-
     return first_device == second_device
-
-
 def convert_file_size_to_int(size: Union[int, str]):
     """
     Converts a size expressed as a string with digits an unit (like `"5MB"`) to an integer (in bytes).
-
     Args:
         size (`int` or `str`): The size to convert. Will be directly returned if an `int`.
-
     Example:
-
     ```py
     >>> convert_file_size_to_int("1MiB")
     1048576
@@ -68,18 +56,13 @@ def convert_file_size_to_int(size: Union[int, str]):
             mem_size = int_size // 8 if size.endswith("b") else int_size
     except ValueError:
         raise ValueError(err_msg)
-
     if mem_size <= 0:
         raise ValueError(err_msg)
     return mem_size
-
-
 def dtype_byte_size(dtype: torch.dtype):
     """
     Returns the size (in bytes) occupied by one parameter of type `dtype`.
-
     Example:
-
     ```py
     >>> dtype_byte_size(torch.float32)
     4
@@ -96,8 +79,6 @@ def dtype_byte_size(dtype: torch.dtype):
         raise ValueError(f"`dtype` is not a valid dtype: {dtype}.")
     bit_size = int(bit_search.groups()[0])
     return bit_size // 8
-
-
 def id_tensor_storage(tensor: torch.Tensor) -> Tuple[torch.device, int, int]:
     """
     Unique identifier to a tensor storage. Multiple different tensors can share the same underlying storage. For
@@ -130,29 +111,21 @@ def id_tensor_storage(tensor: torch.Tensor) -> Tuple[torch.device, int, int]:
             storage_ptr = 0
             # On torch >=2.0 this is the tensor size
             storage_size = tensor.nelement() * _SIZE[tensor.dtype]
-
     return tensor.device, storage_ptr, storage_size
-
-
 def shard_checkpoint(
     state_dict: Dict[str, torch.Tensor], max_shard_size: Union[int, str] = "10GB", weights_name: str = WEIGHTS_NAME
 ):
     """
     Splits a model state dictionary in sub-checkpoints so that the final size of each sub-checkpoint does not exceed a
     given size.
-
     The sub-checkpoints are determined by iterating through the `state_dict` in the order of its keys, so there is no
     optimization made to make each sub-checkpoint as close as possible to the maximum size passed. For example, if the
     limit is 10GB and we have weights of sizes [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] they will get sharded as [6GB], [6+2GB],
     [6+2+2GB] and not [6+2+2GB], [6+2GB], [6GB].
-
     <Tip warning={true}>
-
     If one of the model's weight is bigger that `max_sahrd_size`, it will end up in its own sub-checkpoint which will
     have a size greater than `max_shard_size`.
-
     </Tip>
-
     Args:
         state_dict (`Dict[str, torch.Tensor]`): The state dictionary of a model to save.
         max_shard_size (`int` or `str`, *optional*, defaults to `"10GB"`):
@@ -162,12 +135,10 @@ def shard_checkpoint(
             The name of the model save file.
     """
     max_shard_size = convert_file_size_to_int(max_shard_size)
-
     sharded_state_dicts = [{}]
     last_block_size = 0
     total_size = 0
     storage_id_to_block = {}
-
     for key, weight in state_dict.items():
         # when bnb serialization is used the weights in the state dict can be strings
         # check: https://github.com/huggingface/transformers/pull/24416 for more details
@@ -175,29 +146,23 @@ def shard_checkpoint(
             continue
         else:
             storage_id = id_tensor_storage(weight)
-
         # If a `weight` shares the same underlying storage as another tensor, we put `weight` in the same `block`
         if storage_id in storage_id_to_block:
             block_id = storage_id_to_block[storage_id]
             sharded_state_dicts[block_id][key] = weight
             continue
-
         weight_size = weight.numel() * dtype_byte_size(weight.dtype)
-
         # If this weight is going to tip up over the maximal size, we split.
         if last_block_size + weight_size > max_shard_size:
             sharded_state_dicts.append({})
             last_block_size = 0
-
         sharded_state_dicts[-1][key] = weight
         last_block_size += weight_size
         total_size += weight_size
         storage_id_to_block[storage_id] = len(sharded_state_dicts) - 1
-
     # If we only have one shard, we return it
     if len(sharded_state_dicts) == 1:
         return {weights_name: sharded_state_dicts[0]}, None
-
     # Otherwise, let's build the index
     weight_map = {}
     shards = {}
@@ -209,13 +174,10 @@ def shard_checkpoint(
         shards[shard_file] = shard
         for key in shard.keys():
             weight_map[key] = shard_file
-
     # Add the metadata
     metadata = {"total_size": total_size}
     index = {"metadata": metadata, "weight_map": weight_map}
     return shards, index
-
-
 def set_module_tensor_to_device(
     module: nn.Module,
     tensor_name: str,
@@ -227,7 +189,6 @@ def set_module_tensor_to_device(
     """
     A helper function to set a given tensor (parameter of buffer) of a module on a specific device (note that doing
     `param.to(device)` creates a new tensor not linked to the parameter, which is why we need this function).
-
     Args:
         module (`torch.nn.Module`):
             The module in which the tensor we want to move lives.
@@ -252,30 +213,24 @@ def set_module_tensor_to_device(
                 raise ValueError(f"{module} has no attribute {split}.")
             module = new_module
         tensor_name = splits[-1]
-
     if tensor_name not in module._parameters and tensor_name not in module._buffers:
         raise ValueError(f"{module} does not have a parameter or a buffer named {tensor_name}.")
     is_buffer = tensor_name in module._buffers
     old_value = getattr(module, tensor_name)
-
     if old_value.device == torch.device("meta") and device not in ["meta", torch.device("meta")] and value is None:
         raise ValueError(f"{tensor_name} is on the meta device, we need a `value` to put in on {device}.")
-
     if value is not None:
         if old_value.shape != value.shape:
             raise ValueError(
                 f'Trying to set a tensor of shape {value.shape} in "{tensor_name}" (which has shape {old_value.shape}), this look incorrect.'
             )
-
         if dtype is None:
             # For compatibility with PyTorch load_state_dict which converts state dict dtype to existing dtype in model
             value = value.to(old_value.dtype)
         elif not str(value.dtype).startswith(("torch.uint", "torch.int", "torch.bool")):
             value = value.to(dtype)
-
     param = module._parameters[tensor_name] if tensor_name in module._parameters else None
     param_cls = type(param)
-
     device_quantization = None
     with torch.no_grad():
         # leave it on cpu first before moving them to cuda
@@ -296,7 +251,6 @@ def set_module_tensor_to_device(
             if dtype is not None and device in ["meta", torch.device("meta")]:
                 if not str(old_value.dtype).startswith(("torch.uint", "torch.int", "torch.bool")):
                     new_value = new_value.to(dtype)
-
                 if not is_buffer:
                     module._parameters[tensor_name] = param_cls(new_value, requires_grad=old_value.requires_grad)
         elif isinstance(value, torch.Tensor):
@@ -352,15 +306,12 @@ def set_module_tensor_to_device(
         torch.npu.empty_cache()
     else:
         torch.cuda.empty_cache()
-
-
 def named_module_tensors(
     module: nn.Module, include_buffers: bool = True, recurse: bool = False, remove_non_persistent: bool = False
 ):
     """
     A helper function that gathers all the tensors (parameters + buffers) of a given module. If `include_buffers=True`
     it's the same as doing `module.named_parameters(recurse=recurse) + module.named_buffers(recurse=recurse)`.
-
     Args:
         module (`torch.nn.Module`):
             The module we want the tensors on.
@@ -374,7 +325,6 @@ def named_module_tensors(
     """
     for named_parameter in module.named_parameters(recurse=recurse):
         yield named_parameter
-
     if include_buffers:
         non_persistent_buffers = set()
         if remove_non_persistent:
@@ -383,12 +333,9 @@ def named_module_tensors(
             name, _ = named_buffer
             if name not in non_persistent_buffers:
                 yield named_buffer
-
-
 def get_non_persistent_buffers(module: nn.Module, recurse: bool = False):
     """
     Gather all non persistent buffers of a given modules into a set
-
     Args:
         module (`nn.Module`):
             The module we want the non persistent buffers on.
@@ -399,10 +346,7 @@ def get_non_persistent_buffers(module: nn.Module, recurse: bool = False):
     if recurse:
         for _, m in module.named_modules():
             non_persistent_buffers_set |= m._non_persistent_buffers_set
-
     return non_persistent_buffers_set
-
-
 class FindTiedParametersResult(list):
     """
     This is a subclass of a list to handle backward compatibility for Transformers. Do not rely on the fact this is not
@@ -410,19 +354,14 @@ class FindTiedParametersResult(list):
     """
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-
     def values(self):
         # TODO: at the next Transformers release (4.28.0) issue a deprecation warning here.
         return sum([x[1:] for x in self], [])
-
-
 def check_tied_parameters_in_config(model: nn.Module):
     """
     Check if there is any indication in the given model that some weights should be tied.
-
     Args:
         model (`torch.nn.Module`): The model to inspect
-
     Returns:
         bool: True if the model needs to have tied weights
     """
@@ -430,7 +369,6 @@ def check_tied_parameters_in_config(model: nn.Module):
     has_tied_word_embedding = False
     has_tied_encoder_decoder = False
     has_tied_module = False
-
     if "PreTrainedModel" in [c.__name__ for c in inspect.getmro(model.__class__)]:
         has_tied_word_embedding = (
             hasattr(model, "config")
@@ -443,10 +381,7 @@ def check_tied_parameters_in_config(model: nn.Module):
             and getattr(model.config, "tie_encoder_decoder", False)
         )
         has_tied_module = any(hasattr(module, "_tie_weights") for module in model.modules())
-
     return any([has_tied_word_embedding, has_tied_encoder_decoder, has_tied_module])
-
-
 def _get_param_device(param, device_map):
     if param in device_map:
         return device_map[param]
@@ -455,19 +390,14 @@ def _get_param_device(param, device_map):
         raise ValueError(f"The `device_map` does not contain the module {param}.")
     else:
         return _get_param_device(parent_param, device_map)
-
-
 def check_tied_parameters_on_same_device(tied_params, device_map):
     """
     Check if tied parameters are on the same device
-
     Args:
         tied_params (`List[List[str]]`):
             A list of lists of parameter names being all tied together.
-
         device_map (`Dict[str, Union[int, str, torch.device]]`):
             A map that specifies where each submodule should go.
-
     """
     for tie_param in tied_params:
         tie_param_devices = {}
@@ -478,31 +408,21 @@ def check_tied_parameters_on_same_device(tied_params, device_map):
                 f"Tied parameters are on different devices: {tie_param_devices}. "
                 "Please modify your custom device map or set `device_map='auto'`. "
             )
-
-
 def find_tied_parameters(model: nn.Module, **kwargs):
     """
     Find the tied parameters in a given model.
-
     <Tip warning={true}>
-
     The signature accepts keyword arguments, but they are for the recursive part of this function and you should ignore
     them.
-
     </Tip>
-
     Args:
         model (`torch.nn.Module`): The model to inspect.
-
     Returns:
         List[List[str]]: A list of lists of parameter names being all tied together.
-
     Example:
-
     ```py
     >>> from collections import OrderedDict
     >>> import torch.nn as nn
-
     >>> model = nn.Sequential(OrderedDict([("linear1", nn.Linear(4, 4)), ("linear2", nn.Linear(4, 4))]))
     >>> model.linear2.weight = model.linear1.weight
     >>> find_tied_parameters(model)
@@ -513,7 +433,6 @@ def find_tied_parameters(model: nn.Module, **kwargs):
     named_parameters = kwargs.get("named_parameters", None)
     prefix = kwargs.get("prefix", "")
     result = kwargs.get("result", {})
-
     if named_parameters is None:
         named_parameters = {n: p for n, p in model.named_parameters()}
     else:
@@ -529,19 +448,14 @@ def find_tied_parameters(model: nn.Module, **kwargs):
                         if new_name not in result:
                             result[new_name] = []
                         result[new_name].append(full_name)
-
     # Once we have treated direct parameters, we move to the child modules.
     for name, child in model.named_children():
         child_name = name if prefix == "" else f"{prefix}.{name}"
         find_tied_parameters(child, named_parameters=named_parameters, prefix=child_name, result=result)
-
     return FindTiedParametersResult([sorted([weight] + list(set(tied))) for weight, tied in result.items()])
-
-
 def retie_parameters(model, tied_params):
     """
     Reties tied parameters in a given model if the link was broken (for instance when adding hooks).
-
     Args:
         model (`torch.nn.Module`):
             The model in which to retie parameters.
@@ -567,8 +481,6 @@ def retie_parameters(model, tied_params):
                 for split in splits[:-1]:
                     module = getattr(module, split)
                 setattr(module, splits[-1], param_to_tie)
-
-
 def _get_proper_dtype(dtype: Union[str, torch.device]) -> torch.dtype:
     """
     Just does torch.dtype(dtype) if necessary.
@@ -578,8 +490,6 @@ def _get_proper_dtype(dtype: Union[str, torch.device]) -> torch.dtype:
         dtype = dtype.replace("torch.", "")
         dtype = getattr(torch, dtype)
     return dtype
-
-
 def compute_module_sizes(
     model: nn.Module,
     dtype: Optional[Union[str, torch.device]] = None,
@@ -605,10 +515,7 @@ def compute_module_sizes(
         name_parts = name.split(".")
         for idx in range(len(name_parts) + 1):
             module_sizes[".".join(name_parts[:idx])] += size
-
     return module_sizes
-
-
 def get_max_layer_size(
     modules: List[Tuple[str, torch.nn.Module]], module_sizes: Dict[str, int], no_split_module_classes: List[str]
 ):
@@ -617,7 +524,6 @@ def get_max_layer_size(
     definition of a layer being:
     - a module with no direct children (just parameters and buffers)
     - a module whose class name is in the list `no_split_module_classes`
-
     Args:
         modules (`List[Tuple[str, torch.nn.Module]]`):
             The list of named modules where we want to determine the maximum layer size.
@@ -625,7 +531,6 @@ def get_max_layer_size(
             A dictionary mapping each layer name to its size (as generated by `compute_module_sizes`).
         no_split_module_classes (`List[str]`):
             A list of class names for layers we don't want to be split.
-
     Returns:
         `Tuple[int, List[str]]`: The maximum size of a layer with the list of layer names realizing that maximum size.
     """
@@ -646,18 +551,14 @@ def get_max_layer_size(
         else:
             modules_to_treat = [(f"{module_name}.{n}", v) for n, v in modules_children] + modules_to_treat
     return max_size, layer_names
-
-
 def get_max_memory(max_memory: Optional[Dict[Union[int, str], Union[int, str]]] = None):
     """
     Get the maximum memory available if nothing is passed, converts string to int otherwise.
     """
     import psutil
-
     if max_memory is None:
         if not (torch.cuda.is_available() or is_npu_available() or is_xpu_available()):
             max_memory = {}
-
         else:
             # Make sure CUDA is initialized on each GPU to have the right memory info.
             if is_npu_available():
@@ -678,11 +579,9 @@ def get_max_memory(max_memory: Optional[Dict[Union[int, str], Union[int, str]]]
         else:
             max_memory["cpu"] = psutil.virtual_memory().available
         return max_memory
-
     for key in max_memory:
         if isinstance(max_memory[key], str):
             max_memory[key] = convert_file_size_to_int(max_memory[key])
-
     # Need to sort the device by type to make sure that we allocate the gpu first.
     # As gpu/npu/xpu are represented by int, we need to sort them first.
     gpu_devices = [k for k in max_memory.keys() if isinstance(k, int)]
@@ -706,10 +605,7 @@ def get_max_memory(max_memory: Optional[Dict[Union[int, str], Union[int, str]]]
                 f"Device {k} is not recognized, available devices are integers(for GPU/XPU), 'mps', 'cpu' and 'disk'"
             )
     max_memory = {k: max_memory[k] for k in all_devices}
-
     return max_memory
-
-
 def clean_device_map(device_map: Dict[str, Union[int, str, torch.device]], module_name: str = ""):
     """
     Cleans a device_map by grouping all submodules that go on the same device together.
@@ -721,21 +617,16 @@ def clean_device_map(device_map: Dict[str, Union[int, str, torch.device]], modul
         for k in [k for k in device_map if k.startswith(prefix)]:
             del device_map[k]
         device_map[module_name] = values[0]
-
     # Recurse over the children
     children_modules = [k for k in device_map.keys() if k.startswith(prefix) and len(k) > len(module_name)]
     idx = len(module_name.split(".")) + 1 if len(module_name) > 0 else 1
     children_modules = set(".".join(k.split(".")[:idx]) for k in children_modules)
     for child in children_modules:
         clean_device_map(device_map, module_name=child)
-
     return device_map
-
-
 def load_offloaded_weights(model, index, offload_folder):
     """
     Loads the weights from the offload folder into the model.
-
     Args:
         model (`torch.nn.Module`):
             The model to load the weights into.
@@ -760,8 +651,6 @@ def load_offloaded_weights(model, index, offload_folder):
         tensor_file = os.path.join(offload_folder, f"{param_name}.dat")
         weight = load_offloaded_weight(tensor_file, metadata)
         set_module_tensor_to_device(model, param_name, "cpu", value=weight, fp16_statistics=fp16_statistics)
-
-
 def get_balanced_memory(
     model: nn.Module,
     max_memory: Optional[Dict[Union[int, str], Union[int, str]]] = None,
@@ -772,14 +661,10 @@ def get_balanced_memory(
 ):
     """
     Compute a `max_memory` dictionary for [`infer_auto_device_map`] that will balance the use of each available GPU.
-
     <Tip>
-
     All computation is done analyzing sizes and dtypes of the model parameters. As a result, the model can be on the
     meta device (as it would if initialized within the `init_empty_weights` context manager).
-
     </Tip>
-
     Args:
         model (`torch.nn.Module`):
             The model to analyze.
@@ -800,7 +685,6 @@ def get_balanced_memory(
     # Get default / clean up max_memory
     user_not_set_max_memory = max_memory is None
     max_memory = get_max_memory(max_memory)
-
     if is_npu_available():
         num_devices = len([d for d in max_memory if torch.device(d).type == "npu" and max_memory[d] > 0])
     elif is_xpu_available():
@@ -817,10 +701,8 @@ def get_balanced_memory(
         )
     else:
         num_devices = len([d for d in max_memory if torch.device(d).type == "cuda" and max_memory[d] > 0])
-
     if num_devices == 0:
         return max_memory
-
     if num_devices == 1:
         # We cannot do low_zero on just one GPU, but we will still reserve some memory for the buffer
         low_zero = False
@@ -834,10 +716,8 @@ def get_balanced_memory(
                         "You can set `max_memory` in to a higher value to use more memory (at your own risk)."
                     )
                     break  # only one device
-
     module_sizes = compute_module_sizes(model, dtype=dtype, special_dtypes=special_dtypes)
     per_gpu = module_sizes[""] // (num_devices - 1 if low_zero else num_devices)
-
     # We can't just set the memory to model_size // num_devices as it will end being too small: each GPU will get
     # slightly less layers and some layers will end up offload at the end. So this function computes a buffer size to
     # add which is the biggest of:
@@ -847,7 +727,6 @@ def get_balanced_memory(
         no_split_module_classes = []
     elif not isinstance(no_split_module_classes, (list, tuple)):
         no_split_module_classes = [no_split_module_classes]
-
     # Identify the size of the no_split_block modules
     if len(no_split_module_classes) > 0:
         no_split_children = {}
@@ -860,13 +739,11 @@ def get_balanced_memory(
             class_name = submodule.__class__.__name__
             if class_name in no_split_module_classes and class_name not in no_split_children:
                 no_split_children[class_name] = size
-
             if set(no_split_children.keys()) == set(no_split_module_classes):
                 break
         buffer = max(no_split_children.values()) if len(no_split_children) > 0 else 0
     else:
         buffer = 0
-
     # Compute mean of final modules. In the first dict of module sizes, leaves are the parameters
     leaves = [n for n in module_sizes if len([p for p in module_sizes if n == "" or p.startswith(n + ".")]) == 0]
     module_sizes = {n: v for n, v in module_sizes.items() if n not in leaves}
@@ -875,7 +752,6 @@ def get_balanced_memory(
     mean_leaves = int(sum([module_sizes[n] for n in leaves]) / max(len(leaves), 1))
     buffer = int(1.25 * max(buffer, mean_leaves))
     per_gpu += buffer
-
     # Sorted list of GPUs id (we may have some gpu ids not included in the our max_memory list - let's ignore them)
     gpus_idx_list = list(
         sorted(
@@ -885,14 +761,10 @@ def get_balanced_memory(
     # The last device is left with max_memory just in case the buffer is not enough.
     for idx in gpus_idx_list[:-1]:
         max_memory[idx] = min(max_memory[0] if low_zero and idx == 0 else per_gpu, max_memory[idx])
-
     if low_zero:
         min_zero = max(0, module_sizes[""] - sum([max_memory[i] for i in range(1, num_devices)]))
         max_memory[0] = min(min_zero, max_memory[0])
-
     return max_memory
-
-
 def calculate_maximum_sizes(model: torch.nn.Module):
     "Computes the total size of the model and its largest layer"
     sizes = compute_module_sizes(model)
@@ -900,7 +772,6 @@ def calculate_maximum_sizes(model: torch.nn.Module):
     no_split_modules = getattr(model, "_no_split_modules", None)
     if no_split_modules is None:
         no_split_modules = []
-
     modules_to_treat = (
         list(model.named_parameters(recurse=False))
         + list(model.named_children())
@@ -909,8 +780,6 @@ def calculate_maximum_sizes(model: torch.nn.Module):
     largest_layer = get_max_layer_size(modules_to_treat, sizes, no_split_modules)
     total_size = sizes[""]
     return total_size, largest_layer
-
-
 def infer_auto_device_map(
     model: nn.Module,
     max_memory: Optional[Dict[Union[int, str], Union[int, str]]] = None,
@@ -929,14 +798,10 @@ def infer_auto_device_map(
     - if offload to the CPU is needed,we don't exceed the RAM available on the CPU.
     - if offload to the disk is needed, there is always room left on the CPU to put back the layer offloaded on disk
       that has the largest size.
-
     <Tip>
-
     All computation is done analyzing sizes and dtypes of the model parameters. As a result, the model can be on the
     meta device (as it would if initialized within the `init_empty_weights` context manager).
-
     </Tip>
-
     Args:
         model (`torch.nn.Module`):
             The model to analyze.
@@ -961,12 +826,10 @@ def infer_auto_device_map(
         no_split_module_classes = []
     elif not isinstance(no_split_module_classes, (list, tuple)):
         no_split_module_classes = [no_split_module_classes]
-
     devices = list(max_memory.keys())
     if "disk" not in devices:
         devices.append("disk")
     gpus = [device for device in devices if device not in ["cpu", "disk"]]
-
     # Devices that need to keep space for a potential offloaded layer.
     if "mps" in gpus:
         main_devices = ["mps"]
@@ -974,19 +837,15 @@ def infer_auto_device_map(
         main_devices = [gpus[0], "cpu"]
     else:
         main_devices = ["cpu"]
-
     module_sizes = compute_module_sizes(model, dtype=dtype, special_dtypes=special_dtypes)
     tied_parameters = find_tied_parameters(model)
-
     if check_tied_parameters_in_config(model) and len(tied_parameters) == 0:
         logger.warn(
             "The model weights are not tied. Please use the `tie_weights` method before using the `infer_auto_device` function."
         )
-
     device_map = OrderedDict()
     current_device = 0
     current_memory_used = 0
-
     # Direct submodules and parameters
     modules_to_treat = (
         list(model.named_parameters(recurse=False))
@@ -995,7 +854,6 @@ def infer_auto_device_map(
     )
     # Initialize maximum largest layer, to know which space to keep in memory
     max_layer_size, max_layer_names = get_max_layer_size(modules_to_treat, module_sizes, no_split_module_classes)
-
     # Ready ? This is going to be a bit messy.
     while len(modules_to_treat) > 0:
         name, module = modules_to_treat.pop(0)
@@ -1011,7 +869,6 @@ def infer_auto_device_map(
             )
         # Assess size needed
         module_size = module_sizes[name]
-
         # We keep relevant tied parameters only: one of the tied parameters in the group is inside the current module
         # and the other is not.
         tied_param_goups = [
@@ -1025,7 +882,6 @@ def infer_auto_device_map(
         tied_params = sum([[p for p in tied_group if name not in p] for tied_group in tied_param_goups], [])
         if verbose and len(tied_params) > 0:
             print(f"  So those parameters need to be taken into account {tied_params}")
-
         device = devices[current_device]
         current_max_size = max_memory[device] if device != "disk" else None
         # Reduce max size available by the largest layer.
@@ -1059,7 +915,6 @@ def infer_auto_device_map(
                     module_sizes,
                     no_split_module_classes,
                 )
-
         # Case 2, it fits! We're not entirely out of the wood though, because we may have some tied parameters.
         elif len(tied_params) > 0:
             # First locate all tied modules
@@ -1074,12 +929,10 @@ def infer_auto_device_map(
                     f"  It looks like {name} is going to fit on {devices[current_device]} but we have tied "
                     f"parameters to account for.\n  - Names {tied_params}\n  - Module names {tied_module_names}"
                 )
-
             # Let's see if it all fits first
             module_size_with_ties = module_size
             for tied_param, tied_module_name in zip(tied_params, tied_module_names):
                 module_size_with_ties += module_sizes[tied_module_name] - module_sizes[tied_param]
-
             if current_max_size is None or current_memory_used + module_size_with_ties <= current_max_size:
                 # We really really fit!
                 if verbose:
@@ -1094,7 +947,6 @@ def infer_auto_device_map(
                         ]
                         modules_to_treat.pop(tied_module_index)
                     device_map[tied_module_name] = devices[current_device]
-
             else:
                 # We don't fit with the tied modules. Next question is: can we split one of the tied modules to make it
                 # smaller or do we need to go on the next device?
@@ -1109,13 +961,11 @@ def infer_auto_device_map(
                     if len(tied_module_children) == 0 or tied_module.__class__.__name__ in no_split_module_classes:
                         # can't break this one.
                         continue
-
                     if verbose:
                         print(f"Splitting {tied_module_name}.")
                     tied_module_children = list(tied_module.named_parameters(recurse=False)) + tied_module_children
                     tied_module_children = [(f"{tied_module_name}.{n}", v) for n, v in tied_module_children]
                     tied_module_index = [i for i, (n, _) in enumerate(modules_to_treat) if n == tied_module_name][0]
-
                     modules_to_treat = (
                         [(name, module)]
                         + modules_to_treat[:tied_module_index]
@@ -1130,7 +980,6 @@ def infer_auto_device_map(
                     )
                     split_happened = True
                     break
-
                 if not split_happened:
                     # If the tied module is not split, we go to the next device
                     if verbose:
@@ -1138,7 +987,6 @@ def infer_auto_device_map(
                     current_device += 1
                     modules_to_treat = [(name, module)] + modules_to_treat
                     current_memory_used = 0
-
         else:
             if verbose:
                 if current_max_size is None:
@@ -1150,16 +998,12 @@ def infer_auto_device_map(
                     )
             current_memory_used += module_size
             device_map[name] = devices[current_device]
-
     if clean_result:
         device_map = clean_device_map(device_map)
     return device_map
-
-
 def check_device_map(model: nn.Module, device_map: Dict[str, Union[int, str, torch.device]]):
     """
     Checks a device map covers everything in a given model.
-
     Args:
         model (`torch.nn.Module`): The model to check the device map against.
         device_map (`Dict[str, Union[int, str, torch.device]]`): The device map to check.
@@ -1180,13 +1024,10 @@ def check_device_map(model: nn.Module, device_map: Dict[str, Union[int, str, tor
         raise ValueError(
             f"The device_map provided does not give any device for the following parameters: {non_covered_params}"
         )
-
-
 def load_state_dict(checkpoint_file, device_map=None):
     """
     Load a checkpoint from a given file. If the checkpoint is in the safetensors format and a device map is passed, the
     weights can be fast-loaded directly on the GPU.
-
     Args:
         checkpoint_file (`str`): The path to the checkpoint to load.
         device_map (`Dict[str, Union[int, str, torch.device]]`, *optional*):
@@ -1197,14 +1038,12 @@ def load_state_dict(checkpoint_file, device_map=None):
         with safe_open(checkpoint_file, framework="pt") as f:
             metadata = f.metadata()
             weight_names = f.keys()
-
         if metadata is None:
             logger.warn(
                 f"The safetensors archive passed at {checkpoint_file} does not contain metadata. "
                 "Make sure to save your model with the `save_pretrained` method. Defaulting to 'pt' metadata."
             )
             metadata = {"format": "pt"}
-
         if metadata.get("format") not in ["pt", "tf", "flax"]:
             raise OSError(
                 f"The safetensors archive passed at {checkpoint_file} does not contain the valid metadata. Make sure "
@@ -1218,12 +1057,10 @@ def load_state_dict(checkpoint_file, device_map=None):
             # if we only have one device we can load everything directly
             if len(set(device_map.values())) == 1:
                 return safe_load_file(checkpoint_file, device=list(device_map.values())[0])
-
             devices = list(set(device_map.values()) - {"disk"})
             # cpu device should always exist as fallback option
             if "cpu" not in devices:
                 devices.append("cpu")
-
             # For each device, get the weights that go there
             device_weights = {device: [] for device in devices}
             for module_name, device in device_map.items():
@@ -1231,7 +1068,6 @@ def load_state_dict(checkpoint_file, device_map=None):
                     device_weights[device].extend(
                         [k for k in weight_names if k == module_name or k.startswith(module_name + ".")]
                     )
-
             # all weights that haven't defined a device should be loaded on CPU
             device_weights["cpu"].extend([k for k in weight_names if k not in sum(device_weights.values(), [])])
             tensors = {}
@@ -1256,22 +1092,17 @@ def load_state_dict(checkpoint_file, device_map=None):
                             progress_bar.update()
             if progress_bar is not None:
                 progress_bar.close()
-
             return tensors
     else:
         return torch.load(checkpoint_file, map_location=torch.device("cpu"))
-
-
 def get_state_dict_offloaded_model(model: nn.Module):
     """
     Returns the state dictionary for an offloaded model via iterative onloading
-
     Args:
         model (`torch.nn.Module`):
             The offloaded model we want to save
     """
     from ..hooks import AlignDevicesHook
-
     state_dict = {}
     placeholders = set()
     for name, module in model.named_modules():
@@ -1293,7 +1124,6 @@ def get_state_dict_offloaded_model(model: nn.Module):
             module._hf_hook.execution_device = original_device
         else:
             module_state_dict = module.state_dict()
-
         for key in module_state_dict:
             # ignore placeholder parameters that are still on the meta device
             if module_state_dict[key].device == torch.device("meta"):
@@ -1306,10 +1136,7 @@ def get_state_dict_offloaded_model(model: nn.Module):
             placeholders.remove(key)
     if placeholders:
         logger.warning(f"The following tensors were not saved because they were still on meta device: {placeholders}")
-
     return state_dict
-
-
 def load_checkpoint_in_model(
     model: nn.Module,
     checkpoint: Union[str, os.PathLike],
@@ -1324,14 +1151,10 @@ def load_checkpoint_in_model(
     """
     Loads a (potentially sharded) checkpoint inside a model, potentially sending weights to a given device as they are
     loaded.
-
     <Tip warning={true}>
-
     Once loaded across devices, you still need to call [`dispatch_model`] on your model to make it able to run. To
     group the checkpoint loading and dispatch in one single call, use [`load_checkpoint_and_dispatch`].
-
     </Tip>
-
     Args:
         model (`torch.nn.Module`):
             The model in which we want to load a checkpoint.
@@ -1357,32 +1180,26 @@ def load_checkpoint_in_model(
             A list of the modules that we keep in `torch.float32` dtype.
         offload_8bit_bnb (`bool`, *optional*):
             Whether or not to enable offload of 8-bit modules on cpu/disk.
-
     """
     if offload_8bit_bnb:
         from .bnb import quantize_and_offload_8bit
-
     tied_params = find_tied_parameters(model)
-
     if check_tied_parameters_in_config(model) and len(tied_params) == 0:
         logger.warn(
             "The model weights are not tied. Please use the `tie_weights` method before using the `infer_auto_device` function."
         )
     if device_map is not None:
         check_tied_parameters_on_same_device(tied_params, device_map)
-
     if offload_folder is None and device_map is not None and "disk" in device_map.values():
         raise ValueError(
             "At least one of the model submodule will be offloaded to disk, please pass along an `offload_folder`."
         )
     elif offload_folder is not None and device_map is not None and "disk" in device_map.values():
         os.makedirs(offload_folder, exist_ok=True)
-
     if isinstance(dtype, str):
         # We accept "torch.float16" or just "float16"
         dtype = dtype.replace("torch.", "")
         dtype = getattr(torch, dtype)
-
     checkpoint_files = None
     index_filename = None
     if os.path.isfile(checkpoint):
@@ -1416,24 +1233,19 @@ def load_checkpoint_in_model(
             "`checkpoint` should be the path to a file containing a whole state dict, or the index of a sharded "
             f"checkpoint, or a folder containing a sharded checkpoint or the whole state dict, but got {checkpoint}."
         )
-
     if index_filename is not None:
         checkpoint_folder = os.path.split(index_filename)[0]
         with open(index_filename, "r") as f:
             index = json.loads(f.read())
-
         if "weight_map" in index:
             index = index["weight_map"]
         checkpoint_files = sorted(list(set(index.values())))
         checkpoint_files = [os.path.join(checkpoint_folder, f) for f in checkpoint_files]
-
     # Logic for missing/unexepected keys goes here.
-
     offload_index = {}
     if offload_state_dict:
         state_dict_folder = tempfile.mkdtemp()
         state_dict_index = {}
-
     buffer_names = [name for name, _ in model.named_buffers()]
     for checkpoint_file in checkpoint_files:
         checkpoint = load_state_dict(checkpoint_file, device_map=device_map)
@@ -1444,9 +1256,7 @@ def load_checkpoint_in_model(
                 # skip SCB parameter (for 8-bit serialization)
                 if "SCB" in param_name:
                     continue
-
                 module_name = param_name
-
                 while len(module_name) > 0 and module_name not in device_map:
                     module_name = ".".join(module_name.split(".")[:-1])
                 if module_name == "" and "" not in device_map:
@@ -1463,13 +1273,11 @@ def load_checkpoint_in_model(
                                 break
                         if proceed:
                             new_dtype = torch.float32
-
                 if "weight" in param_name and param_name.replace("weight", "SCB") in checkpoint.keys():
                     if param.dtype == torch.int8:
                         fp16_statistics = checkpoint[param_name.replace("weight", "SCB")]
                 else:
                     fp16_statistics = None
-
                 if param_device == "disk":
                     if offload_buffers or param_name not in buffer_names:
                         if new_dtype is None:
@@ -1501,25 +1309,18 @@ def load_checkpoint_in_model(
                         dtype=new_dtype,
                         fp16_statistics=fp16_statistics,
                     )
-
         # Force Python to clean up.
         del checkpoint
         gc.collect()
-
     save_offload_index(offload_index, offload_folder)
-
     # Load back offloaded state dict on CPU
     if offload_state_dict:
         load_offloaded_weights(model, state_dict_index, state_dict_folder)
         shutil.rmtree(state_dict_folder)
-
     retie_parameters(model, tied_params)
-
-
 def get_mixed_precision_context_manager(native_amp: bool = False, autocast_kwargs: AutocastKwargs = None):
     """
     Return a context manager for autocasting mixed precision
-
     Args:
         native_amp (`bool`, *optional*, defaults to False):
             Whether mixed precision is actually enabled.

src/utils/offload.py

@@ -17,35 +17,26 @@ def offload_weight(weight, weight_name, offload_folder, index=None):
     file_array[:] = array[:]
     file_array.flush()
     return index
-
-
 def load_offloaded_weight(weight_file, weight_info):
     shape = tuple(weight_info["shape"])
     if shape == ():
         # NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
         shape = (1,)
-
     dtype = weight_info["dtype"]
     if dtype == "bfloat16":
         # NumPy does not support bfloat16 so this was saved as a int16
         dtype = "int16"
-
     weight = np.memmap(weight_file, dtype=dtype, shape=shape, mode="r")
-
     if len(weight_info["shape"]) == 0:
         weight = weight[0]
     weight = torch.tensor(weight)
     if weight_info["dtype"] == "bfloat16":
         weight = weight.view(torch.bfloat16)
-
     return weight
-
-
 def save_offload_index(index, offload_folder):
     if index is None or len(index) == 0:
         # Nothing to save
         return
-
     offload_index_file = os.path.join(offload_folder, "index.json")
     if os.path.isfile(offload_index_file):
         with open(offload_index_file, "r", encoding="utf-8") as f:
@@ -53,15 +44,11 @@ def save_offload_index(index, offload_folder):
     else:
         current_index = {}
     current_index.update(index)
-
     with open(offload_index_file, "w", encoding="utf-8") as f:
         json.dump(current_index, f, indent=2)
-
-
 def offload_state_dict(save_dir: Union[str, os.PathLike], state_dict: Dict[str, torch.Tensor]):
     """
     Offload a state dict in a given folder.
-
     Args:
         save_dir (`str` or `os.PathLike`):
             The directory in which to offload the state dict.
@@ -72,15 +59,11 @@ def offload_state_dict(save_dir: Union[str, os.PathLike], state_dict: Dict[str,
     index = {}
     for name, parameter in state_dict.items():
         index = offload_weight(parameter, name, save_dir, index=index)
-
     # Update index
     save_offload_index(index, save_dir)
-
-
 class PrefixedDataset(Mapping):
     """
     Will access keys in a given dataset by adding a prefix.
-
     Args:
         dataset (`Mapping`): Any map with string keys.
         prefix (`str`): A prefix to add when trying to access any element in the underlying dataset.
@@ -88,21 +71,15 @@ class PrefixedDataset(Mapping):
     def __init__(self, dataset: Mapping, prefix: str):
         self.dataset = dataset
         self.prefix = prefix
-
     def __getitem__(self, key):
         return self.dataset[f"{self.prefix}{key}"]
-
     def __iter__(self):
         return iter([key for key in self.dataset if key.startswith(self.prefix)])
-
     def __len__(self):
         return len(self.dataset)
-
-
 class OffloadedWeightsLoader(Mapping):
     """
     A collection that loads weights stored in a given state dict or memory-mapped on disk.
-
     Args:
         state_dict (`Dict[str, torch.Tensor]`, *optional*):
             A dictionary parameter name to tensor.
@@ -121,7 +98,6 @@ class OffloadedWeightsLoader(Mapping):
     ):
         if state_dict is None and save_folder is None and index is None:
             raise ValueError("Need either a `state_dict`, a `save_folder` or an `index` containing offloaded weights.")
-
         self.state_dict = {} if state_dict is None else state_dict
         self.save_folder = save_folder
         if index is None and save_folder is not None:
@@ -131,7 +107,6 @@ class OffloadedWeightsLoader(Mapping):
         self.all_keys = list(self.state_dict.keys())
         self.all_keys.extend([key for key in self.index if key not in self.all_keys])
         self.device = device
-
     def __getitem__(self, key: str):
         # State dict gets priority
         if key in self.state_dict:
@@ -147,28 +122,20 @@ class OffloadedWeightsLoader(Mapping):
                 # if failed to get_tensor on the device, such as bf16 on mps, try to load it on CPU first
                 with safe_open(weight_info["safetensors_file"], framework="pt", device="cpu") as f:
                     tensor = f.get_tensor(weight_info.get("weight_name", key))
-
             if "dtype" in weight_info:
                 tensor = tensor.to(getattr(torch, weight_info["dtype"]))
-
             if tensor.device != torch.device(device):
                 tensor = tensor.to(device)
             return tensor
-
         weight_file = os.path.join(self.save_folder, f"{key}.dat")
         return load_offloaded_weight(weight_file, weight_info)
-
     def __iter__(self):
         return iter(self.all_keys)
-
     def __len__(self):
         return len(self.all_keys)
-
-
 def extract_submodules_state_dict(state_dict: Dict[str, torch.Tensor], submodule_names: List[str]):
     """
     Extract the sub state-dict corresponding to a list of given submodules.
-
     Args:
         state_dict (`Dict[str, torch.Tensor]`): The state dict to extract from.
         submodule_names (`List[str]`): The list of submodule names we want to extract.

src/utils/operations.py

@@ -3,8 +3,6 @@ A set of basic tensor ops compatible with tpu, gpu, and multigpu
 """
 def is_torch_tensor(tensor):
     return isinstance(tensor, torch.Tensor)
-
-
 def is_torch_xpu_tensor(tensor):
     return isinstance(
         tensor,
@@ -16,12 +14,8 @@ def is_torch_xpu_tensor(tensor):
         torch.xpu.DoubleTensor,
         torch.xpu.BFloat16Tensor,
     )
-
-
 def is_tensor_information(tensor_info):
     return isinstance(tensor_info, TensorInformation)
-
-
 def is_namedtuple(data):
     """
     Checks if `x` is a `namedtuple` or not. Can have false positives, but only if a user is trying to mimic a
@@ -35,8 +29,6 @@ def is_namedtuple(data):
     if not isinstance(fields, tuple):
         return False
     return all(isinstance(member, str) for member in fields)
-
-
 def honor_type(obj, generator):
     """
     Cast a generator to the same type as obj (list, tuple, or namedtuple)
@@ -46,12 +38,9 @@ def honor_type(obj, generator):
         return type(obj)(*list(generator))
     else:
         return type(obj)(generator)
-
-
 def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_other_type=False, **kwargs):
     """
     Recursively apply a function on a data structure that is a nested list/tuple/dictionary of a given base type.
-
     Args:
         func (`callable`):
             The function to recursively apply.
@@ -66,7 +55,6 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth
             `main_type`. If `False`, the function will leave objects of types different than `main_type` unchanged.
         **kwargs:
             Keyword arguments that will be passed to `func` when applied on the unpacked data.
-
     Returns:
         The same data structure as `data` with `func` applied to every object of type `main_type`.
     """
@@ -97,18 +85,14 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth
             f"objects that are valid for `{test_type.__name__}` should be passed."
         )
     return data
-
-
 def send_to_device(tensor, device, non_blocking=False, skip_keys=None):
     """
     Recursively sends the elements in a nested list/tuple/dictionary of tensors to a given device.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to send to a given device.
         device (`torch.device`):
             The device to send the data to.
-
     Returns:
         The same data structure as `tensor` with all tensors sent to the proper device.
     """
@@ -137,68 +121,49 @@ def send_to_device(tensor, device, non_blocking=False, skip_keys=None):
             return tensor.to(device)
     else:
         return tensor
-
-
 def get_data_structure(data):
     """
     Recursively gathers the information needed to rebuild a nested list/tuple/dictionary of tensors.
-
     Args:
         data (nested list/tuple/dictionary of `torch.Tensor`):
             The data to send to analyze.
-
     Returns:
         The same data structure as `data` with [`~utils.TensorInformation`] instead of tensors.
     """
     def _get_data_structure(tensor):
         return TensorInformation(shape=tensor.shape, dtype=tensor.dtype)
-
     return recursively_apply(_get_data_structure, data)
-
-
 def get_shape(data):
     """
     Recursively gathers the shape of a nested list/tuple/dictionary of tensors as a list.
-
     Args:
         data (nested list/tuple/dictionary of `torch.Tensor`):
             The data to send to analyze.
-
     Returns:
         The same data structure as `data` with lists of tensor shapes instead of tensors.
     """
     def _get_shape(tensor):
         return list(tensor.shape)
-
     return recursively_apply(_get_shape, data)
-
-
 def initialize_tensors(data_structure):
     """
     Recursively initializes tensors from a nested list/tuple/dictionary of [`~utils.TensorInformation`].
-
     Returns:
         The same data structure as `data` with tensors instead of [`~utils.TensorInformation`].
     """
     def _initialize_tensor(tensor_info):
         return torch.empty(*tensor_info.shape, dtype=tensor_info.dtype)
-
     return recursively_apply(_initialize_tensor, data_structure, test_type=is_tensor_information)
-
-
 def find_batch_size(data):
     """
     Recursively finds the batch size in a nested list/tuple/dictionary of lists of tensors.
-
     Args:
         data (nested list/tuple/dictionary of `torch.Tensor`): The data from which to find the batch size.
-
     Returns:
         `int`: The batch size.
     """
     if isinstance(data, (tuple, list, Mapping)) and (len(data) == 0):
         raise ValueError(f"Cannot find the batch size from empty {type(data)}.")
-
     if isinstance(data, (tuple, list)):
         return find_batch_size(data[0])
     elif isinstance(data, Mapping):
@@ -207,15 +172,11 @@ def find_batch_size(data):
     elif not isinstance(data, torch.Tensor):
         raise TypeError(f"Can only find the batch size of tensors but got {type(data)}.")
     return data.shape[0]
-
-
 def listify(data):
     """
     Recursively finds tensors in a nested list/tuple/dictionary and converts them to a list of numbers.
-
     Args:
         data (nested list/tuple/dictionary of `torch.Tensor`): The data from which to convert to regular numbers.
-
     Returns:
         The same data structure as `data` with lists of numbers instead of `torch.Tensor`.
     """
@@ -227,40 +188,30 @@ def listify(data):
             # Until Numpy adds bfloat16, we must convert float32.
             tensor = tensor.to(torch.float32)
         return tensor.tolist()
-
     return recursively_apply(_convert_to_list, data)
-
-
 def _tpu_gather(tensor):
     def _tpu_gather_one(tensor):
         if tensor.ndim == 0:
             tensor = tensor.clone()[None]
-
         # Can only gather contiguous tensors
         if not tensor.is_contiguous():
             tensor = tensor.contiguous()
         return xm.all_gather(tensor)
-
     res = recursively_apply(_tpu_gather_one, tensor, error_on_other_type=True)
     xm.mark_step()
     return res
-
-
 def _gpu_gather(tensor):
     state = PartialState()
     if is_torch_version(">=", "1.13"):
         gather_op = torch.distributed.all_gather_into_tensor
     else:
         gather_op = torch.distributed._all_gather_base
-
     def _gpu_gather_one(tensor):
         if tensor.ndim == 0:
             tensor = tensor.clone()[None]
-
         # Can only gather contiguous tensors
         if not tensor.is_contiguous():
             tensor = tensor.contiguous()
-
         if state.backend is not None and state.backend != "gloo":
             # We use `empty` as `all_gather_into_tensor` slightly
             # differs from `all_gather` for better efficiency,
@@ -280,18 +231,13 @@ def _gpu_gather(tensor):
             output_tensors = [torch.empty_like(tensor) for _ in range(state.num_processes)]
             torch.distributed.all_gather(output_tensors, tensor)
             return torch.cat(output_tensors, dim=0)
-
     return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)
-
-
 class DistributedOperationException(Exception):
     """
     An exception class for distributed operations. Raised if the operation cannot be performed due to the shape of the
     tensors.
     """
     pass
-
-
 def verify_operation(function):
     """
     Verifies that `tensor` is the same shape across all processes. Only ran if `PartialState().debug` is `True`.
@@ -322,10 +268,7 @@ def verify_operation(function):
                     f"\n\nOperation: `{operation}`\nInput shapes:\n  - {process_shape_str}"
                 )
         return function(*args, **kwargs)
-
     return wrapper
-
-
 def chained_operation(function):
     """
     Checks that `verify_operation` failed and if so reports a more helpful error chaining the existing
@@ -340,19 +283,14 @@ def chained_operation(function):
             raise DistributedOperationException(
                 f"Error found while calling `{operation}`. Please see the earlier error for more details."
             ) from e
-
     return wrapper
-
-
 @verify_operation
 def gather(tensor):
     """
     Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to gather.
-
     Returns:
         The same data structure as `tensor` with all tensors sent to the proper device.
     """
@@ -362,23 +300,17 @@ def gather(tensor):
         return _gpu_gather(tensor)
     else:
         return tensor
-
-
 def _gpu_gather_object(object: Any):
     output_objects = [None for _ in range(PartialState().num_processes)]
     torch.distributed.all_gather_object(output_objects, object)
     # all_gather_object returns a list of lists, so we need to flatten it
     return [x for y in output_objects for x in y]
-
-
 def gather_object(object: Any):
     """
     Recursively gather object in a nested list/tuple/dictionary of objects from all devices.
-
     Args:
         object (nested list/tuple/dictionary of picklable object):
             The data to gather.
-
     Returns:
         The same data structure as `object` with all the objects sent to every device.
     """
@@ -388,35 +320,26 @@ def gather_object(object: Any):
         return _gpu_gather_object(object)
     else:
         return object
-
-
 def _gpu_broadcast(data, src=0):
     def _gpu_broadcast_one(tensor, src=0):
         torch.distributed.broadcast(tensor, src=src)
         return tensor
-
     return recursively_apply(_gpu_broadcast_one, data, error_on_other_type=True, src=src)
-
-
 def _tpu_broadcast(tensor, src=0, name="broadcast tensor"):
     if isinstance(tensor, (list, tuple)):
         return honor_type(tensor, (_tpu_broadcast(t, name=f"{name}_{i}") for i, t in enumerate(tensor)))
     elif isinstance(tensor, Mapping):
         return type(tensor)({k: _tpu_broadcast(v, name=f"{name}_{k}") for k, v in tensor.items()})
     return xm.mesh_reduce(name, tensor, lambda x: x[src])
-
-
 @verify_operation
 def broadcast(tensor, from_process: int = 0):
     """
     Recursively broadcast tensor in a nested list/tuple/dictionary of tensors to all devices.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to gather.
         from_process (`int`, *optional*, defaults to 0):
             The process from which to send the data
-
     Returns:
         The same data structure as `tensor` with all tensors broadcasted to the proper device.
     """
@@ -426,18 +349,14 @@ def broadcast(tensor, from_process: int = 0):
         return _gpu_broadcast(tensor, src=from_process)
     else:
         return tensor
-
-
 def broadcast_object_list(object_list, from_process: int = 0):
     """
     Broadcast a list of picklable objects form one process to the others.
-
     Args:
         object_list (list of picklable objects):
             The list of objects to broadcast. This list will be modified inplace.
         from_process (`int`, *optional*, defaults to 0):
             The process from which to send the data.
-
     Returns:
         The same list containing the objects from process 0.
     """
@@ -447,37 +366,28 @@ def broadcast_object_list(object_list, from_process: int = 0):
     elif PartialState().distributed_type in TORCH_DISTRIBUTED_OPERATION_TYPES:
         torch.distributed.broadcast_object_list(object_list, src=from_process)
     return object_list
-
-
 def slice_tensors(data, tensor_slice, process_index=None, num_processes=None):
     """
     Recursively takes a slice in a nested list/tuple/dictionary of tensors.
-
     Args:
         data (nested list/tuple/dictionary of `torch.Tensor`):
             The data to slice.
         tensor_slice (`slice`):
             The slice to take.
-
     Returns:
         The same data structure as `data` with all the tensors slices.
     """
     def _slice_tensor(tensor, tensor_slice):
         return tensor[tensor_slice]
-
     return recursively_apply(_slice_tensor, data, tensor_slice)
-
-
 def concatenate(data, dim=0):
     """
     Recursively concatenate the tensors in a nested list/tuple/dictionary of lists of tensors with the same shape.
-
     Args:
         data (nested list/tuple/dictionary of lists of tensors `torch.Tensor`):
             The data to concatenate.
         dim (`int`, *optional*, defaults to 0):
             The dimension on which to concatenate.
-
     Returns:
         The same data structure as `data` with all the tensors concatenated.
     """
@@ -488,18 +398,13 @@ def concatenate(data, dim=0):
     elif not isinstance(data[0], torch.Tensor):
         raise TypeError(f"Can only concatenate tensors but got {type(data[0])}")
     return torch.cat(data, dim=dim)
-
-
 class CannotPadNestedTensorWarning(UserWarning):
     pass
-
-
 @chained_operation
 def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
     """
     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.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to gather.
@@ -519,7 +424,6 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
             return tensor
         if dim >= len(tensor.shape):
             return tensor
-
         # Gather all sizes
         size = torch.tensor(tensor.shape, device=tensor.device)[None]
         sizes = gather(size).cpu()
@@ -527,7 +431,6 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
         max_size = max(s[dim] for s in sizes)
         if max_size == tensor.shape[dim]:
             return tensor
-
         old_size = tensor.shape
         new_size = list(old_size)
         new_size[dim] = max_size
@@ -540,18 +443,14 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
             indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(new_size)))
         new_tensor[indices] = tensor
         return new_tensor
-
     return recursively_apply(
         _pad_across_processes, tensor, error_on_other_type=True, dim=dim, pad_index=pad_index, pad_first=pad_first
     )
-
-
 @verify_operation
 def reduce(tensor, reduction="mean", scale=1.0):
     """
     Recursively reduce the tensors in a nested list/tuple/dictionary of lists of tensors across all processes by the
     mean of a given operation.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to reduce.
@@ -559,7 +458,6 @@ def reduce(tensor, reduction="mean", scale=1.0):
             A reduction method. Can be of "mean", "sum", or "none"
         scale (`float`, *optional*):
             A default scaling value to be applied after the reduce, only valied on XLA.
-
     Returns:
         The same data structure as `data` with all the tensors reduced.
     """
@@ -575,73 +473,52 @@ def reduce(tensor, reduction="mean", scale=1.0):
         if reduction == "mean":
             cloned_tensor /= state.num_processes
         return cloned_tensor
-
     return recursively_apply(
         _reduce_across_processes, tensor, error_on_other_type=True, reduction=reduction, scale=scale
     )
-
-
 def convert_to_fp32(tensor):
     """
     Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.
-
     Args:
         tensor (nested list/tuple/dictionary of `torch.Tensor`):
             The data to convert from FP16/BF16 to FP32.
-
     Returns:
         The same data structure as `tensor` with all tensors that were in FP16/BF16 precision converted to FP32.
     """
     def _convert_to_fp32(tensor):
         return tensor.float()
-
     def _is_fp16_bf16_tensor(tensor):
         return hasattr(tensor, "dtype") and tensor.dtype in (torch.float16, torch.bfloat16)
-
     return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_bf16_tensor)
-
-
 class ConvertOutputsToFp32:
     """
     Decorator to apply to a function outputing tensors (like a model forward pass) that ensures the outputs in FP16
     precision will be convert back to FP32.
-
     Args:
         model_forward (`Callable`):
             The function which outputs we want to treat.
-
     Returns:
         The same function as `model_forward` but with converted outputs.
     """
     def __init__(self, model_forward):
         self.model_forward = model_forward
         update_wrapper(self, model_forward)
-
     def __call__(self, *args, **kwargs):
         return convert_to_fp32(self.model_forward(*args, **kwargs))
-
     def __getstate__(self):
         raise pickle.PicklingError(
             "Cannot pickle a prepared model with automatic mixed precision, please unwrap the model with `Accelerator.unwrap_model(model)` before pickling it."
         )
-
-
 def convert_outputs_to_fp32(model_forward):
     model_forward = ConvertOutputsToFp32(model_forward)
-
     def forward(*args, **kwargs):
         return model_forward(*args, **kwargs)
-
     # To act like a decorator so that it can be popped when doing `extract_model_from_parallel`
     forward.__wrapped__ = model_forward
-
     return forward
-
-
 def find_device(data):
     """
     Finds the device on which a nested dict/list/tuple of tensors lies (assuming they are all on the same device).
-
     Args:
         (nested list/tuple/dictionary of `torch.Tensor`): The data we want to know the device of.
     """

src/utils/other.py

@@ -1,10 +1,6 @@
 logger = get_logger(__name__)
-
-
 if is_tpu_available(check_device=False):
     import torch_xla.core.xla_model as xm
-
-
 def is_compiled_module(module):
     """
     Check whether the module was compiled with torch.compile()
@@ -12,41 +8,30 @@ def is_compiled_module(module):
     if is_torch_version("<", "2.0.0") or not hasattr(torch, "_dynamo"):
         return False
     return isinstance(module, torch._dynamo.eval_frame.OptimizedModule)
-
-
 def extract_model_from_parallel(model, keep_fp32_wrapper: bool = True):
     """
     Extract a model from its distributed containers.
-
     Args:
         model (`torch.nn.Module`):
             The model to extract.
         keep_fp32_wrapper (`bool`, *optional*):
             Whether to remove mixed precision hooks from the model.
-
     Returns:
         `torch.nn.Module`: The extracted model.
     """
     options = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)
-
     is_compiled = is_compiled_module(model)
     if is_compiled:
         compiled_model = model
         model = model._orig_mod
-
     if is_deepspeed_available():
         from deepspeed import DeepSpeedEngine
-
         options += (DeepSpeedEngine,)
-
     if is_torch_version(">=", FSDP_PYTORCH_VERSION) and is_torch_distributed_available():
         from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
-
         options += (FSDP,)
-
     while isinstance(model, options):
         model = model.module
-
     if not keep_fp32_wrapper:
         forward = getattr(model, "forward")
         original_forward = model.__dict__.pop("_original_forward", None)
@@ -58,31 +43,21 @@ def extract_model_from_parallel(model, keep_fp32_wrapper: bool = True):
             model.forward = MethodType(forward, model)
         if getattr(model, "_converted_to_transformer_engine", False):
             convert_model(model, to_transformer_engine=False)
-
     if is_compiled:
         compiled_model._orig_mod = model
         model = compiled_model
-
     return model
-
-
 def wait_for_everyone():
     """
     Introduces a blocking point in the script, making sure all processes have reached this point before continuing.
-
     <Tip warning={true}>
-
     Make sure all processes will reach this instruction otherwise one of your processes will hang forever.
-
     </Tip>
     """
     PartialState().wait_for_everyone()
-
-
 def clean_state_dict_for_safetensors(state_dict: dict):
     """
     Cleans the state dictionary from a model and removes tensor aliasing if present.
-
     Args:
         state_dict (`dict`):
             The state dictionary from a model
@@ -92,7 +67,6 @@ def clean_state_dict_for_safetensors(state_dict: dict):
     for name, tensor in state_dict.items():
         if not isinstance(tensor, str):
             ptrs[id_tensor_storage(tensor)].append(name)
-
     # These are all pointers of tensors with shared memory
     shared_ptrs = {ptr: names for ptr, names in ptrs.items() if len(names) > 1}
     warn_names = set()
@@ -112,12 +86,9 @@ def clean_state_dict_for_safetensors(state_dict: dict):
         )
     state_dict = {k: v.contiguous() if isinstance(v, torch.Tensor) else v for k, v in state_dict.items()}
     return state_dict
-
-
 def save(obj, f, save_on_each_node: bool = False, safe_serialization: bool = False):
     """
     Save the data to disk. Use in place of `torch.save()`.
-
     Args:
         obj:
             The data to save
@@ -135,28 +106,21 @@ def save(obj, f, save_on_each_node: bool = False, safe_serialization: bool = Fal
             obj = clean_state_dict_for_safetensors(obj)
     else:
         save_func = torch.save
-
     if PartialState().distributed_type == DistributedType.TPU:
         xm.save(obj, f)
     elif PartialState().is_main_process and not save_on_each_node:
         save_func(obj, f)
     elif PartialState().is_local_main_process and save_on_each_node:
         save_func(obj, f)
-
-
 @contextmanager
 def clear_environment():
     """
     A context manager that will cache origin `os.environ` and replace it with a empty dictionary in this context.
-
     When this context exits, the cached `os.environ` will be back.
-
     Example:
-
     ```python
     >>> import os
     >>> from accelerate.utils import clear_environment
-
     >>> os.environ["FOO"] = "bar"
     >>> with clear_environment():
     ...     print(os.environ)
@@ -164,32 +128,23 @@ def clear_environment():
     ...     print(os.environ["FOO"])
     {}
     new_bar
-
     >>> print(os.environ["FOO"])
     bar
     ```
     """
     _old_os_environ = os.environ
     os.environ = dict()
-
     yield
-
     os.environ = _old_os_environ
-
-
 @contextmanager
 def patch_environment(**kwargs):
     """
     A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting.
-
     Will convert the values in `kwargs` to strings and upper-case all the keys.
-
     Example:
-
     ```python
     >>> import os
     >>> from accelerate.utils import patch_environment
-
     >>> with patch_environment(FOO="bar"):
     ...     print(os.environ["FOO"])  # prints "bar"
     >>> print(os.environ["FOO"])  # raises KeyError
@@ -201,9 +156,7 @@ def patch_environment(**kwargs):
         if key in os.environ:
             existing_vars[key] = os.environ[key]
         os.environ[key] = str(value)
-
     yield
-
     for key in kwargs:
         key = key.upper()
         if key in existing_vars:
@@ -211,8 +164,6 @@ def patch_environment(**kwargs):
             os.environ[key] = existing_vars[key]
         else:
             os.environ.pop(key, None)
-
-
 def get_pretty_name(obj):
     """
     Gets a pretty name from `obj`.
@@ -224,12 +175,9 @@ def get_pretty_name(obj):
     if hasattr(obj, "__name__"):
         return obj.__name__
     return str(obj)
-
-
 def merge_dicts(source, destination):
     """
     Recursively merges two dictionaries.
-
     Args:
         source (`dict`): The dictionary to merge into `destination`.
         destination (`dict`): The dictionary to merge `source` into.
@@ -240,10 +188,7 @@ def merge_dicts(source, destination):
             merge_dicts(value, node)
         else:
             destination[key] = value
-
     return destination
-
-
 def is_port_in_use(port: int = None) -> bool:
     """
     Checks if a port is in use on `localhost`. Useful for checking if multiple `accelerate launch` commands have been
@@ -253,18 +198,13 @@ def is_port_in_use(port: int = None) -> bool:
         port = 29500
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         return s.connect_ex(("localhost", port)) == 0
-
-
 def convert_bytes(size):
     "Converts `size` from bytes to the largest possible unit"
     for x in ["bytes", "KB", "MB", "GB", "TB"]:
         if size < 1024.0:
             return f"{round(size, 2)} {x}"
         size /= 1024.0
-
     return f"{round(size, 2)} PB"
-
-
 def check_os_kernel():
     """Warns if the kernel version is below the recommended minimum on Linux."""
     # see issue #1929
@@ -272,7 +212,6 @@ def check_os_kernel():
     system = info.system
     if system != "Linux":
         return
-
     _, version, *_ = re.split(r"(\d+\.\d+\.\d+)", info.release)
     min_version = "5.5.0"
     if Version(version) < Version(min_version):

src/utils/random.py

@@ -1,7 +1,6 @@
 def set_seed(seed: int, device_specific: bool = False):
     """
     Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
-
     Args:
         seed (`int`):
             The seed to set.
@@ -22,8 +21,6 @@ def set_seed(seed: int, device_specific: bool = False):
     # ^^ safe to call this function even if cuda is not available
     if is_tpu_available():
         xm.set_rng_state(seed)
-
-
 def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optional[torch.Generator] = None):
     # Get the proper rng state
     if rng_type == RNGType.TORCH:
@@ -42,7 +39,6 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona
     elif rng_type == RNGType.GENERATOR:
         assert generator is not None, "Need a generator to synchronize its seed."
         rng_state = generator.get_state()
-
     # Broadcast the rng state from device 0 to other devices
     state = AcceleratorState()
     if state.distributed_type == DistributedType.TPU:
@@ -60,7 +56,6 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona
         rng_state = rng_state.cpu()
     elif state.distributed_type == DistributedType.MULTI_CPU:
         torch.distributed.broadcast(rng_state, 0)
-
     # Set the broadcast rng state
     if rng_type == RNGType.TORCH:
         torch.set_rng_state(rng_state)
@@ -74,8 +69,6 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona
         xm.set_rng_state(rng_state.item())
     elif rng_type == RNGType.GENERATOR:
         generator.set_state(rng_state)
-
-
 def synchronize_rng_states(rng_types: List[Union[str, RNGType]], generator: Optional[torch.Generator] = None):
     for rng_type in rng_types:
         synchronize_rng_state(RNGType(rng_type), generator=generator)

src/utils/rich.py

@@ -1,7 +1,5 @@
 if is_rich_available():
     from rich.traceback import install
-
     install(show_locals=False)
-
 else:
     raise ModuleNotFoundError("To use the rich extension, install rich with `pip install rich`")

src/utils/torch_xla.py

@@ -1,23 +1,18 @@
 def install_xla(upgrade: bool = False):
     """
     Helper function to install appropriate xla wheels based on the `torch` version in Google Colaboratory.
-
     Args:
         upgrade (`bool`, *optional*, defaults to `False`):
             Whether to upgrade `torch` and install the latest `torch_xla` wheels.
-
     Example:
-
     ```python
     >>> from accelerate.utils import install_xla
-
     >>> install_xla(upgrade=True)
     ```
     """
     in_colab = False
     if "IPython" in sys.modules:
         in_colab = "google.colab" in str(sys.modules["IPython"].get_ipython())
-
     if in_colab:
         if upgrade:
             torch_install_cmd = ["pip", "install", "-U", "torch"]

src/utils/tqdm.py

@@ -1,7 +1,6 @@
 def tqdm(main_process_only: bool = True, *args, **kwargs):
     """
     Wrapper around `tqdm.tqdm` that optionally displays only on the main process.
-
     Args:
         main_process_only (`bool`, *optional*):
             Whether to display the progress bar only on the main process

src/utils/transformer_engine.py

@@ -16,13 +16,11 @@ def convert_model(model, to_transformer_engine=True, _convert_linear=True, _conv
             module.weight.copy_(te_module.weight)
             if has_bias:
                 module.bias.copy_(te_module.bias)
-
             setattr(model, name, te_module)
         elif isinstance(module, nn.LayerNorm) and to_transformer_engine and _convert_ln:
             te_module = te.LayerNorm(module.normalized_shape[0], eps=module.eps, params_dtype=module.weight.dtype)
             module.weight.copy_(te_module.weight)
             module.bias.copy_(te_module.bias)
-
             setattr(model, name, te_module)
         elif isinstance(module, te.Linear) and not to_transformer_engine and _convert_linear:
             has_bias = module.bias is not None
@@ -32,13 +30,11 @@ def convert_model(model, to_transformer_engine=True, _convert_linear=True, _conv
             module.weight.copy_(new_module.weight)
             if has_bias:
                 module.bias.copy_(new_module.bias)
-
             setattr(model, name, new_module)
         elif isinstance(module, te.LayerNorm) and not to_transformer_engine and _convert_ln:
             new_module = nn.LayerNorm(module.normalized_shape[0], eps=module.eps, params_dtype=module.weight.dtype)
             module.weight.copy_(new_module.weight)
             module.bias.copy_(new_module.bias)
-
             setattr(model, name, new_module)
         else:
             convert_model(
@@ -47,8 +43,6 @@ def convert_model(model, to_transformer_engine=True, _convert_linear=True, _conv
                 _convert_linear=_convert_linear,
                 _convert_ln=_convert_ln,
             )
-
-
 def has_transformer_engine_layers(model):
     """
     Returns whether a given model has some `transformer_engine` layer or not.

src/utils/versions.py

@@ -1,10 +1,7 @@
 torch_version = parse(importlib.metadata.version("torch"))
-
-
 def compare_versions(library_or_version: Union[str, Version], operation: str, requirement_version: str):
     """
     Compares a library version to some requirement using a given operation.
-
     Args:
         library_or_version (`str` or `packaging.version.Version`):
             A library name or a version to check.
@@ -19,12 +16,9 @@ def compare_versions(library_or_version: Union[str, Version], operation: str, re
     if isinstance(library_or_version, str):
         library_or_version = parse(importlib.metadata.version(library_or_version))
     return operation(library_or_version, parse(requirement_version))
-
-
 def is_torch_version(operation: str, version: str):
     """
     Compares the current PyTorch version to a given reference with an operation.
-
     Args:
         operation (`str`):
             A string representation of an operator, such as `">"` or `"<="`