Try again?

src/accelerator.py

@@ -87,6 +87,7 @@ class Accelerator:
         - **sync_gradients** (`bool`) -- Whether the gradients are currently being synced across all processes.
         - **use_distributed** (`bool`) -- Whether the current configuration is for distributed training.
     """
+
     def __init__(
         self,
         device_placement: bool = True,
@@ -296,44 +297,56 @@ class Accelerator:
         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(
             "The `use_fp16` property is deprecated and will be removed in version 1.0 of Accelerate use "
@@ -342,12 +355,15 @@ class Accelerator:
         )
         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
@@ -382,6 +398,7 @@ 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
@@ -407,9 +424,11 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-        def _inner(*args, **kwargs):
+    
+    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
@@ -422,7 +441,8 @@ class Accelerator:
         from accelerate import Accelerator
         accelerator = Accelerator()
         @accelerator.on_local_main_process
-        def print_something():
+    
+    def print_something():
             print("This will be printed by process 0 only on each server.")
         print_something()
         # On server 1:
@@ -439,9 +459,11 @@ 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):
+    
+    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
@@ -454,7 +476,8 @@ class Accelerator:
         from accelerate import Accelerator
         accelerator = Accelerator()
         @accelerator.on_last_process
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {accelerator.process_index}")
         print_something()
         "Printed on process 3"
@@ -468,9 +491,11 @@ class Accelerator:
                 raise ValueError(
                     "The `on_last_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-        def _inner(*args, **kwargs):
+    
+    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
@@ -486,7 +511,8 @@ class Accelerator:
         from accelerate import Accelerator
         accelerator = Accelerator()
         @accelerator.on_process(process_index=2)
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {accelerator.process_index}")
         print_something()
         "Printed on process 2"
@@ -503,9 +529,11 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-        def _inner(*args, **kwargs):
+    
+    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
@@ -521,7 +549,8 @@ class Accelerator:
         from accelerate import Accelerator
         accelerator = Accelerator()
         @accelerator.on_local_process(local_process_index=2)
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {accelerator.local_process_index}")
         print_something()
         # On server 1:
@@ -541,10 +570,12 @@ class Accelerator:
                 raise ValueError(
                     "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
                 )
-        def _inner(*args, **kwargs):
+    
+    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.
@@ -562,6 +593,7 @@ 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.
@@ -579,6 +611,7 @@ 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
@@ -613,6 +646,7 @@ class Accelerator:
             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).
@@ -651,6 +685,7 @@ 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:
@@ -660,18 +695,23 @@ class Accelerator:
             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
@@ -700,6 +740,7 @@ class Accelerator:
                 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
@@ -766,6 +807,7 @@ class Accelerator:
                 )
             with contextlib.nullcontext(joinables):
                 yield
+
     def print(self, *args, **kwargs):
         """
         Drop in replacement of `print()` to only print once per server.
@@ -777,6 +819,7 @@ class Accelerator:
         ```
         """
         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:
@@ -793,6 +836,7 @@ 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
@@ -909,6 +953,7 @@ class Accelerator:
             ):
                 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
@@ -1061,6 +1106,7 @@ 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
@@ -1250,6 +1296,7 @@ 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:
@@ -1342,6 +1389,7 @@ 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(
@@ -1373,6 +1421,7 @@ 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(
@@ -1407,6 +1456,7 @@ 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
     ):
@@ -1453,6 +1503,7 @@ 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
@@ -1481,6 +1532,7 @@ 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
@@ -1517,6 +1569,7 @@ 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
@@ -1542,6 +1595,7 @@ 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
@@ -1563,6 +1617,7 @@ 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
@@ -1591,6 +1646,7 @@ 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.
@@ -1624,6 +1680,7 @@ 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_`.
@@ -1656,6 +1713,7 @@ 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_`.
@@ -1678,6 +1736,7 @@ 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
@@ -1703,6 +1762,7 @@ 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
@@ -1744,7 +1804,8 @@ class Accelerator:
                     return data
                 elif self.gradient_state.remainder > 0:
                     # Last batch needs to be truncated on distributed systems as it contains additional samples
-                    def _adjust_samples(tensor):
+                
+    def _adjust_samples(tensor):
                         return tensor[: self.gradient_state.remainder]
                     return recursively_apply(_adjust_samples, data)
                 else:  # remainder is 0
@@ -1756,6 +1817,7 @@ 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*.
@@ -1785,6 +1847,7 @@ 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
@@ -1814,6 +1877,7 @@ 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
@@ -1840,6 +1904,7 @@ class Accelerator:
         ```
         """
         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
@@ -1861,6 +1926,7 @@ 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
@@ -1902,6 +1968,7 @@ 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.
@@ -1929,6 +1996,7 @@ class 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.
@@ -1954,6 +2022,7 @@ 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
@@ -1969,6 +2038,7 @@ 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`.
@@ -1993,6 +2063,7 @@ 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,
@@ -2081,6 +2152,7 @@ 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`].
@@ -2104,6 +2176,7 @@ 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.
@@ -2143,7 +2216,8 @@ class Accelerator:
                 and (len(folders) + 1 > self.project_configuration.total_limit)
                 and self.is_main_process
             ):
-                def _inner(folder):
+            
+    def _inner(folder):
                     return list(map(int, re.findall(r"[\/]?([0-9]+)(?=[^\/]*$)", folder)))[0]
                 folders.sort(key=_inner)
                 logger.warning(
@@ -2219,6 +2293,7 @@ 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`].
@@ -2241,6 +2316,7 @@ 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.
@@ -2274,7 +2350,8 @@ 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):
+        
+    def _inner(folder):
                 return list(map(int, re.findall(r"[\/]?([0-9]+)(?=[^\/]*$)", folder)))[0]
             folders.sort(key=_inner)
             input_dir = folders[-1]
@@ -2356,6 +2433,7 @@ 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
@@ -2377,6 +2455,7 @@ 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
@@ -2392,6 +2471,7 @@ class Accelerator:
         ```
         """
         self.free_memory()
+
     def _get_named_parameters(self, *args):
         named_parameters = {}
         for obj in args:
@@ -2399,6 +2479,7 @@ 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
@@ -2415,6 +2496,7 @@ 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
@@ -2461,6 +2543,7 @@ class Accelerator:
                 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`.
@@ -2490,6 +2573,7 @@ class Accelerator:
             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
@@ -2521,6 +2605,7 @@ class Accelerator:
         yield
         autocast_context.__exit__(*sys.exc_info())
     @property
+
     def optimizer_step_was_skipped(self):
         """
         Whether or not the optimizer update was skipped (because of gradient overflow in mixed precision), in which
@@ -2530,6 +2615,7 @@ 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`.
@@ -2556,9 +2642,11 @@ 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`.

src/big_modeling.py

@@ -51,12 +51,14 @@ def init_on_device(device: torch.device, include_buffers: bool = None):
     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:
@@ -69,8 +71,10 @@ 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):
+    
+    def wrapper(*args, **kwargs):
             kwargs["device"] = device
             return fn(*args, **kwargs)
         return wrapper
@@ -318,9 +322,11 @@ def dispatch_model(
         # 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):
+    
+    def add_warning(fn, model):
             @wraps(fn)
-            def wrapper(*args, **kwargs):
+        
+    def wrapper(*args, **kwargs):
                 logger.warning("You shouldn't move a model when it is dispatched on multiple devices.")
                 for param in model.parameters():
                     if param.device == torch.device("meta"):

src/commands/config/config_args.py

@@ -47,6 +47,7 @@ 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).
@@ -58,6 +59,7 @@ class BaseConfig:
         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
         with open(json_file, "r", encoding="utf-8") as f:
@@ -82,11 +84,13 @@ class BaseConfig:
                 " 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
         with open(yaml_file, "r", encoding="utf-8") as f:
@@ -113,9 +117,11 @@ 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)
@@ -158,6 +164,7 @@ class ClusterConfig(BaseConfig):
     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 = {}

src/commands/config/config_utils.py

@@ -49,6 +49,7 @@ class SubcommandHelpFormatter(argparse.RawDescriptionHelpFormatter):
     """
     A custom formatter that will remove the usage line from the help message for subcommands.
     """
+
     def _format_usage(self, usage, actions, groups, prefix):
         usage = super()._format_usage(usage, actions, groups, prefix)
         usage = usage.replace("<command> [<args>] ", "")

src/commands/estimate.py

@@ -100,6 +100,7 @@ def create_ascii_table(headers: list, rows: list, title: str):
     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("├", "┼", "┤")

src/commands/launch.py

@@ -17,6 +17,7 @@ class _CustomHelpAction(argparse._HelpAction):
     called. This is useful for the case where the user is using a specific platform and only wants to see the arguments
     for that platform.
     """
+
     def __call__(self, parser, namespace, values, option_string=None):
         if "accelerate" in sys.argv[0] and "launch" in sys.argv[1:]:
             args = sys.argv[2:]

src/data_loader.py

@@ -29,10 +29,12 @@ class SeedableRandomSampler(RandomSampler):
     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`).
     """
+
     def __init__(self, *args, **kwargs):
         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()
@@ -43,6 +45,7 @@ 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
@@ -74,6 +77,7 @@ class BatchSamplerShard(BatchSampler):
     `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,
@@ -100,8 +104,10 @@ class BatchSamplerShard(BatchSampler):
                 "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
@@ -119,8 +125,10 @@ 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
@@ -141,6 +149,7 @@ 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 = []
@@ -212,6 +221,7 @@ class IterableDatasetShard(IterableDataset):
             - the shard on process 0 to yield `[0, 1, 4, 5]` and the sampler on process 1 to yield `[2, 3, 6, 7]` if
               this argument is set to `True`.
     """
+
     def __init__(
         self,
         dataset: IterableDataset,
@@ -232,16 +242,19 @@ 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")
@@ -281,12 +294,15 @@ class DataLoaderStateMixin:
         - **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()
@@ -295,6 +311,7 @@ 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)
@@ -325,6 +342,7 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
             number of processes
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
     """
+
     def __init__(
         self,
         dataset,
@@ -343,6 +361,7 @@ 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)
@@ -372,6 +391,7 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
                 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:
@@ -383,6 +403,7 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
         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
         return (
@@ -391,6 +412,7 @@ class DataLoaderShard(DataLoader, DataLoaderStateMixin):
             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
@@ -410,22 +432,27 @@ if is_tpu_available(check_device=False):
             number of processes
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
         """
-        def __init__(self, dataloader: DataLoaderShard, device: torch.device):
+    
+    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):
+    
+    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):
+    
+    def total_batch_size(self):
             return self._loader.total_batch_size
         @property
-        def total_dataset_length(self):
+    
+    def total_dataset_length(self):
             return self._loader.total_dataset_length
         @property
-        def batch_sampler(self):
+    
+    def batch_sampler(self):
             return self._loader.batch_sampler
 class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
     """
@@ -447,6 +474,7 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
             number of processes
         - **total_dataset_length** (`int`) -- Total length of the inner dataset across all processes.
     """
+
     def __init__(
         self, dataset, split_batches: bool = False, skip_batches=0, _drop_last: bool = False, slice_fn=None, **kwargs
     ):
@@ -466,6 +494,7 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
         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.
@@ -502,6 +531,7 @@ 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)
@@ -568,6 +598,7 @@ 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:
@@ -576,6 +607,7 @@ 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:
@@ -585,11 +617,13 @@ class DataLoaderDispatcher(DataLoader, DataLoaderStateMixin):
         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(
@@ -783,16 +817,20 @@ class SkipBatchSampler(BatchSampler):
     """
     A `torch.utils.data.BatchSampler` that skips the first `n` batches of another `torch.utils.data.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):
@@ -806,9 +844,11 @@ class SkipDataLoader(DataLoader):
         kwargs:
             All other keyword arguments to pass to the regular `DataLoader` initialization.
     """
+
     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:

src/hooks.py

@@ -7,6 +7,7 @@ class ModelHook:
       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.
@@ -14,6 +15,7 @@ class ModelHook:
             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.
@@ -25,6 +27,7 @@ class ModelHook:
             `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.
@@ -35,6 +38,7 @@ class ModelHook:
             `Any`: The processed `output`.
         """
         return output
+
     def detach_hook(self, module):
         """
         To be executed when the hook is detached from a module.
@@ -46,20 +50,25 @@ 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)
@@ -95,6 +104,7 @@ def add_hook_to_module(module: nn.Module, hook: ModelHook, append: bool = False)
         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:
@@ -143,6 +153,7 @@ class AlignDevicesHook(ModelHook):
         place_submodules (`bool`, *optional*, defaults to `False`):
             Whether to place the submodules on `execution_device` during the `init_hook` event.
     """
+
     def __init__(
         self,
         execution_device: Optional[Union[int, str, torch.device]] = None,
@@ -164,12 +175,14 @@ class AlignDevicesHook(ModelHook):
         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):
@@ -196,6 +209,7 @@ class AlignDevicesHook(ModelHook):
                 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])
@@ -216,6 +230,7 @@ class AlignDevicesHook(ModelHook):
         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(
@@ -231,6 +246,7 @@ class AlignDevicesHook(ModelHook):
         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():
@@ -462,6 +478,7 @@ class CpuOffload(ModelHook):
             passed, its offload method will be called just before the forward of the model to which this hook is
             attached.
     """
+
     def __init__(
         self,
         execution_device: Optional[Union[str, int, torch.device]] = None,
@@ -469,8 +486,10 @@ class CpuOffload(ModelHook):
     ):
         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()
@@ -481,10 +500,13 @@ class UserCpuOffloadHook:
     A simple hook grouping a model and a `ModelHook`, which provides easy APIs for to call the init method of the hook
     or remove it entirely.
     """
+
     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

@@ -43,6 +43,7 @@ def notebook_launcher(
     ```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
         ...

src/local_sgd.py

@@ -12,16 +12,19 @@ class LocalSGD:
     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.
@@ -47,6 +50,7 @@ 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.
@@ -56,6 +60,7 @@ class LocalSGD:
             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

@@ -6,10 +6,12 @@ class MultiProcessAdapter(logging.LoggerAdapter):
     Does not require an `Accelerator` object to be created first.
     """
     @staticmethod
+
     def _should_log(main_process_only):
         "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.
@@ -38,6 +40,7 @@ class MultiProcessAdapter(logging.LoggerAdapter):
                         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

src/optimizer.py

@@ -20,6 +20,7 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
         scaler (`torch.cuda.amp.grad_scaler.GradScaler`, *optional*):
             The scaler to use in the step function if training with mixed precision.
     """
+
     def __init__(self, optimizer, device_placement=True, scaler=None):
         self.optimizer = optimizer
         self.scaler = scaler
@@ -40,31 +41,41 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
                 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
@@ -76,6 +87,7 @@ 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:
@@ -96,10 +108,12 @@ 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."""
         warnings.warn(
@@ -109,9 +123,11 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
         )
         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",
@@ -119,6 +135,7 @@ 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:
@@ -126,6 +143,7 @@ class AcceleratedOptimizer(torch.optim.Optimizer):
             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)

src/scheduler.py

@@ -18,12 +18,14 @@ class AcceleratedScheduler:
             regardless of the number of processes) or create batches on each process (so batch size is the original
             batch size multiplied by the number of processes).
     """
+
     def __init__(self, scheduler, optimizers, step_with_optimizer: bool = True, split_batches: bool = False):
         self.scheduler = scheduler
         self.optimizers = optimizers if isinstance(optimizers, (list, tuple)) else [optimizers]
         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
@@ -52,13 +54,18 @@ class AcceleratedScheduler:
                 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

@@ -20,10 +20,13 @@ class ThreadLocalSharedDict(threading.local):
     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.
@@ -49,6 +52,7 @@ 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:
@@ -240,6 +244,7 @@ class PartialState:
                 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"
@@ -249,30 +254,36 @@ class PartialState:
             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"
         return (
@@ -280,6 +291,7 @@ 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
@@ -310,6 +322,7 @@ 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()
@@ -317,6 +330,7 @@ class PartialState:
         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
@@ -362,7 +376,8 @@ 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):
+    
+    def _split_values(inputs, start_index, end_index):
             if isinstance(inputs, (list, tuple, torch.Tensor)):
                 if start_index >= len(inputs):
                     result = inputs[-1:]
@@ -385,6 +400,7 @@ class PartialState:
                 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.
@@ -401,6 +417,7 @@ 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.
@@ -416,6 +433,7 @@ 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.
@@ -437,6 +455,7 @@ 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.
@@ -448,7 +467,8 @@ class PartialState:
         from accelerate.state import PartialState
         state = PartialState()
         @state.on_local_main_process
-        def print_something():
+    
+    def print_something():
             print("This will be printed by process 0 only on each server.")
         print_something()
         # On server 1:
@@ -460,6 +480,7 @@ 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.
@@ -471,7 +492,8 @@ class PartialState:
         from accelerate.state import PartialState
         state = PartialState()
         @state.on_last_process
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {state.process_index}")
         print_something()
         "Printed on process 3"
@@ -480,6 +502,7 @@ 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.
@@ -494,7 +517,8 @@ class PartialState:
         from accelerate.state import PartialState
         state = PartialState()
         @state.on_process(process_index=2)
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {state.process_index}")
         print_something()
         "Printed on process 2"
@@ -505,6 +529,7 @@ 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.
@@ -519,7 +544,8 @@ class PartialState:
         from accelerate import Accelerator
         accelerator = Accelerator()
         @accelerator.on_local_process(local_process_index=2)
-        def print_something():
+    
+    def print_something():
             print(f"Printed on process {accelerator.local_process_index}")
         print_something()
         # On server 1:
@@ -533,10 +559,12 @@ 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:
         """
         Returns the default device which is:
@@ -575,6 +603,7 @@ 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,
@@ -669,13 +698,16 @@ 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:
@@ -690,6 +722,7 @@ class AcceleratorState:
                 raise ValueError(err.format(flag=f"mixed_precision='{mixed_precision}'"))
     # For backward compatibility
     @property
+
     def use_fp16(self):
         warnings.warn(
             "The `use_fp16` property is deprecated and will be removed in version 1.0 of Accelerate use "
@@ -698,6 +731,7 @@ class AcceleratorState:
         )
         return self._mixed_precision != "no"
     @property
+
     def mixed_precision(self):
         if self.distributed_type == DistributedType.DEEPSPEED:
             config = self.deepspeed_plugin.deepspeed_config
@@ -711,32 +745,39 @@ class AcceleratorState:
             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
@@ -771,6 +812,7 @@ 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.
@@ -779,6 +821,7 @@ class AcceleratorState:
         with PartialState().main_process_first():
             yield
     @contextmanager
+
     def local_main_process_first(self):
         """
         Lets the local main process go inside a with block.
@@ -786,6 +829,7 @@ class AcceleratorState:
         """
         with PartialState().local_main_process_first():
             yield
+
     def print(self, *args, **kwargs):
         PartialState().print(*args, **kwargs)
 class GradientState:
@@ -805,6 +849,7 @@ 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:
@@ -818,33 +863,40 @@ class GradientState:
         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"
@@ -852,22 +904,27 @@ 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"
         GradientState._shared_state.clear()

src/tracking.py

@@ -24,6 +24,7 @@ def on_main_process(function):
     `PartialState`.
     """
     @wraps(function)
+
     def execute_on_main_process(self, *args, **kwargs):
         if getattr(self, "main_process_only", False):
             return PartialState().on_main_process(function)(self, *args, **kwargs)
@@ -46,6 +47,7 @@ class GeneralTracker:
     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 = ""
@@ -66,6 +68,7 @@ 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
@@ -76,6 +79,7 @@ class GeneralTracker:
                 `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
@@ -87,6 +91,7 @@ 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
@@ -107,6 +112,7 @@ 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:
             from torch.utils import tensorboard
@@ -121,9 +127,11 @@ class TensorBoardTracker(GeneralTracker):
             "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
@@ -146,6 +154,7 @@ class TensorBoardTracker(GeneralTracker):
                 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.
@@ -170,6 +179,7 @@ class TensorBoardTracker(GeneralTracker):
         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.
@@ -185,6 +195,7 @@ class TensorBoardTracker(GeneralTracker):
             self.writer.add_images(k, v, global_step=step, **kwargs)
         logger.debug("Successfully logged images to TensorBoard")
     @on_main_process
+
     def finish(self):
         """
         Closes `TensorBoard` writer
@@ -204,6 +215,7 @@ class WandBTracker(GeneralTracker):
     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
@@ -214,9 +226,11 @@ class WandBTracker(GeneralTracker):
             "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.
@@ -229,6 +243,7 @@ class WandBTracker(GeneralTracker):
         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.
@@ -244,6 +259,7 @@ 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.
@@ -260,6 +276,7 @@ class WandBTracker(GeneralTracker):
             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,
         table_name: str,
@@ -288,6 +305,7 @@ class WandBTracker(GeneralTracker):
         values = {table_name: wandb.Table(columns=columns, data=data, dataframe=dataframe)}
         self.log(values, step=step, **kwargs)
     @on_main_process
+
     def finish(self):
         """
         Closes `wandb` writer
@@ -307,6 +325,7 @@ 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
@@ -317,9 +336,11 @@ class CometMLTracker(GeneralTracker):
             "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.
@@ -331,6 +352,7 @@ 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.
@@ -355,6 +377,7 @@ class CometMLTracker(GeneralTracker):
                 self.writer.log_metrics(v, step=step, **kwargs)
         logger.debug("Successfully logged to CometML")
     @on_main_process
+
     def finish(self):
         """
         Closes `comet-ml` writer
@@ -373,6 +396,7 @@ 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
@@ -383,9 +407,11 @@ class AimTracker(GeneralTracker):
             "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.
@@ -395,6 +421,7 @@ class AimTracker(GeneralTracker):
         """
         self.writer["hparams"] = values
     @on_main_process
+
     def log(self, values: dict, step: Optional[int], **kwargs):
         """
         Logs `values` to the current run.
@@ -410,6 +437,7 @@ class AimTracker(GeneralTracker):
         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.
@@ -437,6 +465,7 @@ class AimTracker(GeneralTracker):
             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
@@ -471,6 +500,7 @@ class MLflowTracker(GeneralTracker):
     name = "mlflow"
     requires_logging_directory = False
     @on_main_process
+
     def __init__(
         self,
         experiment_name: str = None,
@@ -512,9 +542,11 @@ class MLflowTracker(GeneralTracker):
             "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.
@@ -537,6 +569,7 @@ class MLflowTracker(GeneralTracker):
             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.
@@ -559,6 +592,7 @@ class MLflowTracker(GeneralTracker):
         mlflow.log_metrics(metrics, step=step)
         logger.debug("Successfully logged to mlflow")
     @on_main_process
+
     def finish(self):
         """
         End the active MLflow run.
@@ -578,6 +612,7 @@ 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()
@@ -590,9 +625,11 @@ class ClearMLTracker(GeneralTracker):
         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.
@@ -602,6 +639,7 @@ class ClearMLTracker(GeneralTracker):
         """
         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
@@ -634,6 +672,7 @@ class ClearMLTracker(GeneralTracker):
             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.
@@ -650,6 +689,7 @@ class ClearMLTracker(GeneralTracker):
             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,
         table_name: str,
@@ -686,6 +726,7 @@ class ClearMLTracker(GeneralTracker):
         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):
         """
         Close the ClearML task. If the task was initialized externally (e.g. by manually calling `Task.init`), this
@@ -694,6 +735,7 @@ 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 + "_"):
@@ -717,14 +759,17 @@ class DVCLiveTracker(GeneralTracker):
     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
@@ -736,6 +781,7 @@ class DVCLiveTracker(GeneralTracker):
         """
         self.live.log_params(values)
     @on_main_process
+
     def log(self, values: dict, step: Optional[int] = None, **kwargs):
         """
         Logs `values` to the current run.
@@ -761,6 +807,7 @@ class DVCLiveTracker(GeneralTracker):
                     "is incorrect so we dropped this attribute."
                 )
     @on_main_process
+
     def finish(self):
         """
         Closes `dvclive.Live()`.

src/utils/dataclasses.py

@@ -5,8 +5,10 @@ class KwargsHandler:
     """
     Internal mixin that implements a `to_kwargs()` method for a dataclass.
     """
+
     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.
@@ -159,6 +161,7 @@ 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):
@@ -175,6 +178,7 @@ class FP8RecipeKwargs(KwargsHandler):
                 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)
@@ -183,9 +187,11 @@ class EnumWithContains(enum.EnumMeta):
         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))
@@ -354,11 +360,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
@@ -395,6 +403,7 @@ 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:
@@ -406,6 +415,7 @@ 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()
@@ -463,6 +473,7 @@ 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:
@@ -554,6 +565,7 @@ 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)
@@ -575,6 +587,7 @@ class DeepSpeedPlugin:
         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
@@ -593,6 +606,7 @@ 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 = {
@@ -616,6 +630,7 @@ 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:
@@ -639,9 +654,11 @@ class DeepSpeedPlugin:
             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
         if old == enable:
@@ -654,6 +671,7 @@ 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",
@@ -784,6 +802,7 @@ class FullyShardedDataParallelPlugin:
             "for reduced memory usage."
         },
     )
+
     def __post_init__(self):
         from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy
         prefix = "FSDP_"
@@ -824,6 +843,7 @@ class FullyShardedDataParallelPlugin:
                 )
             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.
@@ -841,6 +861,7 @@ 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 = (
@@ -870,6 +891,7 @@ 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
@@ -880,6 +902,7 @@ class FullyShardedDataParallelPlugin:
         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,
@@ -1047,6 +1070,7 @@ class MegatronLMPlugin:
         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:
@@ -1100,6 +1124,7 @@ 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'
@@ -1180,6 +1205,7 @@ 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
@@ -1187,6 +1213,7 @@ 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
@@ -1194,6 +1221,7 @@ 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:
@@ -1208,6 +1236,7 @@ class MegatronLMPlugin:
             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"]
@@ -1235,6 +1264,7 @@ 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()
@@ -1292,6 +1322,7 @@ class BnbQuantizationConfig:
         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.

src/utils/deepspeed.py

@@ -10,6 +10,7 @@ class HfDeepSpeedConfig:
     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):
             # Don't modify user's data should they want to reuse it (e.g. in tests), because once we
@@ -28,6 +29,7 @@ class HfDeepSpeedConfig:
                 )
         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
@@ -45,6 +47,7 @@ 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
@@ -55,6 +58,7 @@ class HfDeepSpeedConfig:
             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
@@ -63,6 +67,7 @@ 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.
@@ -82,6 +87,7 @@ class HfDeepSpeedConfig:
         # 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
@@ -89,6 +95,7 @@ class HfDeepSpeedConfig:
         """
         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
@@ -96,10 +103,13 @@ 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:
@@ -108,8 +118,10 @@ class DeepSpeedEngineWrapper:
     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)
@@ -131,14 +143,18 @@ class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):
         optimizer (`torch.optim.optimizer.Optimizer`):
             The optimizer to wrap.
     """
+
     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__:
@@ -152,8 +168,10 @@ class DeepSpeedSchedulerWrapper(AcceleratedScheduler):
             The scheduler to wrap.
         optimizers (one or a list of `torch.optim.Optimizer`):
     """
+
     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:
@@ -170,6 +188,7 @@ class DummyOptim:
         **kwargs:
             Other arguments.
     """
+
     def __init__(self, params, lr=0.001, weight_decay=0, **kwargs):
         self.params = params
         self.lr = lr
@@ -191,6 +210,7 @@ class DummyScheduler:
         **kwargs:
             Other arguments.
     """
+
     def __init__(self, optimizer, total_num_steps=None, warmup_num_steps=0, lr_scheduler_callable=None, **kwargs):
         self.optimizer = optimizer
         self.total_num_steps = total_num_steps

src/utils/imports.py

@@ -149,6 +149,7 @@ def is_mlflow_available():
 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")

src/utils/launch.py

@@ -297,6 +297,7 @@ 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)
@@ -449,10 +450,12 @@ class PrepareForLaunch:
         debug (`bool`, *optional*, defaults to `False`):
             Whether or not this is a debug launch.
     """
+
     def __init__(self, launcher, distributed_type="NO", debug=False):
         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"))

src/utils/megatron_lm.py

@@ -63,6 +63,7 @@ class MegatronLMDummyDataLoader:
     Args:
         **dataset_kwargs: Megatron data arguments.
     """
+
     def __init__(self, **dataset_kwargs):
         parser = argparse.ArgumentParser()
         parser = _add_data_args(parser)
@@ -71,12 +72,15 @@ 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):
+    
+    def train_valid_test_datasets_provider(train_val_test_num_samples):
             """Build train, valid, and test datasets."""
             args = get_args()
             dataset_args = {
@@ -121,6 +125,7 @@ class MegatronLMDummyDataLoader:
             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
@@ -151,8 +156,10 @@ class MegatronLMDummyDataLoader:
         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):
+    
+    def cyclic_iter(iter):
             while True:
                 for x in iter:
                     yield x
@@ -275,13 +282,17 @@ def prepare_data_loader(accelerator, dataloader):
         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
@@ -305,14 +316,17 @@ class MegatronLMDummyScheduler:
         **kwargs:
             Other arguments.
     """
+
     def __init__(self, optimizer, total_num_steps=None, warmup_num_steps=0, **kwargs):
         self.optimizer = optimizer
         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):
@@ -321,13 +335,17 @@ def prepare_scheduler(accelerator, optimizer, scheduler):
     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):
@@ -336,6 +354,7 @@ class BertTrainStep(AbstractTrainStep):
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
+
     def __init__(self, args):
         super().__init__("BertTrainStep")
         self.get_batch = self.get_batch_func(args.megatron_dataset_flag)
@@ -345,8 +364,10 @@ 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):
+    
+    def get_batch_megatron(data_iterator):
             """Build the batch."""
             # Items and their type.
             keys = ["text", "types", "labels", "is_random", "loss_mask", "padding_mask"]
@@ -365,7 +386,8 @@ class BertTrainStep(AbstractTrainStep):
             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):
+    
+    def get_batch_transformer(data_iterator):
             """Build the batch."""
             data = next(data_iterator)
             data = send_to_device(data, torch.cuda.current_device())
@@ -391,8 +413,10 @@ class BertTrainStep(AbstractTrainStep):
             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):
+    
+    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()
@@ -407,7 +431,8 @@ class BertTrainStep(AbstractTrainStep):
                 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):
+    
+    def loss_func_finetune(labels, logits):
             if num_labels == 1:
                 #  We are doing regression
                 loss_fct = MSELoss()
@@ -424,8 +449,10 @@ class BertTrainStep(AbstractTrainStep):
             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):
+    
+    def forward_step(data_iterator, model):
             """Forward step."""
             tokens, types, sentence_order, loss_mask, labels, padding_mask = self.get_batch(data_iterator)
             if not bert_binary_head:
@@ -444,6 +471,7 @@ class GPTTrainStep(AbstractTrainStep):
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
+
     def __init__(self, args):
         super().__init__("GPTTrainStep")
         self.get_batch = self.get_batch_func(args.megatron_dataset_flag)
@@ -460,8 +488,10 @@ 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):
+    
+    def get_batch_megatron(data_iterator):
             """Generate a batch"""
             # Items and their type.
             keys = ["text"]
@@ -481,7 +511,8 @@ class GPTTrainStep(AbstractTrainStep):
                 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):
+    
+    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())
@@ -499,9 +530,11 @@ class GPTTrainStep(AbstractTrainStep):
             return get_batch_megatron
         else:
             return get_batch_transformer
+
     def get_loss_func(self):
         args = get_args()
-        def loss_func(loss_mask, output_tensor):
+    
+    def loss_func(loss_mask, output_tensor):
             if args.return_logits:
                 losses, logits = output_tensor
             else:
@@ -516,8 +549,10 @@ class GPTTrainStep(AbstractTrainStep):
                 output_dict.update({"logits": logits})
             return loss, output_dict
         return loss_func
+
     def get_forward_step_func(self):
-        def forward_step(data_iterator, model):
+    
+    def forward_step(data_iterator, model):
             """Forward step."""
             # Get the batch.
             tokens, labels, loss_mask, attention_mask, position_ids = self.get_batch(data_iterator)
@@ -530,6 +565,7 @@ class T5TrainStep(AbstractTrainStep):
     Args:
         args (`argparse.Namespace`): Megatron-LM arguments.
     """
+
     def __init__(self, args):
         super().__init__("T5TrainStep")
         self.get_batch = self.get_batch_func(args.megatron_dataset_flag)
@@ -540,6 +576,7 @@ class T5TrainStep(AbstractTrainStep):
         else:
             self.model_output_class = Seq2SeqLMOutput
     @staticmethod
+
     def attn_mask_postprocess(attention_mask):
         # We create a 3D attention mask from a 2D tensor mask.
         # [b, 1, s]
@@ -552,11 +589,13 @@ class T5TrainStep(AbstractTrainStep):
         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
         # We create a 3D attention mask from a 2D tensor mask.
@@ -567,8 +606,10 @@ 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):
+    
+    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
@@ -587,7 +628,8 @@ class T5TrainStep(AbstractTrainStep):
             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):
+    
+    def get_batch_transformer(data_iterator):
             """Build the batch."""
             data = next(data_iterator)
             data = send_to_device(data, torch.cuda.current_device())
@@ -611,16 +653,20 @@ class T5TrainStep(AbstractTrainStep):
             return get_batch_megatron
         else:
             return get_batch_transformer
+
     def get_loss_func(self):
-        def loss_func(loss_mask, output_tensor):
+    
+    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):
+    
+    def forward_step(data_iterator, model):
             """Forward step."""
             # Get the batch.
             tokens_enc, tokens_dec, loss_mask, lm_labels, enc_mask, dec_mask, enc_dec_mask = self.get_batch(
@@ -658,6 +704,7 @@ def initialize(accelerator, extra_args_provider=None, args_defaults={}):
     # tensorboard-writer, and timers.
     set_global_variables(args)
     # torch.distributed initialization
+
     def finish_mpu_init():
         args = get_args()
         # Pytorch distributed.
@@ -710,6 +757,7 @@ class MegatronEngine(torch.nn.Module):
         optimizer: Megatron-LM optimizer
         lr_scheduler: Megatron-LM lr scheduler
     """
+
     def __init__(self, accelerator, model, optimizer, scheduler):
         super(MegatronEngine, self).__init__()
         self.module = model
@@ -737,13 +785,16 @@ 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
@@ -829,6 +880,7 @@ 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
@@ -875,6 +927,7 @@ 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`:
@@ -933,6 +986,7 @@ 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:
@@ -957,6 +1011,7 @@ class MegatronEngine(torch.nn.Module):
         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()
@@ -964,6 +1019,7 @@ 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
@@ -975,6 +1031,7 @@ 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,
@@ -1143,6 +1200,7 @@ def gather_across_data_parallel_groups(tensor):
         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:
             tensor = tensor.clone()[None]

src/utils/memory.py

@@ -69,6 +69,7 @@ def find_executable_batch_size(function: callable = None, starting_batch_size: i
     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()

src/utils/modeling.py

@@ -352,8 +352,10 @@ 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
     a list or on the `values` method as in the future this will be removed.
     """
+
     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], [])

src/utils/offload.py

@@ -68,13 +68,17 @@ class PrefixedDataset(Mapping):
         dataset (`Mapping`): Any map with string keys.
         prefix (`str`): A prefix to add when trying to access any element in the underlying dataset.
     """
+
     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):
@@ -89,6 +93,7 @@ class OffloadedWeightsLoader(Mapping):
             A dictionary from weight name to their information (`dtype`/ `shape` or safetensors filename). Will default
             to the index saved in `save_folder`.
     """
+
     def __init__(
         self,
         state_dict: Dict[str, torch.Tensor] = None,
@@ -107,6 +112,7 @@ 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:
@@ -129,8 +135,10 @@ class OffloadedWeightsLoader(Mapping):
             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]):

src/utils/operations.py

@@ -130,6 +130,7 @@ def get_data_structure(data):
     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)
@@ -142,6 +143,7 @@ def get_shape(data):
     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)
@@ -151,6 +153,7 @@ def initialize_tensors(data_structure):
     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)
@@ -180,6 +183,7 @@ def listify(data):
     Returns:
         The same data structure as `data` with lists of numbers instead of `torch.Tensor`.
     """
+
     def _convert_to_list(tensor):
         tensor = tensor.detach().cpu()
         if tensor.dtype == torch.bfloat16:
@@ -190,6 +194,7 @@ def listify(data):
         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]
@@ -206,6 +211,7 @@ def _gpu_gather(tensor):
         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]
@@ -243,6 +249,7 @@ def verify_operation(function):
     Verifies that `tensor` is the same shape across all processes. Only ran if `PartialState().debug` is `True`.
     """
     @wraps(function)
+
     def wrapper(*args, **kwargs):
         if PartialState().distributed_type == DistributedType.NO or not PartialState().debug:
             return function(*args, **kwargs)
@@ -275,6 +282,7 @@ def chained_operation(function):
     `DistributedOperationException`.
     """
     @wraps(function)
+
     def wrapper(*args, **kwargs):
         try:
             return function(*args, **kwargs)
@@ -321,6 +329,7 @@ def gather_object(object: Any):
     else:
         return object
 def _gpu_broadcast(data, src=0):
+
     def _gpu_broadcast_one(tensor, src=0):
         torch.distributed.broadcast(tensor, src=src)
         return tensor
@@ -377,6 +386,7 @@ def slice_tensors(data, tensor_slice, process_index=None, num_processes=None):
     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)
@@ -415,6 +425,7 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
         pad_first (`bool`, *optional*, defaults to `False`):
             Whether to pad at the beginning or the end.
     """
+
     def _pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):
         if getattr(tensor, "is_nested", False):
             warnings.warn(
@@ -461,6 +472,7 @@ def reduce(tensor, reduction="mean", scale=1.0):
     Returns:
         The same data structure as `data` with all the tensors reduced.
     """
+
     def _reduce_across_processes(tensor, reduction="mean", scale=1.0):
         state = PartialState()
         cloned_tensor = tensor.clone()
@@ -485,8 +497,10 @@ def convert_to_fp32(tensor):
     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)
@@ -500,17 +514,21 @@ class ConvertOutputsToFp32:
     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`