\\n-\\n- `gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.\\n-\\n- </Tip>\\\"\\\"\\\"\\n-\\n- dim: int = 0\\n- broadcast_buffers: bool = True\\n- bucket_cap_mb: int = 25\\n- find_unused_parameters: bool = False\\n- check_reduction: bool = False\\n- gradient_as_bucket_view: bool = False\\n-\\n-\\n-@dataclass\\n-class GradScalerKwargs(KwargsHandler):\\n- \\\"\\\"\\\"\\n- Use this object in your [`Accelerator`] to customize the behavior of mixed precision, specifically how the\\n- `torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this\\n- [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) for more information on each argument.\\n-\\n- <Tip warning={true}>\\n-\\n- `GradScaler` is only available in PyTorch 1.5.0 and later versions.\\n-\\n- </Tip>\\\"\\\"\\\"\\n-\\n- init_scale: float = 65536.0\\n- growth_factor: float = 2.0\\n- backoff_factor: float = 0.5\\n- growth_interval: int = 2000\\n- enabled: bool = True\\n-\\n-\\n-@dataclass\\n-class InitProcessGroupKwargs(KwargsHandler):\\n- \\\"\\\"\\\"\\n- Use this object in your [`Accelerator`] to customize the initialization of the distributed processes. Please refer\\n- to the documentation of this\\n- [method](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) for more\\n- information on each argument.\\n- \\\"\\\"\\\"\\n-\\n- init_method: Optional[str] = None\\n- timeout: timedelta = timedelta(seconds=1800)\\ndiff --git a/src/accelerate/memory_utils.py b/src/accelerate/memory_utils.py\\nindex 422ead770..eba10bb78 100644\\n--- a/src/accelerate/memory_utils.py\\n+++ b/src/accelerate/memory_utils.py\\n@@ -12,77 +12,18 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-\\\"\\\"\\\"\\n-A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n-[toma](https://github.com/BlackHC/toma) library.\\n-\\\"\\\"\\\"\\n+# flake8: noqa\\n+# There's no way to ignore \\\"F401 '...' imported but unused\\\" warnings in this\\n+# module, but to preserve other warnings. So, don't check this module at all\\n \\n-import functools\\n-import gc\\n-import inspect\\n \\n-import torch\\n+import warnings\\n \\n \\n-def should_reduce_batch_size(exception: Exception) -> bool:\\n- \\\"\\\"\\\"\\n- Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+warnings.warn(\\n+ \\\"memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: \\\"\\n+ \\\"`from accelerate import find_executable_batch_size` to avoid this warning.\\\",\\n+ FutureWarning,\\n+)\\n \\n- Args:\\n- exception (`Exception`):\\n- An exception\\n- \\\"\\\"\\\"\\n- _statements = [\\n- \\\"CUDA out of memory.\\\", # CUDA OOM\\n- \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n- \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n- ]\\n- if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n- return any(err in exception.args[0] for err in _statements)\\n- return False\\n-\\n-\\n-def find_executable_batch_size(function: callable = None, starting_batch_size: int = 128):\\n- \\\"\\\"\\\"\\n- A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or\\n- CUDNN, the batch size is cut in half and passed to `function`\\n-\\n- `function` must take in a `batch_size` parameter as its first argument.\\n-\\n- Args:\\n- function (`callable`, *optional*):\\n- A function to wrap\\n- starting_batch_size (`int`, *optional*):\\n- The batch size to try and fit into memory\\n- \\\"\\\"\\\"\\n- if function is None:\\n- return functools.partial(find_executable_batch_size, starting_batch_size=starting_batch_size)\\n-\\n- batch_size = starting_batch_size\\n-\\n- def decorator(*args, **kwargs):\\n- nonlocal batch_size\\n- gc.collect()\\n- torch.cuda.empty_cache()\\n- params = list(inspect.signature(function).parameters.keys())\\n- # Guard against user error\\n- if len(params) < (len(args) + 1):\\n- arg_str = \\\", \\\".join([f\\\"{arg}={value}\\\" for arg, value in zip(params[1:], args[1:])])\\n- raise TypeError(\\n- f\\\"Batch size was passed into `{function.__name__}` as the first argument when called.\\\"\\n- f\\\"Remove this as the decorator already does so: `{function.__name__}({arg_str})`\\\"\\n- )\\n- while True:\\n- if batch_size == 0:\\n- raise RuntimeError(\\\"No executable batch size found, reached zero.\\\")\\n- try:\\n- return function(batch_size, *args, **kwargs)\\n- except Exception as e:\\n- if should_reduce_batch_size(e):\\n- gc.collect()\\n- torch.cuda.empty_cache()\\n- batch_size //= 2\\n- else:\\n- raise\\n-\\n- return decorator\\n+from .utils.memory import find_executable_batch_size\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 1bf37b7d5..dcf792592 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -19,8 +19,8 @@\\n \\n from packaging import version\\n \\n-from .state import AcceleratorState, DistributedType, is_tpu_available\\n-from .utils import honor_type\\n+from .state import AcceleratorState\\n+from .utils import DistributedType, honor_type, is_tpu_available\\n \\n \\n if is_tpu_available():\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex df2e36e9a..fbda09754 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -12,29 +12,17 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-import importlib\\n import os\\n from distutils.util import strtobool\\n-from enum import Enum\\n \\n import torch\\n \\n+from .utils import DistributedType, is_ccl_available, is_deepspeed_available, is_tpu_available\\n \\n-try:\\n- import torch_ccl # noqa: F401\\n \\n- _ccl_available = True\\n-except ImportError:\\n- _ccl_available = False\\n-\\n-\\n-try:\\n+if is_tpu_available():\\n import torch_xla.core.xla_model as xm\\n \\n- _tpu_available = True\\n-except ImportError:\\n- _tpu_available = False\\n-\\n \\n def get_int_from_env(env_keys, default):\\n \\\"\\\"\\\"Returns the first positive env value found in the `env_keys` list or the default.\\\"\\\"\\\"\\n@@ -45,22 +33,6 @@ def get_int_from_env(env_keys, default):\\n return default\\n \\n \\n-def is_ccl_available():\\n- return _ccl_available\\n-\\n-\\n-def is_apex_available():\\n- return importlib.util.find_spec(\\\"apex\\\") is not None\\n-\\n-\\n-def is_tpu_available():\\n- return _tpu_available\\n-\\n-\\n-def is_deepspeed_available():\\n- return importlib.util.find_spec(\\\"deepspeed\\\") is not None\\n-\\n-\\n def parse_flag_from_env(key, default=False):\\n value = os.environ.get(key, str(default))\\n return strtobool(value) == 1 # As its name indicates `strtobool` actually returns an int...\\n@@ -71,60 +43,6 @@ def parse_choice_from_env(key, default=\\\"no\\\"):\\n return value\\n \\n \\n-class DistributedType(str, Enum):\\n- \\\"\\\"\\\"\\n- Represents a type of distributed environment.\\n-\\n- Values:\\n-\\n- - **NO** -- Not a distributed environment, just a single process.\\n- - **MULTI_CPU** -- Distributed on multiple CPU nodes.\\n- - **MULTI_GPU** -- Distributed on multiple GPUs.\\n- - **DEEPSPEED** -- Using DeepSpeed.\\n- - **TPU** -- Distributed on TPUs.\\n- \\\"\\\"\\\"\\n-\\n- # Subclassing str as well as Enum allows the `DistributedType` to be JSON-serializable out of the box.\\n- NO = \\\"NO\\\"\\n- MULTI_CPU = \\\"MULTI_CPU\\\"\\n- MULTI_GPU = \\\"MULTI_GPU\\\"\\n- DEEPSPEED = \\\"DEEPSPEED\\\"\\n- FSDP = \\\"FSDP\\\"\\n- TPU = \\\"TPU\\\"\\n-\\n-\\n-class SageMakerDistributedType(str, Enum):\\n- \\\"\\\"\\\"\\n- Represents a type of distributed environment.\\n-\\n- Values:\\n-\\n- - **NO** -- Not a distributed environment, just a single process.\\n- - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.\\n- - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.\\n- \\\"\\\"\\\"\\n-\\n- # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.\\n- NO = \\\"NO\\\"\\n- DATA_PARALLEL = \\\"DATA_PARALLEL\\\"\\n- MODEL_PARALLEL = \\\"MODEL_PARALLEL\\\"\\n-\\n-\\n-class ComputeEnvironment(str, Enum):\\n- \\\"\\\"\\\"\\n- Represents a type of the compute environment.\\n-\\n- Values:\\n-\\n- - **LOCAL_MACHINE** -- private/custom cluster hardware.\\n- - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.\\n- \\\"\\\"\\\"\\n-\\n- # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.\\n- LOCAL_MACHINE = \\\"LOCAL_MACHINE\\\"\\n- AMAZON_SAGEMAKER = \\\"AMAZON_SAGEMAKER\\\"\\n-\\n-\\n # Inspired by Alex Martelli's 'Borg'.\\n class AcceleratorState:\\n \\\"\\\"\\\"\\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex f9a99e22f..48e7bcc49 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -19,9 +19,9 @@\\n \\n from accelerate import Accelerator\\n from accelerate.data_loader import prepare_data_loader\\n-from accelerate.state import AcceleratorState, DistributedType\\n+from accelerate.state import AcceleratorState\\n from accelerate.test_utils import RegressionDataset, RegressionModel, are_the_same_tensors\\n-from accelerate.utils import gather, set_seed, synchronize_rng_states\\n+from accelerate.utils import DistributedType, gather, set_seed, synchronize_rng_states\\n from packaging import version\\n \\n \\ndiff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex 0b8e2250f..9379eb0b9 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -25,8 +25,8 @@\\n \\n import torch\\n \\n-from ..state import AcceleratorState, is_tpu_available\\n-from ..utils import gather, is_comet_ml_available, is_tensorflow_available, is_wandb_available\\n+from ..state import AcceleratorState\\n+from ..utils import gather, is_comet_ml_available, is_tensorflow_available, is_tpu_available, is_wandb_available\\n \\n \\n def parse_flag_from_env(key, default=False):\\ndiff --git a/src/accelerate/utils/__init__.py b/src/accelerate/utils/__init__.py\\nnew file mode 100644\\nindex 000000000..a43c7d261\\n--- /dev/null\\n+++ b/src/accelerate/utils/__init__.py\\n@@ -0,0 +1,61 @@\\n+# flake8: noqa\\n+# There's no way to ignore \\\"F401 '...' imported but unused\\\" warnings in this\\n+# module, but to preserve other warnings. So, don't check this module at all\\n+\\n+from .constants import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, SCHEDULER_NAME\\n+from .dataclasses import (\\n+ ComputeEnvironment,\\n+ DeepSpeedPlugin,\\n+ DistributedDataParallelKwargs,\\n+ DistributedType,\\n+ FullyShardedDataParallelPlugin,\\n+ GradScalerKwargs,\\n+ InitProcessGroupKwargs,\\n+ KwargsHandler,\\n+ LoggerType,\\n+ PrecisionType,\\n+ RNGType,\\n+ SageMakerDistributedType,\\n+ TensorInformation,\\n+)\\n+from .imports import (\\n+ is_apex_available,\\n+ is_boto3_available,\\n+ is_ccl_available,\\n+ is_comet_ml_available,\\n+ is_deepspeed_available,\\n+ is_sagemaker_available,\\n+ is_tensorboard_available,\\n+ is_tensorflow_available,\\n+ is_tpu_available,\\n+ is_wandb_available,\\n+)\\n+from .operations import (\\n+ broadcast,\\n+ broadcast_object_list,\\n+ concatenate,\\n+ convert_outputs_to_fp32,\\n+ convert_to_fp32,\\n+ find_batch_size,\\n+ gather,\\n+ gather_object,\\n+ get_data_structure,\\n+ honor_type,\\n+ initialize_tensors,\\n+ is_tensor_information,\\n+ is_torch_tensor,\\n+ pad_across_processes,\\n+ recursively_apply,\\n+ reduce,\\n+ send_to_device,\\n+ slice_tensors,\\n+)\\n+\\n+\\n+if is_deepspeed_available():\\n+ from .deepspeed import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper\\n+\\n+from .launch import PrepareForLaunch\\n+from .memory import find_executable_batch_size\\n+from .other import extract_model_from_parallel, get_pretty_name, patch_environment, save, wait_for_everyone\\n+from .random import set_seed, synchronize_rng_state, synchronize_rng_states\\ndiff --git a/src/accelerate/utils/constants.py b/src/accelerate/utils/constants.py\\nnew file mode 100644\\nindex 000000000..c2c36a486\\n--- /dev/null\\n+++ b/src/accelerate/utils/constants.py\\n@@ -0,0 +1,19 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+SCALER_NAME = \\\"scaler.pt\\\"\\n+MODEL_NAME = \\\"pytorch_model\\\"\\n+RNG_STATE_NAME = \\\"random_states\\\"\\n+OPTIMIZER_NAME = \\\"optimizer\\\"\\n+SCHEDULER_NAME = \\\"scheduler\\\"\\ndiff --git a/src/accelerate/utils/dataclasses.py b/src/accelerate/utils/dataclasses.py\\nnew file mode 100644\\nindex 000000000..4a19f8b51\\n--- /dev/null\\n+++ b/src/accelerate/utils/dataclasses.py\\n@@ -0,0 +1,304 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+General namespace and dataclass related classes\\n+\\\"\\\"\\\"\\n+\\n+import copy\\n+import enum\\n+import functools\\n+import os\\n+import typing\\n+from dataclasses import dataclass, field\\n+from datetime import timedelta\\n+from typing import Callable, Iterable, Optional\\n+\\n+import torch\\n+\\n+\\n+class KwargsHandler:\\n+ \\\"\\\"\\\"\\n+ Internal mixin that implements a `to_kwargs()` method for a dataclass.\\n+ \\\"\\\"\\\"\\n+\\n+ def to_dict(self):\\n+ return copy.deepcopy(self.__dict__)\\n+\\n+ def to_kwargs(self):\\n+ \\\"\\\"\\\"\\n+ Returns a dictionary containing the attributes with values different from the default of this class.\\n+ \\\"\\\"\\\"\\n+ default_dict = self.__class__().to_dict()\\n+ this_dict = self.to_dict()\\n+ return {k: v for k, v in this_dict.items() if default_dict[k] != v}\\n+\\n+\\n+@dataclass\\n+class DistributedDataParallelKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your [`Accelerator`] to customize how your model is wrapped in a\\n+ `torch.nn.parallel.DistributedDataParallel`. Please refer to the documentation of this\\n+ [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) for more\\n+ information on each argument.\\n+\\n+ <Tip warning={true}>\\n+\\n+ `gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n+\\n+ dim: int = 0\\n+ broadcast_buffers: bool = True\\n+ bucket_cap_mb: int = 25\\n+ find_unused_parameters: bool = False\\n+ check_reduction: bool = False\\n+ gradient_as_bucket_view: bool = False\\n+\\n+\\n+@dataclass\\n+class GradScalerKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your [`Accelerator`] to customize the behavior of mixed precision, specifically how the\\n+ `torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this\\n+ [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) for more information on each argument.\\n+\\n+ <Tip warning={true}>\\n+\\n+ `GradScaler` is only available in PyTorch 1.5.0 and later versions.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n+\\n+ init_scale: float = 65536.0\\n+ growth_factor: float = 2.0\\n+ backoff_factor: float = 0.5\\n+ growth_interval: int = 2000\\n+ enabled: bool = True\\n+\\n+\\n+@dataclass\\n+class InitProcessGroupKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your [`Accelerator`] to customize the initialization of the distributed processes. Please refer\\n+ to the documentation of this\\n+ [method](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) for more\\n+ information on each argument.\\n+ \\\"\\\"\\\"\\n+\\n+ init_method: Optional[str] = None\\n+ timeout: timedelta = timedelta(seconds=1800)\\n+\\n+\\n+class DistributedType(str, enum.Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of distributed environment.\\n+\\n+ Values:\\n+\\n+ - **NO** -- Not a distributed environment, just a single process.\\n+ - **MULTI_CPU** -- Distributed on multiple CPU nodes.\\n+ - **MULTI_GPU** -- Distributed on multiple GPUs.\\n+ - **DEEPSPEED** -- Using DeepSpeed.\\n+ - **TPU** -- Distributed on TPUs.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `DistributedType` to be JSON-serializable out of the box.\\n+ NO = \\\"NO\\\"\\n+ MULTI_CPU = \\\"MULTI_CPU\\\"\\n+ MULTI_GPU = \\\"MULTI_GPU\\\"\\n+ DEEPSPEED = \\\"DEEPSPEED\\\"\\n+ FSDP = \\\"FSDP\\\"\\n+ TPU = \\\"TPU\\\"\\n+\\n+\\n+class SageMakerDistributedType(str, enum.Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of distributed environment.\\n+\\n+ Values:\\n+\\n+ - **NO** -- Not a distributed environment, just a single process.\\n+ - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.\\n+ - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.\\n+ NO = \\\"NO\\\"\\n+ DATA_PARALLEL = \\\"DATA_PARALLEL\\\"\\n+ MODEL_PARALLEL = \\\"MODEL_PARALLEL\\\"\\n+\\n+\\n+class ComputeEnvironment(str, enum.Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of the compute environment.\\n+\\n+ Values:\\n+\\n+ - **LOCAL_MACHINE** -- private/custom cluster hardware.\\n+ - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.\\n+ LOCAL_MACHINE = \\\"LOCAL_MACHINE\\\"\\n+ AMAZON_SAGEMAKER = \\\"AMAZON_SAGEMAKER\\\"\\n+\\n+\\n+class EnumWithContains(enum.EnumMeta):\\n+ \\\"A metaclass that adds the ability to check if `self` contains an item with the `in` operator\\\"\\n+\\n+ def __contains__(cls, item):\\n+ try:\\n+ cls(item)\\n+ except ValueError:\\n+ return False\\n+ return True\\n+\\n+\\n+class BaseEnum(enum.Enum, metaclass=EnumWithContains):\\n+ \\\"An enum class that can get the value of an item with `str(Enum.key)`\\\"\\n+\\n+ def __str__(self):\\n+ return self.value\\n+\\n+ @classmethod\\n+ def list(cls):\\n+ \\\"Method to list all the possible items in `cls`\\\"\\n+ return list(map(lambda item: str(item), cls))\\n+\\n+\\n+class LoggerType(BaseEnum):\\n+ ALL = \\\"all\\\"\\n+ TENSORBOARD = \\\"tensorboard\\\"\\n+ WANDB = \\\"wandb\\\"\\n+ COMETML = \\\"comet_ml\\\"\\n+\\n+\\n+class PrecisionType(BaseEnum):\\n+ NO = \\\"no\\\"\\n+ FP16 = \\\"fp16\\\"\\n+ BF16 = \\\"bf16\\\"\\n+\\n+\\n+class RNGType(BaseEnum):\\n+ TORCH = \\\"torch\\\"\\n+ CUDA = \\\"cuda\\\"\\n+ XLA = \\\"xla\\\"\\n+ GENERATOR = \\\"generator\\\"\\n+\\n+\\n+# data classes\\n+\\n+\\n+@dataclass\\n+class TensorInformation:\\n+ shape: torch.Size\\n+ dtype: torch.dtype\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\\n+\\n+ auto_opt_mapping: bool = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n+ )\\n+\\n+ offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n+\\n+ def __post_init__(self):\\n+\\n+ if self.gradient_accumulation_steps is None:\\n+ self.gradient_accumulation_steps = int(os.environ.get(\\\"GRADIENT_ACCUMULATION_STEPS\\\", 1))\\n+\\n+ if self.zero_stage is None:\\n+ self.zero_stage = int(os.environ.get(\\\"DEEPSPEED_ZERO_STAGE\\\", 2))\\n+\\n+ if self.offload_optimizer_device is None:\\n+ self.offload_optimizer_device = os.environ.get(\\\"DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE\\\", \\\"none\\\")\\n+\\n+ self.deepspeed_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\n+ \\\"stage\\\": self.zero_stage,\\n+ \\\"offload_optimizer\\\": {\\n+ \\\"device\\\": self.offload_optimizer_device,\\n+ },\\n+ },\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ \\\"zero_allow_untested_optimizer\\\": True,\\n+ }\\n+\\n+\\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ sharding_strategy: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are [1] FULL_SHARD, [2] SHARD_GRAD_OP\\\"},\\n+ )\\n+ backward_prefetch: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are [1] BACKWARD_PRE, [2] BACKWARD_POST\\\"},\\n+ )\\n+ auto_wrap_policy: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A callable specifying a policy to recursively wrap layers with FSDP\\\"},\\n+ )\\n+ cpu_offload: Optional[Callable] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Decides Whether to offload parameters and gradients to CPU.\\\"},\\n+ )\\n+ min_num_params: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"FSDP's minimum number of parameters for Default Auto Wrapping.\\\"}\\n+ )\\n+ ignored_modules: Optional[Iterable[torch.nn.Module]] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A list of modules to ignore for FSDP.\\\"},\\n+ )\\n+\\n+ def __post_init__(self):\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload, ShardingStrategy\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ if self.sharding_strategy is None:\\n+ self.sharding_strategy = ShardingStrategy(int(os.environ.get(\\\"FSDP_SHARDING_STRATEGY\\\", 1)))\\n+\\n+ if self.cpu_offload is None:\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.cpu_offload = CPUOffload(offload_params=True)\\n+ else:\\n+ self.cpu_offload = CPUOffload(offload_params=False)\\n+\\n+ if self.min_num_params is None:\\n+ self.min_num_params = int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", 0))\\n+\\n+ if self.auto_wrap_policy is None:\\n+ if self.min_num_params > 0:\\n+ self.auto_wrap_policy = functools.partial(default_auto_wrap_policy, min_num_params=self.min_num_params)\\ndiff --git a/src/accelerate/deepspeed_utils.py b/src/accelerate/utils/deepspeed.py\\nsimilarity index 96%\\nrename from src/accelerate/deepspeed_utils.py\\nrename to src/accelerate/utils/deepspeed.py\\nindex 5f261f2e3..891f6fdb8 100644\\n--- a/src/accelerate/deepspeed_utils.py\\n+++ b/src/accelerate/utils/deepspeed.py\\n@@ -12,8 +12,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-from .optimizer import AcceleratedOptimizer\\n-from .state import is_apex_available, is_deepspeed_available\\n+from ..optimizer import AcceleratedOptimizer\\n+from .imports import is_apex_available, is_deepspeed_available\\n \\n \\n if is_deepspeed_available():\\ndiff --git a/src/accelerate/utils/imports.py b/src/accelerate/utils/imports.py\\nnew file mode 100644\\nindex 000000000..3f10b83cf\\n--- /dev/null\\n+++ b/src/accelerate/utils/imports.py\\n@@ -0,0 +1,72 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\n+import importlib\\n+\\n+\\n+try:\\n+ import torch_ccl # noqa: F401\\n+\\n+ _ccl_available = True\\n+except ImportError:\\n+ _ccl_available = False\\n+\\n+\\n+try:\\n+ import torch_xla.core.xla_model as xm # noqa: F401\\n+\\n+ _tpu_available = True\\n+except ImportError:\\n+ _tpu_available = False\\n+\\n+\\n+def is_ccl_available():\\n+ return _ccl_available\\n+\\n+\\n+def is_apex_available():\\n+ return importlib.util.find_spec(\\\"apex\\\") is not None\\n+\\n+\\n+def is_tpu_available():\\n+ return _tpu_available\\n+\\n+\\n+def is_deepspeed_available():\\n+ return importlib.util.find_spec(\\\"deepspeed\\\") is not None\\n+\\n+\\n+def is_tensorflow_available():\\n+ return importlib.util.find_spec(\\\"tensorflow\\\") is not None\\n+\\n+\\n+def is_tensorboard_available():\\n+ return importlib.util.find_spec(\\\"tensorboard\\\") is not None or importlib.util.find_spec(\\\"tensorboardX\\\") is not None\\n+\\n+\\n+def is_wandb_available():\\n+ return importlib.util.find_spec(\\\"wandb\\\") is not None\\n+\\n+\\n+def is_comet_ml_available():\\n+ return importlib.util.find_spec(\\\"comet_ml\\\") is not None\\n+\\n+\\n+def is_boto3_available():\\n+ return importlib.util.find_spec(\\\"boto3\\\") is not None\\n+\\n+\\n+def is_sagemaker_available():\\n+ return importlib.util.find_spec(\\\"sagemaker\\\") is not None\\ndiff --git a/src/accelerate/utils/launch.py b/src/accelerate/utils/launch.py\\nnew file mode 100644\\nindex 000000000..8ff624250\\n--- /dev/null\\n+++ b/src/accelerate/utils/launch.py\\n@@ -0,0 +1,55 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+\\n+import torch\\n+\\n+from .dataclasses import DistributedType\\n+\\n+\\n+class PrepareForLaunch:\\n+ \\\"\\\"\\\"\\n+ Prepare a function that will launched in a distributed setup.\\n+\\n+ Args:\\n+ launcher (`Callable`):\\n+ The function to launch.\\n+ distributed_type ([`~state.DistributedType`]):\\n+ The distributed type to prepare for.\\n+ debug (`bool`, *optional*, defaults to `False`):\\n+ Whether or not this is a debug launch.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, launcher, distributed_type=\\\"NO\\\", debug=False):\\n+ self.launcher = launcher\\n+ self.distributed_type = DistributedType(distributed_type)\\n+ self.debug = debug\\n+\\n+ def __call__(self, index, *args):\\n+ if self.debug:\\n+ world_size = int(os.environ.get(\\\"WORLD_SIZE\\\"))\\n+ rdv_file = os.environ.get(\\\"ACCELERATE_DEBUG_RDV_FILE\\\")\\n+ torch.distributed.init_process_group(\\n+ \\\"gloo\\\",\\n+ rank=index,\\n+ store=torch.distributed.FileStore(rdv_file, world_size),\\n+ world_size=world_size,\\n+ )\\n+ elif self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n+ # Prepare the environment for torch.distributed\\n+ os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n+ os.environ[\\\"RANK\\\"] = str(index)\\n+\\n+ self.launcher(*args)\\ndiff --git a/src/accelerate/utils/memory.py b/src/accelerate/utils/memory.py\\nnew file mode 100644\\nindex 000000000..422ead770\\n--- /dev/null\\n+++ b/src/accelerate/utils/memory.py\\n@@ -0,0 +1,88 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n+[toma](https://github.com/BlackHC/toma) library.\\n+\\\"\\\"\\\"\\n+\\n+import functools\\n+import gc\\n+import inspect\\n+\\n+import torch\\n+\\n+\\n+def should_reduce_batch_size(exception: Exception) -> bool:\\n+ \\\"\\\"\\\"\\n+ Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+\\n+ Args:\\n+ exception (`Exception`):\\n+ An exception\\n+ \\\"\\\"\\\"\\n+ _statements = [\\n+ \\\"CUDA out of memory.\\\", # CUDA OOM\\n+ \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n+ \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n+ ]\\n+ if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n+ return any(err in exception.args[0] for err in _statements)\\n+ return False\\n+\\n+\\n+def find_executable_batch_size(function: callable = None, starting_batch_size: int = 128):\\n+ \\\"\\\"\\\"\\n+ A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or\\n+ CUDNN, the batch size is cut in half and passed to `function`\\n+\\n+ `function` must take in a `batch_size` parameter as its first argument.\\n+\\n+ Args:\\n+ function (`callable`, *optional*):\\n+ A function to wrap\\n+ starting_batch_size (`int`, *optional*):\\n+ The batch size to try and fit into memory\\n+ \\\"\\\"\\\"\\n+ if function is None:\\n+ return functools.partial(find_executable_batch_size, starting_batch_size=starting_batch_size)\\n+\\n+ batch_size = starting_batch_size\\n+\\n+ def decorator(*args, **kwargs):\\n+ nonlocal batch_size\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ params = list(inspect.signature(function).parameters.keys())\\n+ # Guard against user error\\n+ if len(params) < (len(args) + 1):\\n+ arg_str = \\\", \\\".join([f\\\"{arg}={value}\\\" for arg, value in zip(params[1:], args[1:])])\\n+ raise TypeError(\\n+ f\\\"Batch size was passed into `{function.__name__}` as the first argument when called.\\\"\\n+ f\\\"Remove this as the decorator already does so: `{function.__name__}({arg_str})`\\\"\\n+ )\\n+ while True:\\n+ if batch_size == 0:\\n+ raise RuntimeError(\\\"No executable batch size found, reached zero.\\\")\\n+ try:\\n+ return function(batch_size, *args, **kwargs)\\n+ except Exception as e:\\n+ if should_reduce_batch_size(e):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ batch_size //= 2\\n+ else:\\n+ raise\\n+\\n+ return decorator\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils/operations.py\\nsimilarity index 58%\\nrename from src/accelerate/utils.py\\nrename to src/accelerate/utils/operations.py\\nindex 5abbf00b5..b61ae069b 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils/operations.py\\n@@ -1,4 +1,4 @@\\n-# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n #\\n # Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n # you may not use this file except in compliance with the License.\\n@@ -12,172 +12,34 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-import functools\\n-import importlib\\n-import os\\n-import random\\n-import typing\\n-from collections.abc import Mapping\\n-from contextlib import contextmanager\\n-from dataclasses import dataclass, field\\n-from enum import Enum, EnumMeta\\n+\\\"\\\"\\\"\\n+A set of basic tensor ops compatible with tpu, gpu, and multigpu\\n+\\\"\\\"\\\"\\n+\\n+\\n from functools import update_wrapper\\n-from typing import Any, Callable, Iterable, List, Optional, Union\\n+from typing import Any, Mapping\\n \\n-import numpy as np\\n import torch\\n from torch.distributed import ReduceOp\\n \\n from packaging import version\\n \\n-from .state import AcceleratorState, DistributedType, is_deepspeed_available, is_tpu_available\\n+from ..state import AcceleratorState\\n+from .dataclasses import DistributedType, TensorInformation\\n+from .imports import is_tpu_available\\n \\n \\n if is_tpu_available():\\n import torch_xla.core.xla_model as xm\\n \\n \\n-def is_tensorflow_available():\\n- return importlib.util.find_spec(\\\"tensorflow\\\") is not None\\n-\\n-\\n-def is_tensorboard_available():\\n- return importlib.util.find_spec(\\\"tensorboard\\\") is not None or importlib.util.find_spec(\\\"tensorboardX\\\") is not None\\n-\\n-\\n-def is_wandb_available():\\n- return importlib.util.find_spec(\\\"wandb\\\") is not None\\n-\\n-\\n-def is_comet_ml_available():\\n- return importlib.util.find_spec(\\\"comet_ml\\\") is not None\\n-\\n-\\n-def is_boto3_available():\\n- return importlib.util.find_spec(\\\"boto3\\\") is not None\\n-\\n-\\n-def is_sagemaker_available():\\n- return importlib.util.find_spec(\\\"sagemaker\\\") is not None\\n-\\n-\\n-if is_deepspeed_available():\\n- from deepspeed import DeepSpeedEngine\\n-\\n-SCALER_NAME = \\\"scaler.pt\\\"\\n-MODEL_NAME = \\\"pytorch_model\\\"\\n-RNG_STATE_NAME = \\\"random_states\\\"\\n-OPTIMIZER_NAME = \\\"optimizer\\\"\\n-SCHEDULER_NAME = \\\"scheduler\\\"\\n-\\n-\\n-class EnumWithContains(EnumMeta):\\n- \\\"A metaclass that adds the ability to check if `self` contains an item with the `in` operator\\\"\\n-\\n- def __contains__(cls, item):\\n- try:\\n- cls(item)\\n- except ValueError:\\n- return False\\n- return True\\n-\\n-\\n-class BaseEnum(Enum, metaclass=EnumWithContains):\\n- \\\"An enum class that can get the value of an item with `str(Enum.key)`\\\"\\n-\\n- def __str__(self):\\n- return self.value\\n-\\n- @classmethod\\n- def list(cls):\\n- \\\"Method to list all the possible items in `cls`\\\"\\n- return list(map(lambda item: str(item), cls))\\n-\\n-\\n-class LoggerType(BaseEnum):\\n- ALL = \\\"all\\\"\\n- TENSORBOARD = \\\"tensorboard\\\"\\n- WANDB = \\\"wandb\\\"\\n- COMETML = \\\"comet_ml\\\"\\n-\\n-\\n-class PrecisionType(BaseEnum):\\n- NO = \\\"no\\\"\\n- FP16 = \\\"fp16\\\"\\n- BF16 = \\\"bf16\\\"\\n-\\n-\\n-class RNGType(BaseEnum):\\n- TORCH = \\\"torch\\\"\\n- CUDA = \\\"cuda\\\"\\n- XLA = \\\"xla\\\"\\n- GENERATOR = \\\"generator\\\"\\n-\\n-\\n-@dataclass\\n-class TensorInformation:\\n- shape: torch.Size\\n- dtype: torch.dtype\\n-\\n+def is_torch_tensor(tensor):\\n+ return isinstance(tensor, torch.Tensor)\\n \\n-def set_seed(seed: int, device_specific: bool = False):\\n- \\\"\\\"\\\"\\n- Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.\\n \\n- Args:\\n- seed (`int`): The seed to set.\\n- device_specific (`bool`, *optional*, defaults to `False`):\\n- Whether to differ the seed on each device slightly with `self.process_index`.\\n- \\\"\\\"\\\"\\n- if device_specific:\\n- seed += AcceleratorState().process_index\\n- random.seed(seed)\\n- np.random.seed(seed)\\n- torch.manual_seed(seed)\\n- torch.cuda.manual_seed_all(seed)\\n- # ^^ safe to call this function even if cuda is not available\\n- if is_tpu_available():\\n- xm.set_rng_state(seed)\\n-\\n-\\n-def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optional[torch.Generator] = None):\\n- # Get the proper rng state\\n- if rng_type == RNGType.TORCH:\\n- rng_state = torch.get_rng_state()\\n- elif rng_type == RNGType.CUDA:\\n- rng_state = torch.cuda.get_rng_state()\\n- elif rng_type == RNGType.XLA:\\n- assert is_tpu_available(), \\\"Can't synchronize XLA seeds on an environment without TPUs.\\\"\\n- rng_state = torch.tensor(xm.get_rng_state())\\n- elif rng_type == RNGType.GENERATOR:\\n- assert generator is not None, \\\"Need a generator to synchronize its seed.\\\"\\n- rng_state = generator.get_state()\\n-\\n- # Broadcast the rng state from device 0 to other devices\\n- state = AcceleratorState()\\n- if state.distributed_type == DistributedType.TPU:\\n- rng_state = xm.mesh_reduce(\\\"random_seed\\\", rng_state, lambda x: x[0])\\n- elif state.distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n- rng_state = rng_state.to(state.device)\\n- torch.distributed.broadcast(rng_state, 0)\\n- rng_state = rng_state.cpu()\\n- elif state.distributed_type == DistributedType.MULTI_CPU:\\n- torch.distributed.broadcast(rng_state, 0)\\n-\\n- # Set the broadcast rng state\\n- if rng_type == RNGType.TORCH:\\n- torch.set_rng_state(rng_state)\\n- elif rng_type == RNGType.CUDA:\\n- torch.cuda.set_rng_state(rng_state)\\n- elif rng_type == RNGType.XLA:\\n- xm.set_rng_state(rng_state.item())\\n- elif rng_type == RNGType.GENERATOR:\\n- generator.set_state(rng_state)\\n-\\n-\\n-def synchronize_rng_states(rng_types: List[Union[str, RNGType]], generator: Optional[torch.Generator] = None):\\n- for rng_type in rng_types:\\n- synchronize_rng_state(RNGType(rng_type), generator=generator)\\n+def is_tensor_information(tensor_info):\\n+ return isinstance(tensor_info, TensorInformation)\\n \\n \\n def honor_type(obj, generator):\\n@@ -191,14 +53,6 @@ def honor_type(obj, generator):\\n return type(obj)(*list(generator))\\n \\n \\n-def is_torch_tensor(tensor):\\n- return isinstance(tensor, torch.Tensor)\\n-\\n-\\n-def is_tensor_information(tensor_info):\\n- return isinstance(tensor_info, TensorInformation)\\n-\\n-\\n def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_other_type=False, **kwargs):\\n \\\"\\\"\\\"\\n Recursively apply a function on a data structure that is a nested list/tuple/dictionary of a given base type.\\n@@ -305,73 +159,24 @@ def _initialize_tensor(tensor_info):\\n return recursively_apply(_initialize_tensor, data_structure, test_type=is_tensor_information)\\n \\n \\n-def convert_to_fp32(tensor):\\n- \\\"\\\"\\\"\\n- Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.\\n-\\n- Args:\\n- tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n- The data to convert from FP16/BF16 to FP32.\\n-\\n- Returns:\\n- The same data structure as `tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n- \\\"\\\"\\\"\\n-\\n- def _convert_to_fp32(tensor):\\n- return tensor.float()\\n-\\n- def _is_fp16_bf16_tensor(tensor):\\n- return hasattr(tensor, \\\"dtype\\\") and (\\n- tensor.dtype == torch.float16\\n- or (version.parse(torch.__version__) >= version.parse(\\\"1.10\\\") and tensor.dtype == torch.bfloat16)\\n- )\\n-\\n- return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_bf16_tensor)\\n-\\n-\\n-class ConvertOutputsToFp32:\\n- \\\"\\\"\\\"\\n- Decorator to apply to a function outputing tensors (like a model forward pass) that ensures the outputs in FP16\\n- precision will be convert back to FP32.\\n-\\n- Use a class instead of a decorator because otherwise, the prepared model can no longer be pickled (issue #273).\\n-\\n- Args:\\n- model_forward (`Callable`):\\n- The function which outputs we want to treat.\\n-\\n- Returns:\\n- The same function as `model_forward` but with converted outputs.\\n- \\\"\\\"\\\"\\n-\\n- def __init__(self, model_forward):\\n- self.model_forward = model_forward\\n- update_wrapper(self, model_forward)\\n-\\n- def __call__(self, *args, **kwargs):\\n- return convert_to_fp32(self.model_forward(*args, **kwargs))\\n-\\n-\\n-convert_outputs_to_fp32 = ConvertOutputsToFp32\\n-\\n-\\n-def extract_model_from_parallel(model):\\n+def find_batch_size(data):\\n \\\"\\\"\\\"\\n- Extract a model from its distributed containers.\\n+ Recursively finds the batch size in a nested list/tuple/dictionary of lists of tensors.\\n \\n Args:\\n- model (`torch.nn.Module`): The model to extract.\\n+ data (nested list/tuple/dictionary of `torch.Tensor`): The data from which to find the batch size.\\n \\n Returns:\\n- `torch.nn.Module`: The extracted model.\\n+ `int`: The batch size.\\n \\\"\\\"\\\"\\n- options = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)\\n- if is_deepspeed_available():\\n- options += (DeepSpeedEngine,)\\n-\\n- while isinstance(model, options):\\n- model = model.module\\n- return model\\n+ if isinstance(data, (tuple, list)):\\n+ return find_batch_size(data[0])\\n+ elif isinstance(data, Mapping):\\n+ for k in data.keys():\\n+ return find_batch_size(data[k])\\n+ elif not isinstance(data, torch.Tensor):\\n+ raise TypeError(f\\\"Can only find the batch size of tensors but got {type(data)}.\\\")\\n+ return data.shape[0]\\n \\n \\n def _tpu_gather(tensor, name=\\\"gather tensor\\\"):\\n@@ -536,26 +341,6 @@ def _slice_tensor(tensor, tensor_slice):\\n return recursively_apply(_slice_tensor, data, tensor_slice)\\n \\n \\n-def find_batch_size(data):\\n- \\\"\\\"\\\"\\n- Recursively finds the batch size in a nested list/tuple/dictionary of lists of tensors.\\n-\\n- Args:\\n- data (nested list/tuple/dictionary of `torch.Tensor`): The data from which to find the batch size.\\n-\\n- Returns:\\n- `int`: The batch size.\\n- \\\"\\\"\\\"\\n- if isinstance(data, (tuple, list)):\\n- return find_batch_size(data[0])\\n- elif isinstance(data, Mapping):\\n- for k in data.keys():\\n- return find_batch_size(data[k])\\n- elif not isinstance(data, torch.Tensor):\\n- raise TypeError(f\\\"Can only find the batch size of tensors but got {type(data)}.\\\")\\n- return data.shape[0]\\n-\\n-\\n def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n Recursively concatenate the tensors in a nested list/tuple/dictionary of lists of tensors with the same shape.\\n@@ -657,198 +442,51 @@ def _reduce_across_processes(tensor, reduction=\\\"mean\\\"):\\n return recursively_apply(_reduce_across_processes, tensor, error_on_other_type=True, reduction=reduction)\\n \\n \\n-def wait_for_everyone():\\n- \\\"\\\"\\\"\\n- Introduces a blocking point in the script, making sure all processes have reached this point before continuing.\\n-\\n- <Tip warning={true}>\\n-\\n- Make sure all processes will reach this instruction otherwise one of your processes will hang forever.\\n-\\n- </Tip>\\n- \\\"\\\"\\\"\\n- if (\\n- AcceleratorState().distributed_type == DistributedType.MULTI_GPU\\n- or AcceleratorState().distributed_type == DistributedType.MULTI_CPU\\n- or AcceleratorState().distributed_type == DistributedType.DEEPSPEED\\n- ):\\n- torch.distributed.barrier()\\n- elif AcceleratorState().distributed_type == DistributedType.TPU:\\n- xm.rendezvous(\\\"accelerate.utils.wait_for_everyone\\\")\\n-\\n-\\n-def save(obj, f):\\n+def convert_to_fp32(tensor):\\n \\\"\\\"\\\"\\n- Save the data to disk. Use in place of `torch.save()`.\\n+ Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.\\n \\n Args:\\n- obj: The data to save\\n- f: The file (or file-like object) to use to save the data\\n- \\\"\\\"\\\"\\n- if AcceleratorState().distributed_type == DistributedType.TPU:\\n- xm.save(obj, f)\\n- elif AcceleratorState().local_process_index == 0:\\n- torch.save(obj, f)\\n-\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n+ The data to convert from FP16/BF16 to FP32.\\n \\n-class PrepareForLaunch:\\n+ Returns:\\n+ The same data structure as `tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n \\\"\\\"\\\"\\n- Prepare a function that will launched in a distributed setup.\\n-\\n- Args:\\n- launcher (`Callable`):\\n- The function to launch.\\n- distributed_type ([`~state.DistributedType`]):\\n- The distributed type to prepare for.\\n- debug (`bool`, *optional*, defaults to `False`):\\n- Whether or not this is a debug launch.\\n- \\\"\\\"\\\"\\n-\\n- def __init__(self, launcher, distributed_type=\\\"NO\\\", debug=False):\\n- self.launcher = launcher\\n- self.distributed_type = DistributedType(distributed_type)\\n- self.debug = debug\\n-\\n- def __call__(self, index, *args):\\n- if self.debug:\\n- world_size = int(os.environ.get(\\\"WORLD_SIZE\\\"))\\n- rdv_file = os.environ.get(\\\"ACCELERATE_DEBUG_RDV_FILE\\\")\\n- torch.distributed.init_process_group(\\n- \\\"gloo\\\",\\n- rank=index,\\n- store=torch.distributed.FileStore(rdv_file, world_size),\\n- world_size=world_size,\\n- )\\n- elif self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n- # Prepare the environment for torch.distributed\\n- os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n- os.environ[\\\"RANK\\\"] = str(index)\\n-\\n- self.launcher(*args)\\n-\\n-\\n-@dataclass\\n-class DeepSpeedPlugin:\\n \\n- gradient_accumulation_steps: int = field(\\n- default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n- )\\n- zero_stage: int = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n- )\\n- is_train_batch_min: str = field(\\n- default=True,\\n- metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n- )\\n-\\n- auto_opt_mapping: bool = field(\\n- default=True,\\n- metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n- )\\n-\\n- offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n-\\n- def __post_init__(self):\\n-\\n- if self.gradient_accumulation_steps is None:\\n- self.gradient_accumulation_steps = int(os.environ.get(\\\"GRADIENT_ACCUMULATION_STEPS\\\", 1))\\n-\\n- if self.zero_stage is None:\\n- self.zero_stage = int(os.environ.get(\\\"DEEPSPEED_ZERO_STAGE\\\", 2))\\n+ def _convert_to_fp32(tensor):\\n+ return tensor.float()\\n \\n- if self.offload_optimizer_device is None:\\n- self.offload_optimizer_device = os.environ.get(\\\"DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE\\\", \\\"none\\\")\\n+ def _is_fp16_bf16_tensor(tensor):\\n+ return hasattr(tensor, \\\"dtype\\\") and (\\n+ tensor.dtype == torch.float16\\n+ or (version.parse(torch.__version__) >= version.parse(\\\"1.10\\\") and tensor.dtype == torch.bfloat16)\\n+ )\\n \\n- self.deepspeed_config = {\\n- \\\"train_batch_size\\\": None,\\n- \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n- \\\"zero_optimization\\\": {\\n- \\\"stage\\\": self.zero_stage,\\n- \\\"offload_optimizer\\\": {\\n- \\\"device\\\": self.offload_optimizer_device,\\n- },\\n- },\\n- \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n- \\\"zero_allow_untested_optimizer\\\": True,\\n- }\\n+ return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_bf16_tensor)\\n \\n \\n-@dataclass\\n-class FullyShardedDataParallelPlugin:\\n- \\\"\\\"\\\"\\n- This plugin is used to enable fully sharded data parallelism.\\n+class ConvertOutputsToFp32:\\n \\\"\\\"\\\"\\n+ Decorator to apply to a function outputing tensors (like a model forward pass) that ensures the outputs in FP16\\n+ precision will be convert back to FP32.\\n \\n- sharding_strategy: \\\"typing.Any\\\" = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"Possible options are [1] FULL_SHARD, [2] SHARD_GRAD_OP\\\"},\\n- )\\n- backward_prefetch: \\\"typing.Any\\\" = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"Possible options are [1] BACKWARD_PRE, [2] BACKWARD_POST\\\"},\\n- )\\n- auto_wrap_policy: \\\"typing.Any\\\" = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"A callable specifying a policy to recursively wrap layers with FSDP\\\"},\\n- )\\n- cpu_offload: Optional[Callable] = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"Decides Whether to offload parameters and gradients to CPU.\\\"},\\n- )\\n- min_num_params: int = field(\\n- default=None, metadata={\\\"help\\\": \\\"FSDP's minimum number of parameters for Default Auto Wrapping.\\\"}\\n- )\\n- ignored_modules: Optional[Iterable[torch.nn.Module]] = field(\\n- default=None,\\n- metadata={\\\"help\\\": \\\"A list of modules to ignore for FSDP.\\\"},\\n- )\\n-\\n- def __post_init__(self):\\n- from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload, ShardingStrategy\\n- from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n-\\n- if self.sharding_strategy is None:\\n- self.sharding_strategy = ShardingStrategy(int(os.environ.get(\\\"FSDP_SHARDING_STRATEGY\\\", 1)))\\n-\\n- if self.cpu_offload is None:\\n- if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n- self.cpu_offload = CPUOffload(offload_params=True)\\n- else:\\n- self.cpu_offload = CPUOffload(offload_params=False)\\n-\\n- if self.min_num_params is None:\\n- self.min_num_params = int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", 0))\\n-\\n- if self.auto_wrap_policy is None:\\n- if self.min_num_params > 0:\\n- self.auto_wrap_policy = functools.partial(default_auto_wrap_policy, min_num_params=self.min_num_params)\\n-\\n+ Use a class instead of a decorator because otherwise, the prepared model can no longer be pickled (issue #273).\\n \\n-@contextmanager\\n-def patch_environment(**kwargs):\\n- \\\"\\\"\\\"\\n- A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting.\\n+ Args:\\n+ model_forward (`Callable`):\\n+ The function which outputs we want to treat.\\n \\n- Will convert the values in `kwargs` to strings and upper-case all the keys.\\n+ Returns:\\n+ The same function as `model_forward` but with converted outputs.\\n \\\"\\\"\\\"\\n- for key, value in kwargs.items():\\n- os.environ[key.upper()] = str(value)\\n \\n- yield\\n+ def __init__(self, model_forward):\\n+ self.model_forward = model_forward\\n+ update_wrapper(self, model_forward)\\n \\n- for key in kwargs:\\n- del os.environ[key.upper()]\\n+ def __call__(self, *args, **kwargs):\\n+ return convert_to_fp32(self.model_forward(*args, **kwargs))\\n \\n \\n-def get_pretty_name(obj):\\n- \\\"\\\"\\\"\\n- Gets a pretty name from `obj`.\\n- \\\"\\\"\\\"\\n- if not hasattr(obj, \\\"__qualname__\\\") and not hasattr(obj, \\\"__name__\\\"):\\n- obj = getattr(obj, \\\"__class__\\\", obj)\\n- if hasattr(obj, \\\"__qualname__\\\"):\\n- return obj.__qualname__\\n- if hasattr(obj, \\\"__name__\\\"):\\n- return obj.__name__\\n- return str(obj)\\n+convert_outputs_to_fp32 = ConvertOutputsToFp32\\ndiff --git a/src/accelerate/utils/other.py b/src/accelerate/utils/other.py\\nnew file mode 100644\\nindex 000000000..35c96a21a\\n--- /dev/null\\n+++ b/src/accelerate/utils/other.py\\n@@ -0,0 +1,111 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from contextlib import contextmanager\\n+\\n+import torch\\n+\\n+from ..state import AcceleratorState\\n+from .dataclasses import DistributedType\\n+from .imports import is_deepspeed_available, is_tpu_available\\n+\\n+\\n+if is_deepspeed_available():\\n+ from deepspeed import DeepSpeedEngine\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+\\n+def extract_model_from_parallel(model):\\n+ \\\"\\\"\\\"\\n+ Extract a model from its distributed containers.\\n+\\n+ Args:\\n+ model (`torch.nn.Module`): The model to extract.\\n+\\n+ Returns:\\n+ `torch.nn.Module`: The extracted model.\\n+ \\\"\\\"\\\"\\n+ options = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)\\n+ if is_deepspeed_available():\\n+ options += (DeepSpeedEngine,)\\n+\\n+ while isinstance(model, options):\\n+ model = model.module\\n+ return model\\n+\\n+\\n+def wait_for_everyone():\\n+ \\\"\\\"\\\"\\n+ Introduces a blocking point in the script, making sure all processes have reached this point before continuing.\\n+\\n+ <Tip warning={true}>\\n+\\n+ Make sure all processes will reach this instruction otherwise one of your processes will hang forever.\\n+\\n+ </Tip>\\n+ \\\"\\\"\\\"\\n+ if (\\n+ AcceleratorState().distributed_type == DistributedType.MULTI_GPU\\n+ or AcceleratorState().distributed_type == DistributedType.MULTI_CPU\\n+ or AcceleratorState().distributed_type == DistributedType.DEEPSPEED\\n+ ):\\n+ torch.distributed.barrier()\\n+ elif AcceleratorState().distributed_type == DistributedType.TPU:\\n+ xm.rendezvous(\\\"accelerate.utils.wait_for_everyone\\\")\\n+\\n+\\n+def save(obj, f):\\n+ \\\"\\\"\\\"\\n+ Save the data to disk. Use in place of `torch.save()`.\\n+\\n+ Args:\\n+ obj: The data to save\\n+ f: The file (or file-like object) to use to save the data\\n+ \\\"\\\"\\\"\\n+ if AcceleratorState().distributed_type == DistributedType.TPU:\\n+ xm.save(obj, f)\\n+ elif AcceleratorState().local_process_index == 0:\\n+ torch.save(obj, f)\\n+\\n+\\n+@contextmanager\\n+def patch_environment(**kwargs):\\n+ \\\"\\\"\\\"\\n+ A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting.\\n+\\n+ Will convert the values in `kwargs` to strings and upper-case all the keys.\\n+ \\\"\\\"\\\"\\n+ for key, value in kwargs.items():\\n+ os.environ[key.upper()] = str(value)\\n+\\n+ yield\\n+\\n+ for key in kwargs:\\n+ del os.environ[key.upper()]\\n+\\n+\\n+def get_pretty_name(obj):\\n+ \\\"\\\"\\\"\\n+ Gets a pretty name from `obj`.\\n+ \\\"\\\"\\\"\\n+ if not hasattr(obj, \\\"__qualname__\\\") and not hasattr(obj, \\\"__name__\\\"):\\n+ obj = getattr(obj, \\\"__class__\\\", obj)\\n+ if hasattr(obj, \\\"__qualname__\\\"):\\n+ return obj.__qualname__\\n+ if hasattr(obj, \\\"__name__\\\"):\\n+ return obj.__name__\\n+ return str(obj)\\ndiff --git a/src/accelerate/utils/random.py b/src/accelerate/utils/random.py\\nnew file mode 100644\\nindex 000000000..3958022a4\\n--- /dev/null\\n+++ b/src/accelerate/utils/random.py\\n@@ -0,0 +1,87 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import random\\n+from typing import List, Optional, Union\\n+\\n+import numpy as np\\n+import torch\\n+\\n+from ..state import AcceleratorState\\n+from .dataclasses import DistributedType, RNGType\\n+from .imports import is_tpu_available\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+\\n+def set_seed(seed: int, device_specific: bool = False):\\n+ \\\"\\\"\\\"\\n+ Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.\\n+\\n+ Args:\\n+ seed (`int`): The seed to set.\\n+ device_specific (`bool`, *optional*, defaults to `False`):\\n+ Whether to differ the seed on each device slightly with `self.process_index`.\\n+ \\\"\\\"\\\"\\n+ if device_specific:\\n+ seed += AcceleratorState().process_index\\n+ random.seed(seed)\\n+ np.random.seed(seed)\\n+ torch.manual_seed(seed)\\n+ torch.cuda.manual_seed_all(seed)\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ xm.set_rng_state(seed)\\n+\\n+\\n+def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optional[torch.Generator] = None):\\n+ # Get the proper rng state\\n+ if rng_type == RNGType.TORCH:\\n+ rng_state = torch.get_rng_state()\\n+ elif rng_type == RNGType.CUDA:\\n+ rng_state = torch.cuda.get_rng_state()\\n+ elif rng_type == RNGType.XLA:\\n+ assert is_tpu_available(), \\\"Can't synchronize XLA seeds on an environment without TPUs.\\\"\\n+ rng_state = torch.tensor(xm.get_rng_state())\\n+ elif rng_type == RNGType.GENERATOR:\\n+ assert generator is not None, \\\"Need a generator to synchronize its seed.\\\"\\n+ rng_state = generator.get_state()\\n+\\n+ # Broadcast the rng state from device 0 to other devices\\n+ state = AcceleratorState()\\n+ if state.distributed_type == DistributedType.TPU:\\n+ rng_state = xm.mesh_reduce(\\\"random_seed\\\", rng_state, lambda x: x[0])\\n+ elif state.distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n+ rng_state = rng_state.to(state.device)\\n+ torch.distributed.broadcast(rng_state, 0)\\n+ rng_state = rng_state.cpu()\\n+ elif state.distributed_type == DistributedType.MULTI_CPU:\\n+ torch.distributed.broadcast(rng_state, 0)\\n+\\n+ # Set the broadcast rng state\\n+ if rng_type == RNGType.TORCH:\\n+ torch.set_rng_state(rng_state)\\n+ elif rng_type == RNGType.CUDA:\\n+ torch.cuda.set_rng_state(rng_state)\\n+ elif rng_type == RNGType.XLA:\\n+ xm.set_rng_state(rng_state.item())\\n+ elif rng_type == RNGType.GENERATOR:\\n+ generator.set_state(rng_state)\\n+\\n+\\n+def synchronize_rng_states(rng_types: List[Union[str, RNGType]], generator: Optional[torch.Generator] = None):\\n+ for rng_type in rng_types:\\n+ synchronize_rng_state(RNGType(rng_type), generator=generator)\\ndiff --git a/tests/test_kwargs_handlers.py b/tests/test_kwargs_handlers.py\\nindex aaf15de0c..8b438d1c6 100644\\n--- a/tests/test_kwargs_handlers.py\\n+++ b/tests/test_kwargs_handlers.py\\n@@ -21,8 +21,8 @@\\n import torch\\n \\n from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs\\n-from accelerate.kwargs_handlers import KwargsHandler\\n from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu\\n+from accelerate.utils import KwargsHandler\\n \\n \\n @dataclass\\ndiff --git a/tests/test_memory_utils.py b/tests/test_memory_utils.py\\nindex 42fa151d0..df125ea95 100644\\n--- a/tests/test_memory_utils.py\\n+++ b/tests/test_memory_utils.py\\n@@ -14,7 +14,7 @@\\n \\n import unittest\\n \\n-from accelerate.memory_utils import find_executable_batch_size\\n+from accelerate.utils.memory import find_executable_batch_size\\n \\n \\n def raise_fake_out_of_memory():\\ndiff --git a/tests/test_sagemaker.py b/tests/test_sagemaker.py\\nindex f2d587a39..2824493d6 100644\\n--- a/tests/test_sagemaker.py\\n+++ b/tests/test_sagemaker.py\\n@@ -4,7 +4,7 @@\\n import pytest\\n from accelerate.commands.config.config_args import SageMakerConfig\\n from accelerate.commands.launch import _convert_nargs_to_dict\\n-from accelerate.state import ComputeEnvironment\\n+from accelerate.utils import ComputeEnvironment\\n \\n \\n @dataclass\\n\",\n \"code_comments\": [\n {\n \"body\": \"This one is rather important -> let's put it in the main init as well so that users import it directly from `accelerate` (and this way they'll be immune to the next cleanup)\",\n \"diff_hunk\": \"@@ -19,7 +19,7 @@\\n from accelerate import Accelerator, DistributedType\\n \\n # New Code #\\n-from accelerate.memory_utils import find_executable_batch_size\\n+from accelerate.utils import find_executable_batch_size\",\n \"from_author\": false\n },\n {\n \"body\": \"So as said above, let's add the batch size finder here.\",\n \"diff_hunk\": \"@@ -5,7 +5,12 @@\\n __version__ = \\\"0.8.0.dev0\\\"\\n \\n from .accelerator import Accelerator\\n-from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs\\n from .launchers import debug_launcher, notebook_launcher\\n-from .state import DistributedType\\n-from .utils import DeepSpeedPlugin, synchronize_rng_states\\n+from .utils import (\\n+ DeepSpeedPlugin,\\n+ DistributedDataParallelKwargs,\\n+ DistributedType,\\n+ GradScalerKwargs,\\n+ InitProcessGroupKwargs,\\n+ synchronize_rng_states,\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: \\\"\\r\\n \\\"`from accelerate import find_executable_batch_size` to avoid this warning.\\\",\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,28 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# flake8: noqa\\n+# There's no way to ignore \\\"F401 '...' imported but unused\\\" warnings in this\\n+# module, but to preserve other warnings. So, don't check this module at all\\n+\\n+\\n+import warnings\\n+\\n+\\n+warnings.warn(\\n+ \\\"memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: `from accelerate import find_executable_batch_size` to avoid this\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nfrom .utils.memory import find_executable_batch_size\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,28 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# flake8: noqa\\n+# There's no way to ignore \\\"F401 '...' imported but unused\\\" warnings in this\\n+# module, but to preserve other warnings. So, don't check this module at all\\n+\\n+\\n+import warnings\\n+\\n+\\n+warnings.warn(\\n+ \\\"memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: `from accelerate import find_executable_batch_size` to avoid this\\\",\\n+ FutureWarning,\\n+)\\n+\\n+from accelerate import memory_utils\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/340\",\n \"pr_id\": 928019348\n },\n {\n \"diff\": \"diff --git a/docs/source/index.mdx b/docs/source/index.mdx\\nindex c41ae4a0e..9d9000097 100644\\n--- a/docs/source/index.mdx\\n+++ b/docs/source/index.mdx\\n@@ -52,7 +52,7 @@ Changing it to work with accelerate is really easy and only adds a few lines of\\n + device = accelerator.device\\n my_model.to(device)\\n # Pass every important object (model, optimizer, dataloader) to *accelerator.prepare*\\n-+ my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n++ my_model, my_optimizer, my_training_dataloader = accelerator.prepare(\\n + my_model, my_optimizer, my_training_dataloader\\n + )\\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"It's the least I can do, thank's for merging.\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/339\",\n \"pr_id\": 924846504\n },\n {\n \"diff\": \"diff --git a/examples/by_feature/tracking.py b/examples/by_feature/tracking.py\\nindex 170211e5e..19f8e9dea 100644\\n--- a/examples/by_feature/tracking.py\\n+++ b/examples/by_feature/tracking.py\\n@@ -13,7 +13,6 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n import argparse\\n-import logging\\n import os\\n \\n import torch\\n@@ -30,9 +29,6 @@\\n )\\n \\n \\n-logger = logging.getLogger(__name__)\\n-\\n-\\n ########################################################################\\n # This is a fully working simple example to use Accelerate,\\n # specifically showcasing the experiment tracking capability,\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a903386aa..7f1480436 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -26,6 +26,7 @@\\n from .checkpointing import load_accelerator_state, load_custom_state, save_accelerator_state, save_custom_state\\n from .data_loader import prepare_data_loader\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n+from .logging import get_logger\\n from .optimizer import AcceleratedOptimizer\\n from .scheduler import AcceleratedScheduler\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n@@ -52,10 +53,7 @@\\n \\n from .deepspeed_utils import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper\\n \\n-import logging\\n-\\n-\\n-logger = logging.getLogger(__name__)\\n+logger = get_logger(__name__)\\n \\n \\n class Accelerator:\\ndiff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nindex b35bec237..a94067144 100644\\n--- a/src/accelerate/checkpointing.py\\n+++ b/src/accelerate/checkpointing.py\\n@@ -28,10 +28,10 @@\\n if is_tpu_available():\\n import torch_xla.core.xla_model as xm\\n \\n-import logging\\n+from .logging import get_logger\\n \\n \\n-logger = logging.getLogger(__name__)\\n+logger = get_logger(__name__)\\n \\n \\n def save_accelerator_state(\\ndiff --git a/src/accelerate/logging.py b/src/accelerate/logging.py\\nnew file mode 100644\\nindex 000000000..2128cdca7\\n--- /dev/null\\n+++ b/src/accelerate/logging.py\\n@@ -0,0 +1,63 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+\\n+from .state import AcceleratorState\\n+\\n+\\n+class MultiProcessAdapter(logging.LoggerAdapter):\\n+ \\\"\\\"\\\"\\n+ An adapter to assist with logging in multiprocess.\\n+\\n+ `log` takes in an additional `main_process_only` kwarg, which dictates whether it should be called on all processes\\n+ or only the main executed one. Default is `main_process_only=True`.\\n+ \\\"\\\"\\\"\\n+\\n+ @staticmethod\\n+ def _should_log(main_process_only):\\n+ \\\"Check if log should be performed\\\"\\n+ return not main_process_only or (main_process_only and AcceleratorState().local_process_index == 0)\\n+\\n+ def log(self, level, msg, *args, **kwargs):\\n+ \\\"\\\"\\\"\\n+ Delegates logger call after checking if we should log.\\n+\\n+ Accepts a new kwarg of `main_process_only`, which will dictate whether it will be logged across all processes\\n+ or only the main executed one. Default is `True` if not passed\\n+ \\\"\\\"\\\"\\n+ main_process_only = kwargs.pop(\\\"main_process_only\\\", True)\\n+ if self.isEnabledFor(level) and self._should_log(main_process_only):\\n+ msg, kwargs = self.process(msg, kwargs)\\n+ self.logger.log(level, msg, *args, **kwargs)\\n+\\n+\\n+def get_logger(name: str):\\n+ \\\"\\\"\\\"\\n+ Returns a `logging.Logger` for `name` that can handle multiprocessing.\\n+\\n+ If a log should be called on all processes, pass `main_process_only=False`\\n+\\n+ E.g.\\n+ ```python\\n+ logger.info(\\\"My log\\\", main_process_only=False)\\n+ logger.debug(\\\"My log\\\", main_process_only=False)\\n+ ```\\n+\\n+ Args:\\n+ name (`str`):\\n+ The name for the logger, such as `__file__`\\n+ \\\"\\\"\\\"\\n+ logger = logging.getLogger(name)\\n+ return MultiProcessAdapter(logger, {})\\ndiff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py\\nindex de3a19310..218ddf2df 100644\\n--- a/src/accelerate/tracking.py\\n+++ b/src/accelerate/tracking.py\\n@@ -15,11 +15,11 @@\\n # Expectation:\\n # Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n \\n-import logging\\n import os\\n from abc import ABCMeta, abstractmethod, abstractproperty\\n from typing import List, Optional, Union\\n \\n+from .logging import get_logger\\n from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n \\n \\n@@ -41,7 +41,7 @@\\n _available_trackers.append(LoggerType.COMETML)\\n \\n \\n-logger = logging.getLogger(__name__)\\n+logger = get_logger(__name__)\\n \\n \\n def get_available_trackers():\\n\",\n \"code_comments\": [\n {\n \"body\": \"Nice!\",\n \"diff_hunk\": \"@@ -0,0 +1,60 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+\\n+from .state import AcceleratorState\\n+\\n+\\n+class MultiProcessAdapter(logging.LoggerAdapter):\\n+ \\\"\\\"\\\"\\n+ An adapter to assist with logging in multiprocess.\\n+\\n+ `log` takes in an additional `main_process_only` kwarg, which dictates whether it should be called on all processes\\n+ or only the main executed one. Default is `main_process_only=True`.\\n+ \\\"\\\"\\\"\\n+\\n+ @staticmethod\\n+ def _should_log(main_process_only):\\n+ \\\"Check if log should be performed\\\"\\n+ return not main_process_only or (main_process_only and AcceleratorState().local_process_index == 0)\\n+\\n+ def log(self, level, msg, *args, **kwargs):\\n+ \\\"\\\"\\\"\\n+ Delegates logger call after checking if we should log\\n+ \\\"\\\"\\\"\\n+ main_process_only = kwargs.pop(\\\"main_process_only\\\", True)\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/337\",\n \"pr_id\": 924147533\n },\n {\n \"diff\": \"diff --git a/examples/by_feature/fsdp_with_peak_mem_tracking.py b/examples/by_feature/fsdp_with_peak_mem_tracking.py\\nnew file mode 100644\\nindex 000000000..e17e9ff67\\n--- /dev/null\\n+++ b/examples/by_feature/fsdp_with_peak_mem_tracking.py\\n@@ -0,0 +1,369 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # New Code #\\n+ # For FSDP feature, it is highly recommended and efficient to prepare the model before creating optimizer\\n+ model = accelerator.prepare(model)\\n+\\n+ # Instantiate optimizer\\n+ # New Code #\\n+ # For FSDP feature, at present it doesn't support multiple parameter groups,\\n+ # so we need to create a single parameter group for the whole model\\n+ optimizer = torch.optim.AdamW(params=model.parameters(), lr=lr, weight_decay=2e-4)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=10,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # New Code #\\n+ # For FSDP feature, prepare everything except the model as we have already prepared the model\\n+ # before creating the optimizer\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ overall_step = 0\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ path = os.path.basename(args.resume_from_checkpoint)\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ # Extract `epoch_{i}` or `step_{i}`\\n+ training_difference = os.path.splitext(path)[0]\\n+\\n+ if \\\"epoch\\\" in training_difference:\\n+ num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ resume_step = None\\n+ else:\\n+ resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ # New Code #\\n+ # context manager to track the peak memory usage during the training epoch\\n+ with TorchTracemalloc() as tracemalloc:\\n+ model.train()\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We need to skip steps until we reach the resumed step\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ if resume_step is not None and step < resume_step:\\n+ pass\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ # We keep track of the loss at each epoch\\n+ if args.with_tracking:\\n+ total_loss += loss.detach().float()\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+ # accelerator.print(lr_scheduler.get_lr())\\n+\\n+ overall_step += 1\\n+\\n+ if isinstance(checkpointing_steps, int):\\n+ output_dir = f\\\"step_{overall_step}\\\"\\n+ if overall_step % checkpointing_steps == 0:\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+ # New Code #\\n+ # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage\\n+ accelerator.print(\\\"Memory before entering the train : {}\\\".format(b2mb(tracemalloc.begin)))\\n+ accelerator.print(\\\"Memory consumed at the end of the train (end-begin): {}\\\".format(tracemalloc.used))\\n+ accelerator.print(\\\"Peak Memory consumed during the train (max-begin): {}\\\".format(tracemalloc.peaked))\\n+ accelerator.print(\\n+ \\\"Total Peak Memory consumed during the train (max): {}\\\".format(\\n+ tracemalloc.peaked + b2mb(tracemalloc.begin)\\n+ )\\n+ )\\n+ # Logging the peak memory usage of the GPU to the tracker\\n+ accelerator.log(\\n+ {\\n+ \\\"train_total_peak_memory\\\": tracemalloc.peaked + b2mb(tracemalloc.begin),\\n+ },\\n+ step=epoch,\\n+ )\\n+\\n+ # New Code #\\n+ # context manager to track the peak memory usage during the evaluation\\n+ with TorchTracemalloc() as tracemalloc:\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ # It is slightly faster to call this once, than multiple times\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\n+ \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\n+ \\\"f1\\\": eval_metric[\\\"f1\\\"],\\n+ \\\"train_loss\\\": total_loss,\\n+ },\\n+ step=epoch,\\n+ )\\n+\\n+ if checkpointing_steps == \\\"epoch\\\":\\n+ output_dir = f\\\"epoch_{epoch}\\\"\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+ # New Code #\\n+ # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage\\n+ accelerator.print(\\\"Memory before entering the eval : {}\\\".format(b2mb(tracemalloc.begin)))\\n+ accelerator.print(\\\"Memory consumed at the end of the eval (end-begin): {}\\\".format(tracemalloc.used))\\n+ accelerator.print(\\\"Peak Memory consumed during the eval (max-begin): {}\\\".format(tracemalloc.peaked))\\n+ accelerator.print(\\n+ \\\"Total Peak Memory consumed during the eval (max): {}\\\".format(tracemalloc.peaked + b2mb(tracemalloc.begin))\\n+ )\\n+ # Logging the peak memory usage of the GPU to the tracker\\n+ accelerator.log(\\n+ {\\n+ \\\"eval_total_peak_memory\\\": tracemalloc.peaked + b2mb(tracemalloc.begin),\\n+ },\\n+ step=epoch,\\n+ )\\n+\\n+ if args.with_tracking:\\n+ accelerator.end_training()\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"If the training should continue from a checkpoint folder.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--with_tracking\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--output_dir\\\",\\n+ type=str,\\n+ default=\\\".\\\",\\n+ help=\\\"Optional save directory where all checkpoint folders will be stored. Default is the current working directory.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--logging_dir\\\",\\n+ type=str,\\n+ default=\\\"logs\\\",\\n+ help=\\\"Location on where to store experiment tracking logs`\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--model_name_or_path\\\",\\n+ type=str,\\n+ help=\\\"Path to pretrained model or model identifier from huggingface.co/models.\\\",\\n+ required=True,\\n+ )\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"seed\\\": 1, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nindex 919667fc5..84b6adaef 100644\\n--- a/tests/test_examples.py\\n+++ b/tests/test_examples.py\\n@@ -40,7 +40,7 @@\\n # Should mock `{script_name}.get_dataloaders` via:\\n # @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n \\n-EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\", \\\"multi_process_metrics.py\\\", \\\"memory.py\\\"]\\n+EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\", \\\"multi_process_metrics.py\\\", \\\"memory.py\\\", \\\"fsdp_with_peak_mem_tracking.py\\\"]\\n \\n \\n def mocked_dataloaders(accelerator, batch_size: int = 16):\\n\",\n \"code_comments\": [\n {\n \"body\": \"This should be uncommented no? Also we can remove the print statement.\",\n \"diff_hunk\": \"@@ -0,0 +1,378 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # model = accelerator.prepare(model) #for FSDP model needs to be prepared before the optimizer\\n+ # accelerator.print(model)\",\n \"from_author\": false\n },\n {\n \"body\": \"Same, we should show the new code here?\",\n \"diff_hunk\": \"@@ -0,0 +1,378 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # model = accelerator.prepare(model) #for FSDP model needs to be prepared before the optimizer\\n+ # accelerator.print(model)\\n+\\n+ # Instantiate optimizer\\n+ no_decay = [\\\"bias\\\", \\\"LayerNorm.weight\\\"]\\n+ optimizer_grouped_parameters = [\\n+ {\\n+ \\\"params\\\": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],\\n+ \\\"weight_decay\\\": 2e-4,\\n+ },\\n+ {\\n+ \\\"params\\\": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],\\n+ \\\"weight_decay\\\": 0.0,\\n+ },\\n+ ]\\n+ # optimizer = torch.optim.AdamW(params=model.parameters(), lr=lr)\\n+ optimizer = torch.optim.AdamW(params=optimizer_grouped_parameters, lr=lr)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=10,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+ # optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ # optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ # )\",\n \"from_author\": false\n },\n {\n \"body\": \"I thought it was more on showing how FSDP reduces memory usage. We can have this to show the proper usage for FSDP, that should be better. Should I rename the file also? \",\n \"diff_hunk\": \"@@ -0,0 +1,378 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # model = accelerator.prepare(model) #for FSDP model needs to be prepared before the optimizer\\n+ # accelerator.print(model)\",\n \"from_author\": true\n },\n {\n \"body\": \"Both should be nice to have in the same example I think. And yes something that clearly says fsdp would be better!\",\n \"diff_hunk\": \"@@ -0,0 +1,378 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # model = accelerator.prepare(model) #for FSDP model needs to be prepared before the optimizer\\n+ # accelerator.print(model)\",\n \"from_author\": false\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -0,0 +1,378 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import gc\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+# - FSDP\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+# New Code #\\n+# Converting Bytes to Megabytes\\n+def b2mb(x):\\n+ return int(x / 2**20)\\n+\\n+\\n+# New Code #\\n+# This context manager is used to track the peak memory usage of the process\\n+class TorchTracemalloc:\\n+ def __enter__(self):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero\\n+ self.begin = torch.cuda.memory_allocated()\\n+ return self\\n+\\n+ def __exit__(self, *exc):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ self.end = torch.cuda.memory_allocated()\\n+ self.peak = torch.cuda.max_memory_allocated()\\n+ self.used = b2mb(self.end - self.begin)\\n+ self.peaked = b2mb(self.peak - self.begin)\\n+ # print(f\\\"delta used/peak {self.used:4d}/{self.peaked:4d}\\\")\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"wandb\\\", logging_dir=args.logging_dir\\n+ )\\n+ else:\\n+ accelerator = Accelerator()\\n+ accelerator.print(accelerator.distributed_type)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.print(run)\\n+ accelerator.init_trackers(run, config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, return_dict=True)\\n+ # model = accelerator.prepare(model) #for FSDP model needs to be prepared before the optimizer\\n+ # accelerator.print(model)\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"Since this is more than a \\\"one-feature\\\" script modifying the base, tests will pass if you add the script name to here: https://github.com/huggingface/accelerate/blob/main/tests/test_examples.py#L43\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/336\",\n \"pr_id\": 924092985\n },\n {\n \"diff\": \"diff --git a/src/accelerate/memory_utils.py b/src/accelerate/memory_utils.py\\nindex 4ffc5d10a..422ead770 100644\\n--- a/src/accelerate/memory_utils.py\\n+++ b/src/accelerate/memory_utils.py\\n@@ -82,5 +82,7 @@ def decorator(*args, **kwargs):\\n gc.collect()\\n torch.cuda.empty_cache()\\n batch_size //= 2\\n+ else:\\n+ raise\\n \\n return decorator\\ndiff --git a/tests/test_memory_utils.py b/tests/test_memory_utils.py\\nindex cc1b3e827..42fa151d0 100644\\n--- a/tests/test_memory_utils.py\\n+++ b/tests/test_memory_utils.py\\n@@ -80,3 +80,12 @@ def mock_training_loop_function(batch_size, arg1, arg2):\\n mock_training_loop_function(128, \\\"hello\\\", \\\"world\\\")\\n self.assertIn(\\\"Batch size was passed into `f`\\\", cm.exception.args[0])\\n self.assertIn(\\\"`f(arg1='hello', arg2='world')\\\", cm.exception.args[0])\\n+\\n+ def test_any_other_error(self):\\n+ @find_executable_batch_size(starting_batch_size=16)\\n+ def mock_training_loop_function(batch_size):\\n+ raise ValueError(\\\"Oops, we had an error!\\\")\\n+\\n+ with self.assertRaises(ValueError) as cm:\\n+ mock_training_loop_function()\\n+ self.assertIn(\\\"Oops, we had an error!\\\", cm.exception.args[0])\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/335\",\n \"pr_id\": 923648946\n },\n {\n \"diff\": \"diff --git a/src/accelerate/memory_utils.py b/src/accelerate/memory_utils.py\\nindex 73a298caf..4ffc5d10a 100644\\n--- a/src/accelerate/memory_utils.py\\n+++ b/src/accelerate/memory_utils.py\\n@@ -73,6 +73,8 @@ def decorator(*args, **kwargs):\\n f\\\"Remove this as the decorator already does so: `{function.__name__}({arg_str})`\\\"\\n )\\n while True:\\n+ if batch_size == 0:\\n+ raise RuntimeError(\\\"No executable batch size found, reached zero.\\\")\\n try:\\n return function(batch_size, *args, **kwargs)\\n except Exception as e:\\n@@ -80,7 +82,5 @@ def decorator(*args, **kwargs):\\n gc.collect()\\n torch.cuda.empty_cache()\\n batch_size //= 2\\n- else:\\n- raise\\n \\n return decorator\\ndiff --git a/tests/test_memory_utils.py b/tests/test_memory_utils.py\\nindex 510d79c71..cc1b3e827 100644\\n--- a/tests/test_memory_utils.py\\n+++ b/tests/test_memory_utils.py\\n@@ -50,6 +50,26 @@ def mock_training_loop_function(batch_size, arg1):\\n self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n self.assertListEqual([bs, arg1], [8, \\\"hello\\\"])\\n \\n+ def test_start_zero(self):\\n+ @find_executable_batch_size(starting_batch_size=0)\\n+ def mock_training_loop_function(batch_size):\\n+ pass\\n+\\n+ with self.assertRaises(RuntimeError) as cm:\\n+ mock_training_loop_function()\\n+ self.assertIn(\\\"No executable batch size found, reached zero.\\\", cm.exception.args[0])\\n+\\n+ def test_approach_zero(self):\\n+ @find_executable_batch_size(starting_batch_size=16)\\n+ def mock_training_loop_function(batch_size):\\n+ if batch_size > 0:\\n+ raise_fake_out_of_memory()\\n+ pass\\n+\\n+ with self.assertRaises(RuntimeError) as cm:\\n+ mock_training_loop_function()\\n+ self.assertIn(\\\"No executable batch size found, reached zero.\\\", cm.exception.args[0])\\n+\\n def test_verbose_guard(self):\\n @find_executable_batch_size(starting_batch_size=128)\\n def mock_training_loop_function(batch_size, arg1, arg2):\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n def test_start_zero(self):\\r\\n```\",\n \"diff_hunk\": \"@@ -50,6 +50,26 @@ def mock_training_loop_function(batch_size, arg1):\\n self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n self.assertListEqual([bs, arg1], [8, \\\"hello\\\"])\\n \\n+ def test_zero(self):\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/334\",\n \"pr_id\": 922308318\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex 69464ea0b..f9d35ea48 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -64,7 +64,7 @@ def get_cluster_input():\\n else:\\n use_cpu = False\\n \\n- deepspeed_config = None\\n+ deepspeed_config = {}\\n if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n use_deepspeed = _ask_field(\\n \\\"Do you want to use DeepSpeed? [yes/NO]: \\\",\\n@@ -78,7 +78,6 @@ def get_cluster_input():\\n is_deepspeed_available()\\n ), \\\"DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source\\\"\\n \\n- deepspeed_config = {}\\n if distributed_type == DistributedType.DEEPSPEED:\\n deepspeed_config[\\\"zero_stage\\\"] = _ask_field(\\n \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2, 3)? [2]: \\\",\\n@@ -99,6 +98,7 @@ def get_cluster_input():\\n default=1,\\n )\\n \\n+ fsdp_config = {}\\n if distributed_type in [DistributedType.MULTI_GPU]:\\n use_fsdp = _ask_field(\\n \\\"Do you want to use FullyShardedDataParallel? [yes/NO]: \\\",\\n@@ -108,7 +108,6 @@ def get_cluster_input():\\n )\\n if use_fsdp:\\n distributed_type = DistributedType.FSDP\\n- fsdp_config = {}\\n if distributed_type == DistributedType.FSDP:\\n fsdp_config[\\\"sharding_strategy\\\"] = _ask_field(\\n \\\"What should be your sharding strategy ([1] FULL_SHARD, [2] SHARD_GRAD_OP)? [1]: \\\",\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n fsdp_config = {}\\r\\n```\\r\\nCan you remove the same thing at line 112 as a result?\",\n \"diff_hunk\": \"@@ -99,6 +99,7 @@ def get_cluster_input():\\n default=1,\\n )\\n \\n+ fsdp_config = None\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/331\",\n \"pr_id\": 922240374\n },\n {\n \"diff\": \"diff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex ac6df7741..0b8e2250f 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -26,7 +26,7 @@\\n import torch\\n \\n from ..state import AcceleratorState, is_tpu_available\\n-from ..utils import gather, is_tensorflow_available\\n+from ..utils import gather, is_comet_ml_available, is_tensorflow_available, is_wandb_available\\n \\n \\n def parse_flag_from_env(key, default=False):\\n@@ -53,10 +53,51 @@ def slow(test_case):\\n Decorator marking a test as slow. Slow tests are skipped by default. Set the RUN_SLOW environment variable to a\\n truthy value to run them.\\n \\\"\\\"\\\"\\n- if not _run_slow_tests:\\n- return unittest.skip(\\\"test is slow\\\")(test_case)\\n- else:\\n- return test_case\\n+ return unittest.skipUnless(_run_slow_tests, \\\"test is slow\\\")(test_case)\\n+\\n+\\n+def require_cuda(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires CUDA. These tests are skipped when there are no GPU available.\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(torch.cuda.is_available(), \\\"test requires a GPU\\\")(test_case)\\n+\\n+\\n+def require_tpu(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires TPUs. These tests are skipped when there are no TPUs available.\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(is_tpu_available(), \\\"test requires TPU\\\")(test_case)\\n+\\n+\\n+def require_multi_gpu(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires a multi-GPU setup. These tests are skipped on a machine without multiple\\n+ GPUs.\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(torch.cuda.device_count() > 1, \\\"test requires multiple GPUs\\\")(test_case)\\n+\\n+\\n+def require_tensorflow(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires TensorFlow installed. These tests are skipped when TensorFlow isn't\\n+ installed\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(is_tensorflow_available(), \\\"test requires TensorFlow\\\")(test_case)\\n+\\n+\\n+def require_wandb(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires wandb installed. These tests are skipped when wandb isn't installed\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(is_wandb_available(), \\\"test requires wandb\\\")(test_case)\\n+\\n+\\n+def require_comet_ml(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires comet_ml installed. These tests are skipped when comet_ml isn't installed\\n+ \\\"\\\"\\\"\\n+ return unittest.skipUnless(is_comet_ml_available(), \\\"test requires comet_ml\\\")(test_case)\\n \\n \\n class TempDirTestCase(unittest.TestCase):\\n@@ -136,48 +177,6 @@ def are_the_same_tensors(tensor):\\n return True\\n \\n \\n-def require_cuda(test_case):\\n- \\\"\\\"\\\"\\n- Decorator marking a test that requires CUDA. These tests are skipped when there are no GPU available.\\n- \\\"\\\"\\\"\\n- if not torch.cuda.is_available():\\n- return unittest.skip(\\\"test requires a GPU\\\")(test_case)\\n- else:\\n- return test_case\\n-\\n-\\n-def require_tpu(test_case):\\n- \\\"\\\"\\\"\\n- Decorator marking a test that requires TPUs. These tests are skipped when there are no TPUs available.\\n- \\\"\\\"\\\"\\n- if not is_tpu_available():\\n- return unittest.skip(\\\"test requires TPU\\\")(test_case)\\n- else:\\n- return test_case\\n-\\n-\\n-def require_multi_gpu(test_case):\\n- \\\"\\\"\\\"\\n- Decorator marking a test that requires a multi-GPU setup. These tests are skipped on a machine without multiple\\n- GPUs.\\n- \\\"\\\"\\\"\\n- if torch.cuda.device_count() < 2:\\n- return unittest.skip(\\\"test requires multiple GPUs\\\")(test_case)\\n- else:\\n- return test_case\\n-\\n-\\n-def require_tensorflow(test_case):\\n- \\\"\\\"\\\"\\n- Decorator marking a test that requires TensorFlow installed. These tests are skipped when TensorFlow isn't\\n- installed\\n- \\\"\\\"\\\"\\n- if not is_tensorflow_available():\\n- return unittest.skip(\\\"test requires TensorFlow\\\")(test_case)\\n- else:\\n- return test_case\\n-\\n-\\n class _RunOutput:\\n def __init__(self, returncode, stdout, stderr):\\n self.returncode = returncode\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex c5b940a46..e9a2170ee 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -26,10 +26,19 @@\\n \\n # We use TF to parse the logs\\n from accelerate import Accelerator\\n-from accelerate.test_utils.testing import MockingTestCase, TempDirTestCase, require_tensorflow\\n+from accelerate.test_utils.testing import (\\n+ MockingTestCase,\\n+ TempDirTestCase,\\n+ require_comet_ml,\\n+ require_tensorflow,\\n+ require_wandb,\\n+)\\n from accelerate.tracking import CometMLTracker, GeneralTracker\\n-from accelerate.utils import is_tensorflow_available\\n-from comet_ml import OfflineExperiment\\n+from accelerate.utils import is_comet_ml_available, is_tensorflow_available\\n+\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import OfflineExperiment\\n \\n \\n if is_tensorflow_available():\\n@@ -110,6 +119,7 @@ def test_logging_dir(self):\\n _ = Accelerator(log_with=\\\"tensorboard\\\", logging_dir=dirpath)\\n \\n \\n+@require_wandb\\n @mock.patch.dict(os.environ, {\\\"WANDB_MODE\\\": \\\"offline\\\"})\\n class WandBTrackingTest(TempDirTestCase, MockingTestCase):\\n def setUp(self):\\n@@ -179,6 +189,7 @@ def offline_init(self, run_name: str, tmpdir: str):\\n logger.info(\\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\")\\n \\n \\n+@require_comet_ml\\n @mock.patch.object(CometMLTracker, \\\"__init__\\\", offline_init)\\n class CometMLTest(unittest.TestCase):\\n @staticmethod\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/330\",\n \"pr_id\": 922069538\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex fadbe6211..58db9b24e 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -139,6 +139,13 @@ class ClusterConfig(BaseConfig):\\n # args for fsdp\\n fsdp_config: dict = None\\n \\n+ def __post_init__(self):\\n+ if self.deepspeed_config is None:\\n+ self.deepspeed_config = {}\\n+ if self.fsdp_config is None:\\n+ self.fsdp_config = {}\\n+ return super().__post_init__()\\n+\\n \\n @dataclass\\n class SageMakerConfig(BaseConfig):\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/329\",\n \"pr_id\": 921986463\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex eb3b24ce9..f62d9e7a4 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -40,6 +40,7 @@\\n gather,\\n get_pretty_name,\\n pad_across_processes,\\n+ reduce,\\n save,\\n wait_for_everyone,\\n )\\n@@ -556,7 +557,7 @@ def clip_grad_value_(self, parameters, clip_value):\\n \\n def gather(self, tensor):\\n \\\"\\\"\\\"\\n- Gather the values in *tensor* accross all processes and concatenate them on the first dimension. Useful to\\n+ Gather the values in *tensor* across all processes and concatenate them on the first dimension. Useful to\\n regroup the predictions from all processes when doing evaluation.\\n \\n Note:\\n@@ -572,6 +573,18 @@ def gather(self, tensor):\\n \\\"\\\"\\\"\\n return gather(tensor)\\n \\n+ def reduce(self, tensor: torch.Tensor, reduction=\\\"sum\\\"):\\n+ \\\"\\\"\\\"\\n+ Reduce the values in *tensor* across all processes based on *reduction*.\\n+\\n+ Args:\\n+ tensor (`torch.Tensor`):\\n+ The tensors to reduce across all processes.\\n+ reduction (`str`, *optional*, defaults to \\\"sum\\\"):\\n+ A reduction type, can be one of 'sum', 'mean', or 'none'. If 'none', will not perform any operation.\\n+ \\\"\\\"\\\"\\n+ reduce(tensor, reduction)\\n+\\n def pad_across_processes(self, tensor, dim=0, pad_index=0, pad_first=False):\\n \\\"\\\"\\\"\\n Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 9bcd87f5f..c2d05c162 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -24,6 +24,7 @@\\n \\n import numpy as np\\n import torch\\n+from torch.distributed import ReduceOp\\n \\n from packaging import version\\n \\n@@ -621,6 +622,39 @@ def _pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n )\\n \\n \\n+def reduce(tensor, reduction=\\\"mean\\\"):\\n+ \\\"\\\"\\\"\\n+ Recursively reduce the tensors in a nested list/tuple/dictionary of lists of tensors across all processes by the\\n+ mean of a given operation.\\n+\\n+ Args:\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n+ The data to reduce.\\n+ reduction (`str`, *optional*, defaults to `\\\"mean\\\"`):\\n+ A reduction method. Can be of \\\"mean\\\", \\\"sum\\\", or \\\"none\\\"\\n+\\n+ Returns:\\n+ The same data structure as `data` with all the tensors reduced.\\n+ \\\"\\\"\\\"\\n+\\n+ def _reduce_across_processes(tensor, reduction=\\\"mean\\\"):\\n+ state = AcceleratorState()\\n+ cloned_tensor = tensor.clone()\\n+ if state.distributed_type == DistributedType.TPU:\\n+ xm.all_reduce(\\\"sum\\\", cloned_tensor)\\n+ return cloned_tensor\\n+ elif state.distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n+ torch.distributed.reduce(cloned_tensor, ReduceOp.SUM)\\n+ return cloned_tensor\\n+ else:\\n+ if reduction == \\\"sum\\\":\\n+ return cloned_tensor.sum()\\n+ else:\\n+ return cloned_tensor.mean()\\n+\\n+ return recursively_apply(_reduce_across_processes, tensor, error_on_other_type=True, reduction=reduction)\\n+\\n+\\n def wait_for_everyone():\\n \\\"\\\"\\\"\\n Introduces a blocking point in the script, making sure all processes have reached this point before continuing.\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n reduction (`str`, *optional*, defaults to `\\\"mean\\\"`):\\r\\n```\",\n \"diff_hunk\": \"@@ -621,6 +622,35 @@ def _pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n )\\n \\n \\n+def reduce(tensor: torch.Tensor, reduction=\\\"mean\\\"):\\n+ \\\"\\\"\\\"\\n+ Reduce `tensor` across all processes and perform a `reduction`.\\n+\\n+ Args:\\n+ tensor (`torch.Tensor`):\\n+ The data to reduce\\n+ reduction (`str`, *optional*, defaults to \\\"mean\\\"):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n Reduce a tensor across all processes by the mean of a given operation.\\r\\n```\\r\\nThe arguments are described just below, so I like to keep the general description pure English :-)\",\n \"diff_hunk\": \"@@ -621,6 +622,35 @@ def _pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n )\\n \\n \\n+def reduce(tensor: torch.Tensor, reduction=\\\"mean\\\"):\\n+ \\\"\\\"\\\"\\n+ Reduce `tensor` across all processes and perform a `reduction`.\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/326\",\n \"pr_id\": 919680762\n },\n {\n \"diff\": \"diff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml\\nindex 0a6d45892..1ee741653 100644\\n--- a/docs/source/_toctree.yml\\n+++ b/docs/source/_toctree.yml\\n@@ -23,4 +23,6 @@\\n title: Checkpointing\\n - local: tracking\\n title: Experiment Tracking\\n+ - local: memory\\n+ title: Memory Utilities\\n title: API Reference\\ndiff --git a/docs/source/memory.mdx b/docs/source/memory.mdx\\nnew file mode 100644\\nindex 000000000..31a2bc66f\\n--- /dev/null\\n+++ b/docs/source/memory.mdx\\n@@ -0,0 +1,51 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Memory Utilities\\n+\\n+One of the most frustrating errors when it comes to running training scripts is hitting \\\"CUDA Out-of-Memory\\\", \\n+as the entire script needs to be restarted, progress is lost, and typically a developer would want to simply\\n+start their script and let it run.\\n+\\n+`Accelerate` provides a utility heavily based on [toma](https://github.com/BlackHC/toma) to give this capability.\\n+\\n+## find_executable_batch_size\\n+\\n+This algorithm operates with exponential decay, decreasing the batch size in half after each failed run on some \\n+training script. To use it, restructure your training function to include an inner function that includes this wrapper, \\n+and build your dataloaders inside it. At a minimum, this could look like 4 new lines of code. \\n+> Note: The inner function *must* take in the batch size as the first parameter, but we do not pass one to it when called. The wrapper handles this for us\\n+\\n+```diff\\n+def training_function(args):\\n+ accelerator = Accelerator()\\n+ model = get_model()\\n+ model.to(accelerator.device)\\n+ optimizer = get_optimizer()\\n+\\n++ @find_executable_batch_size(starting_batch_size=args.batch_size)\\n++ def inner_training_loop(batch_size):\\n++ nonlocal model, optimizer # Ensure they can be used in our context\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n+ lr_scheduler = get_scheduler(\\n+ optimizer, \\n+ num_training_steps=len(train_dataloader)*num_epochs\\n+ )\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+ train(model, optimizer, train_dataloader, lr_scheduler)\\n+ validate(model, eval_dataloader)\\n++ inner_training_loop()\\n+```\\n+\\n+[[autodoc]] memory_utils.find_executable_batch_size\\n\\\\ No newline at end of file\\ndiff --git a/examples/by_feature/memory.py b/examples/by_feature/memory.py\\nnew file mode 100644\\nindex 000000000..67263de52\\n--- /dev/null\\n+++ b/examples/by_feature/memory.py\\n@@ -0,0 +1,218 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+\\n+# New Code #\\n+from accelerate.memory_utils import find_executable_batch_size\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to ensure out-of-memory errors never\\n+# iterrupt training, and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # New Code #\\n+ # We now can define an inner training loop function. It should take a batch size as the only parameter,\\n+ # and build the dataloaders in there.\\n+ # It also gets our decorator\\n+ @find_executable_batch_size(starting_batch_size=batch_size)\\n+ def inner_training_loop(batch_size):\\n+ # And now just move everything below under this function\\n+ # Ensure that anything declared outside this function is set as `nonlocal`\\n+ # so it is in scope\\n+ nonlocal model, optimizer\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+\\n+ # New Code #\\n+ # And call it at the end with no arguments\\n+ # Note: You could also refactor this outside of your training loop function\\n+ inner_training_loop()\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/src/accelerate/memory_utils.py b/src/accelerate/memory_utils.py\\nnew file mode 100644\\nindex 000000000..73a298caf\\n--- /dev/null\\n+++ b/src/accelerate/memory_utils.py\\n@@ -0,0 +1,86 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n+[toma](https://github.com/BlackHC/toma) library.\\n+\\\"\\\"\\\"\\n+\\n+import functools\\n+import gc\\n+import inspect\\n+\\n+import torch\\n+\\n+\\n+def should_reduce_batch_size(exception: Exception) -> bool:\\n+ \\\"\\\"\\\"\\n+ Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+\\n+ Args:\\n+ exception (`Exception`):\\n+ An exception\\n+ \\\"\\\"\\\"\\n+ _statements = [\\n+ \\\"CUDA out of memory.\\\", # CUDA OOM\\n+ \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n+ \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n+ ]\\n+ if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n+ return any(err in exception.args[0] for err in _statements)\\n+ return False\\n+\\n+\\n+def find_executable_batch_size(function: callable = None, starting_batch_size: int = 128):\\n+ \\\"\\\"\\\"\\n+ A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or\\n+ CUDNN, the batch size is cut in half and passed to `function`\\n+\\n+ `function` must take in a `batch_size` parameter as its first argument.\\n+\\n+ Args:\\n+ function (`callable`, *optional*):\\n+ A function to wrap\\n+ starting_batch_size (`int`, *optional*):\\n+ The batch size to try and fit into memory\\n+ \\\"\\\"\\\"\\n+ if function is None:\\n+ return functools.partial(find_executable_batch_size, starting_batch_size=starting_batch_size)\\n+\\n+ batch_size = starting_batch_size\\n+\\n+ def decorator(*args, **kwargs):\\n+ nonlocal batch_size\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ params = list(inspect.signature(function).parameters.keys())\\n+ # Guard against user error\\n+ if len(params) < (len(args) + 1):\\n+ arg_str = \\\", \\\".join([f\\\"{arg}={value}\\\" for arg, value in zip(params[1:], args[1:])])\\n+ raise TypeError(\\n+ f\\\"Batch size was passed into `{function.__name__}` as the first argument when called.\\\"\\n+ f\\\"Remove this as the decorator already does so: `{function.__name__}({arg_str})`\\\"\\n+ )\\n+ while True:\\n+ try:\\n+ return function(batch_size, *args, **kwargs)\\n+ except Exception as e:\\n+ if should_reduce_batch_size(e):\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ batch_size //= 2\\n+ else:\\n+ raise\\n+\\n+ return decorator\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nindex aa78fed9f..919667fc5 100644\\n--- a/tests/test_examples.py\\n+++ b/tests/test_examples.py\\n@@ -40,7 +40,7 @@\\n # Should mock `{script_name}.get_dataloaders` via:\\n # @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n \\n-EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\", \\\"multi_process_metrics.py\\\"]\\n+EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\", \\\"multi_process_metrics.py\\\", \\\"memory.py\\\"]\\n \\n \\n def mocked_dataloaders(accelerator, batch_size: int = 16):\\ndiff --git a/tests/test_memory_utils.py b/tests/test_memory_utils.py\\nnew file mode 100644\\nindex 000000000..510d79c71\\n--- /dev/null\\n+++ b/tests/test_memory_utils.py\\n@@ -0,0 +1,62 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+\\n+from accelerate.memory_utils import find_executable_batch_size\\n+\\n+\\n+def raise_fake_out_of_memory():\\n+ raise RuntimeError(\\\"CUDA out of memory.\\\")\\n+\\n+\\n+class MemoryTest(unittest.TestCase):\\n+ def test_memory_implicit(self):\\n+ batch_sizes = []\\n+\\n+ @find_executable_batch_size(starting_batch_size=128)\\n+ def mock_training_loop_function(batch_size):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+\\n+ mock_training_loop_function()\\n+ self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n+\\n+ def test_memory_explicit(self):\\n+ batch_sizes = []\\n+\\n+ @find_executable_batch_size(starting_batch_size=128)\\n+ def mock_training_loop_function(batch_size, arg1):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+ return batch_size, arg1\\n+\\n+ bs, arg1 = mock_training_loop_function(\\\"hello\\\")\\n+ self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n+ self.assertListEqual([bs, arg1], [8, \\\"hello\\\"])\\n+\\n+ def test_verbose_guard(self):\\n+ @find_executable_batch_size(starting_batch_size=128)\\n+ def mock_training_loop_function(batch_size, arg1, arg2):\\n+ if batch_size != 8:\\n+ raise raise_fake_out_of_memory()\\n+\\n+ with self.assertRaises(TypeError) as cm:\\n+ mock_training_loop_function(128, \\\"hello\\\", \\\"world\\\")\\n+ self.assertIn(\\\"Batch size was passed into `f`\\\", cm.exception.args[0])\\n+ self.assertIn(\\\"`f(arg1='hello', arg2='world')\\\", cm.exception.args[0])\\n\",\n \"code_comments\": [\n {\n \"body\": \"We might hit some custom types of users here. The only thing we need to check is that there is a `batch_size` attribute and that it's an iterator, no?\",\n \"diff_hunk\": \"@@ -0,0 +1,82 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n+[toma](https://github.com/BlackHC/toma) library.\\n+\\\"\\\"\\\"\\n+\\n+import functools\\n+from typing import List, Union\\n+\\n+from torch.utils import DataLoader\\n+\\n+from accelerate.data_loader import DataLoaderDispatcher, DataLoaderShard\\n+\\n+\\n+def should_reduce_batch_size(exception: Exception) -> bool:\\n+ \\\"\\\"\\\"\\n+ Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+\\n+ Args:\\n+ exception (`Exception`):\\n+ An exception\\n+ \\\"\\\"\\\"\\n+ _statements = [\\n+ \\\"CUDA out of memory.\\\", # CUDA OOM\\n+ \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n+ \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n+ ]\\n+ if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n+ return any(err in exception.args[0] for err in _statements)\\n+ return False\\n+\\n+\\n+def memory_aware(\\n+ function: callable = None, dataloaders: List[Union[DataLoader, DataLoaderDispatcher, DataLoaderShard]] = None\\n+):\\n+ \\\"\\\"\\\"\\n+ A decorator that will reduce the batch size in half of all `dataloaders` if the wrapped function fails from any\\n+ exceptions related to out-of-memory or CUDNN not supported until the function executes completely.\\n+\\n+ Args:\\n+ function (`callable`, *optional*):\\n+ A function to wrap that utilizes all declared `dataloaders`\\n+ dataloaders (list of `DataLoader`, [`~data_loader.DataLoaderDispatcher`], or [`~data_loader.DataLoaderShard`], *optional*):\\n+ A list of prepared or unprepared `DataLoaders`.\\n+ \\\"\\\"\\\"\\n+ if not isinstance(dataloaders, (tuple, list)):\\n+ dataloaders = [dataloaders]\\n+ if not all(\\n+ (isinstance(dataloader, (DataLoaderDispatcher, DataLoaderShard, DataLoader)) for dataloader in dataloaders)\\n+ ):\\n+ raise TypeError(\\n+ \\\"Unsupported operation attempted. One or more dataloaders passed were not of type(s) `DataLoaderDispatcher`, `DataLoaderShard`, or `torch.utils.DataLoader`\\\"\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"Does this actually work? PyTorch fixes the `batch_sampler` at init, so I think this is ignore by the `dataloader`.\",\n \"diff_hunk\": \"@@ -0,0 +1,82 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n+[toma](https://github.com/BlackHC/toma) library.\\n+\\\"\\\"\\\"\\n+\\n+import functools\\n+from typing import List, Union\\n+\\n+from torch.utils import DataLoader\\n+\\n+from accelerate.data_loader import DataLoaderDispatcher, DataLoaderShard\\n+\\n+\\n+def should_reduce_batch_size(exception: Exception) -> bool:\\n+ \\\"\\\"\\\"\\n+ Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+\\n+ Args:\\n+ exception (`Exception`):\\n+ An exception\\n+ \\\"\\\"\\\"\\n+ _statements = [\\n+ \\\"CUDA out of memory.\\\", # CUDA OOM\\n+ \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n+ \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n+ ]\\n+ if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n+ return any(err in exception.args[0] for err in _statements)\\n+ return False\\n+\\n+\\n+def memory_aware(\\n+ function: callable = None, dataloaders: List[Union[DataLoader, DataLoaderDispatcher, DataLoaderShard]] = None\\n+):\\n+ \\\"\\\"\\\"\\n+ A decorator that will reduce the batch size in half of all `dataloaders` if the wrapped function fails from any\\n+ exceptions related to out-of-memory or CUDNN not supported until the function executes completely.\\n+\\n+ Args:\\n+ function (`callable`, *optional*):\\n+ A function to wrap that utilizes all declared `dataloaders`\\n+ dataloaders (list of `DataLoader`, [`~data_loader.DataLoaderDispatcher`], or [`~data_loader.DataLoaderShard`], *optional*):\\n+ A list of prepared or unprepared `DataLoaders`.\\n+ \\\"\\\"\\\"\\n+ if not isinstance(dataloaders, (tuple, list)):\\n+ dataloaders = [dataloaders]\\n+ if not all(\\n+ (isinstance(dataloader, (DataLoaderDispatcher, DataLoaderShard, DataLoader)) for dataloader in dataloaders)\\n+ ):\\n+ raise TypeError(\\n+ \\\"Unsupported operation attempted. One or more dataloaders passed were not of type(s) `DataLoaderDispatcher`, `DataLoaderShard`, or `torch.utils.DataLoader`\\\"\\n+ )\\n+\\n+ if function is None:\\n+ return functools.partial(memory_aware, dataloaders=dataloaders)\\n+\\n+ def decorator(*args, **kwargs):\\n+ while True:\\n+ try:\\n+ return function(*args, **kwargs)\\n+ except Exception as e:\\n+ if should_reduce_batch_size(e):\\n+ for dataloader in dataloaders:\\n+ dataloader.batch_size /= 2\",\n \"from_author\": false\n },\n {\n \"body\": \"Still not fond of that name ;-) What about `@find_max_batch_size`?\",\n \"diff_hunk\": \"@@ -0,0 +1,218 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+\\n+# New Code #\\n+from accelerate.memory_utils import memory_aware\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to ensure out-of-memory errors never\\n+# iterrupt training, and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # New Code #\\n+ # We now can define an inner training loop function. It should take a batch size as the only parameter,\\n+ # and build the dataloaders in there.\\n+ # It also gets our decorator\\n+ @memory_aware(starting_batch_size=batch_size)\",\n \"from_author\": false\n },\n {\n \"body\": \"It's cleaner to pass the string on several lines (with the `\\\"\\\"\\\"` you will get the new lines and indentation in the text displayed by the warning).\\r\\n```suggestion\\r\\n f\\\"Batch size was passed into `{function.__name__}` as the first argument when called.\\\"\\r\\n f\\\"Remove this as the decorator already does so: `{function.__name__}({arg_str})`\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,87 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\\"\\\"\\\"\\n+A collection of utilities for ensuring that training can always occur. Heavily influenced by the\\n+[toma](https://github.com/BlackHC/toma) library.\\n+\\\"\\\"\\\"\\n+\\n+import functools\\n+import gc\\n+import inspect\\n+\\n+import torch\\n+\\n+\\n+def should_reduce_batch_size(exception: Exception) -> bool:\\n+ \\\"\\\"\\\"\\n+ Checks if `exception` relates to CUDA out-of-memory, CUDNN not supported, or CPU out-of-memory\\n+\\n+ Args:\\n+ exception (`Exception`):\\n+ An exception\\n+ \\\"\\\"\\\"\\n+ _statements = [\\n+ \\\"CUDA out of memory.\\\", # CUDA OOM\\n+ \\\"cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.\\\", # CUDNN SNAFU\\n+ \\\"DefaultCPUAllocator: can't allocate memory\\\", # CPU OOM\\n+ ]\\n+ if isinstance(exception, RuntimeError) and len(exception.args) == 1:\\n+ return any(err in exception.args[0] for err in _statements)\\n+ return False\\n+\\n+\\n+def memory_aware(function: callable = None, starting_batch_size: int = 128):\\n+ \\\"\\\"\\\"\\n+ A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or\\n+ CUDNN, the batch size is cut in half and passed to `function`\\n+\\n+ `function` must take in a `batch_size` parameter as its first argument.\\n+\\n+ Args:\\n+ function (`callable`, *optional*):\\n+ A function to wrap\\n+ starting_batch_size (`int`, *optional*):\\n+ The batch size to try and fit into memory\\n+ \\\"\\\"\\\"\\n+ if function is None:\\n+ return functools.partial(memory_aware, starting_batch_size=starting_batch_size)\\n+\\n+ batch_size = starting_batch_size\\n+\\n+ def decorator(*args, **kwargs):\\n+ nonlocal batch_size\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+ params = list(inspect.signature(function).parameters.keys())\\n+ # Guard against user error\\n+ if len(params) < (len(args) + 1):\\n+ arg_str = \\\", \\\".join([f\\\"{arg}={value}\\\" for arg, value in zip(params[1:], args[1:])])\\n+ raise TypeError(\\n+ f\\\"\\\"\\\"Batch size was passed into `{function.__name__}` as the first argument when called.\\n+ Remove this as the decorator already does so:\\n+ `{function.__name__}({arg_str})`\\\"\\\"\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Use something better than `f` has a function name please ;-)\",\n \"diff_hunk\": \"@@ -0,0 +1,62 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+\\n+from accelerate.memory_utils import memory_aware\\n+\\n+\\n+def raise_fake_out_of_memory():\\n+ raise RuntimeError(\\\"CUDA out of memory.\\\")\\n+\\n+\\n+class MemoryTest(unittest.TestCase):\\n+ def test_memory_implicit(self):\\n+ batch_sizes = []\\n+\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+\\n+ f()\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -0,0 +1,62 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+\\n+from accelerate.memory_utils import memory_aware\\n+\\n+\\n+def raise_fake_out_of_memory():\\n+ raise RuntimeError(\\\"CUDA out of memory.\\\")\\n+\\n+\\n+class MemoryTest(unittest.TestCase):\\n+ def test_memory_implicit(self):\\n+ batch_sizes = []\\n+\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+\\n+ f()\\n+ self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n+\\n+ def test_memory_explicit(self):\\n+ batch_sizes = []\\n+\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size, arg1):\",\n \"from_author\": false\n },\n {\n \"body\": \"Same there!\",\n \"diff_hunk\": \"@@ -0,0 +1,62 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+\\n+from accelerate.memory_utils import memory_aware\\n+\\n+\\n+def raise_fake_out_of_memory():\\n+ raise RuntimeError(\\\"CUDA out of memory.\\\")\\n+\\n+\\n+class MemoryTest(unittest.TestCase):\\n+ def test_memory_implicit(self):\\n+ batch_sizes = []\\n+\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+\\n+ f()\\n+ self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n+\\n+ def test_memory_explicit(self):\\n+ batch_sizes = []\\n+\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size, arg1):\\n+ nonlocal batch_sizes\\n+ batch_sizes.append(batch_size)\\n+ if batch_size != 8:\\n+ raise_fake_out_of_memory()\\n+ return batch_size, arg1\\n+\\n+ bs, arg1 = f(\\\"hello\\\")\\n+ self.assertListEqual(batch_sizes, [128, 64, 32, 16, 8])\\n+ self.assertListEqual([8, \\\"hello\\\"], [bs, arg1])\\n+\\n+ def test_verbose_guard(self):\\n+ @memory_aware(starting_batch_size=128)\\n+ def f(batch_size, arg1, arg2):\",\n \"from_author\": false\n },\n {\n \"body\": \"`find_executable_batch_size` is a bit more on the nose here with what it does. WDYT?\",\n \"diff_hunk\": \"@@ -0,0 +1,218 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+\\n+# New Code #\\n+from accelerate.memory_utils import memory_aware\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to ensure out-of-memory errors never\\n+# iterrupt training, and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # New Code #\\n+ # We now can define an inner training loop function. It should take a batch size as the only parameter,\\n+ # and build the dataloaders in there.\\n+ # It also gets our decorator\\n+ @memory_aware(starting_batch_size=batch_size)\",\n \"from_author\": true\n },\n {\n \"body\": \"Mostly since it's a start high -> go low approach if it broke, rather than find the maximum\",\n \"diff_hunk\": \"@@ -0,0 +1,218 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+\\n+# New Code #\\n+from accelerate.memory_utils import memory_aware\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to ensure out-of-memory errors never\\n+# iterrupt training, and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # New Code #\\n+ # We now can define an inner training loop function. It should take a batch size as the only parameter,\\n+ # and build the dataloaders in there.\\n+ # It also gets our decorator\\n+ @memory_aware(starting_batch_size=batch_size)\",\n \"from_author\": true\n },\n {\n \"body\": \"You do end up with the max that fits on the GPU, but your name works for me too.\",\n \"diff_hunk\": \"@@ -0,0 +1,218 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+\\n+# New Code #\\n+from accelerate.memory_utils import memory_aware\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to ensure out-of-memory errors never\\n+# iterrupt training, and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # New Code #\\n+ # We now can define an inner training loop function. It should take a batch size as the only parameter,\\n+ # and build the dataloaders in there.\\n+ # It also gets our decorator\\n+ @memory_aware(starting_batch_size=batch_size)\",\n \"from_author\": false\n },\n {\n \"body\": \"Put the API doc at the end.\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Memory Utilities\\n+\\n+One of the most frustrating errors when it comes to running training scripts is hitting \\\"CUDA Out-of-Memory\\\", \\n+as the entire script needs to be restarted, progress is lost, and typically a developer would want to simply\\n+start their script and let it run.\\n+\\n+`Accelerate` provides a utility heavily based on [toma](https://github.com/BlackHC/toma) to give this capability.\\n+\\n+## find_executable_batch_size\\n+\\n+[[autodoc]] memory_utils.find_executable_batch_size\",\n \"from_author\": false\n },\n {\n \"body\": \"Wrong name here :-)\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Memory Utilities\\n+\\n+One of the most frustrating errors when it comes to running training scripts is hitting \\\"CUDA Out-of-Memory\\\", \\n+as the entire script needs to be restarted, progress is lost, and typically a developer would want to simply\\n+start their script and let it run.\\n+\\n+`Accelerate` provides a utility heavily based on [toma](https://github.com/BlackHC/toma) to give this capability.\\n+\\n+## find_executable_batch_size\\n+\\n+[[autodoc]] memory_utils.find_executable_batch_size\\n+\\n+This algorithm operates with exponential decay, decreasing the batch size in half after each failed run on some \\n+training script. To use it, restructure your training function to include an inner function that includes this wrapper, \\n+and build your dataloaders inside it. At a minimum, this could look like 4 new lines of code. \\n+> Note: The inner function *must* take in the batch size as the first parameter, but we do not pass one to it when called. The wrapper handles this for us\\n+\\n+```diff\\n+def training_function(args):\\n+ accelerator = Accelerator()\\n+ model = get_model()\\n+ model.to(accelerator.device)\\n+ optimizer = get_optimizer()\\n+\\n++ @memory_aware(starting_batch_size=args.batch_size)\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Still TODO:\\r\\n\\r\\n- Add documentation\\r\\n- Write tests\",\n \"from_author\": true\n },\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/324\",\n \"pr_id\": 916716433\n },\n {\n \"diff\": \"diff --git a/examples/by_feature/checkpointing.py b/examples/by_feature/checkpointing.py\\nindex e595a8db7..ee0716b6d 100644\\n--- a/examples/by_feature/checkpointing.py\\n+++ b/examples/by_feature/checkpointing.py\\n@@ -166,6 +166,8 @@ def training_function(config, args):\\n # New Code #\\n # We need to keep track of how many total steps we have iterated over\\n overall_step = 0\\n+ # We also need to keep track of the stating epoch so files are named properly\\n+ starting_epoch = 0\\n \\n # We need to load the checkpoint back in before training here with `load_state`\\n # The total number of epochs is adjusted based on where the state is being loaded from,\\n@@ -184,23 +186,23 @@ def training_function(config, args):\\n training_difference = os.path.splitext(path)[0]\\n \\n if \\\"epoch\\\" in training_difference:\\n- num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ starting_epoch = int(training_difference.replace(\\\"epoch_\\\", \\\"\\\")) + 1\\n resume_step = None\\n else:\\n resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n- num_epochs -= resume_step // len(train_dataloader)\\n- # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n- resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ starting_epoch = resume_step // len(train_dataloader)\\n+ resume_step -= starting_epoch * len(train_dataloader)\\n \\n # Now we train the model\\n- for epoch in range(num_epochs):\\n+ for epoch in range(starting_epoch, num_epochs):\\n model.train()\\n for step, batch in enumerate(train_dataloader):\\n # New Code #\\n # We need to skip steps until we reach the resumed step during the first epoch\\n- if args.resume_from_checkpoint and epoch == 0:\\n+ if args.resume_from_checkpoint and epoch == starting_epoch:\\n if resume_step is not None and step < resume_step:\\n- pass\\n+ overall_step += 1\\n+ continue\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch.to(accelerator.device)\\n outputs = model(**batch)\\n@@ -246,7 +248,7 @@ def training_function(config, args):\\n \\n # New Code #\\n # We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`\\n- # These are saved to folders named `step_{overall_step}`\\n+ # These are saved to folders named `epoch_{epoch}`\\n # Will contain files: \\\"pytorch_model.bin\\\", \\\"optimizer.bin\\\", \\\"scheduler.bin\\\", and \\\"random_states.pkl\\\"\\n # If mixed precision was used, will also save a \\\"scalar.bin\\\" file\\n if checkpointing_steps == \\\"epoch\\\":\\ndiff --git a/examples/complete_cv_example.py b/examples/complete_cv_example.py\\nindex 01033498c..80a083a8d 100644\\n--- a/examples/complete_cv_example.py\\n+++ b/examples/complete_cv_example.py\\n@@ -173,6 +173,10 @@ def training_function(config, args):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n+ # We need to keep track of how many total steps we have iterated over\\n+ overall_step = 0\\n+ # We also need to keep track of the stating epoch so files are named properly\\n+ starting_epoch = 0\\n \\n # Potentially load in the weights and states from a previous save\\n if args.resume_from_checkpoint:\\n@@ -189,25 +193,24 @@ def training_function(config, args):\\n training_difference = os.path.splitext(path)[0]\\n \\n if \\\"epoch\\\" in training_difference:\\n- num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ starting_epoch = int(training_difference.replace(\\\"epoch_\\\", \\\"\\\")) + 1\\n resume_step = None\\n else:\\n resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n- num_epochs -= resume_step // len(train_dataloader)\\n- # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n- resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ starting_epoch = resume_step // len(train_dataloader)\\n+ resume_step -= starting_epoch * len(train_dataloader)\\n \\n- overall_step = 0\\n # Now we train the model\\n- for epoch in range(num_epochs):\\n+ for epoch in range(starting_epoch, num_epochs):\\n model.train()\\n if args.with_tracking:\\n total_loss = 0\\n for step, batch in enumerate(train_dataloader):\\n # We need to skip steps until we reach the resumed step\\n- if args.resume_from_checkpoint and epoch == 0:\\n+ if args.resume_from_checkpoint and epoch == starting_epoch:\\n if resume_step is not None and step < resume_step:\\n- pass\\n+ overall_step += 1\\n+ continue\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n inputs = (batch[\\\"image\\\"] - mean) / std\\ndiff --git a/examples/complete_nlp_example.py b/examples/complete_nlp_example.py\\nindex a0e8d568c..1910a4f83 100644\\n--- a/examples/complete_nlp_example.py\\n+++ b/examples/complete_nlp_example.py\\n@@ -153,7 +153,10 @@ def collate_fn(examples):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n+ # We need to keep track of how many total steps we have iterated over\\n overall_step = 0\\n+ # We also need to keep track of the stating epoch so files are named properly\\n+ starting_epoch = 0\\n \\n # Potentially load in the weights and states from a previous save\\n if args.resume_from_checkpoint:\\n@@ -170,24 +173,24 @@ def collate_fn(examples):\\n training_difference = os.path.splitext(path)[0]\\n \\n if \\\"epoch\\\" in training_difference:\\n- num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ starting_epoch = int(training_difference.replace(\\\"epoch_\\\", \\\"\\\")) + 1\\n resume_step = None\\n else:\\n resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n- num_epochs -= resume_step // len(train_dataloader)\\n- # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n- resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ starting_epoch = resume_step // len(train_dataloader)\\n+ resume_step -= starting_epoch * len(train_dataloader)\\n \\n # Now we train the model\\n- for epoch in range(num_epochs):\\n+ for epoch in range(starting_epoch, num_epochs):\\n model.train()\\n if args.with_tracking:\\n total_loss = 0\\n for step, batch in enumerate(train_dataloader):\\n # We need to skip steps until we reach the resumed step\\n- if args.resume_from_checkpoint and epoch == 0:\\n+ if args.resume_from_checkpoint and epoch == starting_epoch:\\n if resume_step is not None and step < resume_step:\\n- pass\\n+ overall_step += 1\\n+ continue\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch.to(accelerator.device)\\n outputs = model(**batch)\\ndiff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex e348e161f..ac6df7741 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -69,6 +69,8 @@ class TempDirTestCase(unittest.TestCase):\\n The temporary directory location will be stored in `self.tmpdir`\\n \\\"\\\"\\\"\\n \\n+ clear_on_setup = True\\n+\\n @classmethod\\n def setUpClass(cls):\\n \\\"Creates a `tempfile.TemporaryDirectory` and stores it in `cls.tmpdir`\\\"\\n@@ -82,11 +84,12 @@ def tearDownClass(cls):\\n \\n def setUp(self):\\n \\\"Destroy all contents in `self.tmpdir`, but not `self.tmpdir`\\\"\\n- for path in Path(self.tmpdir).glob(\\\"**/*\\\"):\\n- if path.is_file():\\n- path.unlink()\\n- elif path.is_dir():\\n- shutil.rmtree(path)\\n+ if self.clear_on_setup:\\n+ for path in Path(self.tmpdir).glob(\\\"**/*\\\"):\\n+ if path.is_file():\\n+ path.unlink()\\n+ elif path.is_dir():\\n+ shutil.rmtree(path)\\n \\n \\n class MockingTestCase(unittest.TestCase):\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nindex 3ecd3bf91..aa78fed9f 100644\\n--- a/tests/test_examples.py\\n+++ b/tests/test_examples.py\\n@@ -22,7 +22,7 @@\\n \\n from accelerate import DistributedType\\n from accelerate.test_utils.examples import compare_against_test\\n-from accelerate.test_utils.testing import slow\\n+from accelerate.test_utils.testing import TempDirTestCase, slow\\n from datasets import load_dataset\\n from transformers import AutoTokenizer\\n \\n@@ -158,30 +158,61 @@ def test_cv_examples(self):\\n self.one_complete_example(\\\"complete_cv_example.py\\\", False, cv_path, special_strings)\\n \\n \\n-class FeatureExamplesTests(unittest.TestCase):\\n+class FeatureExamplesTests(TempDirTestCase):\\n+ clear_on_setup = False\\n+\\n @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n def test_checkpointing_by_epoch(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- checkpointing.py\\n- --checkpointing_steps epoch\\n- --output_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps epoch\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"epoch_1\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_steps(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps 2\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"step_4\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_load_states_by_epoch(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --resume_from_checkpoint {os.path.join(self.tmpdir, \\\"epoch_1\\\")}\\n+ \\\"\\\"\\\".split()\\n+ dummy_results = {\\\"accuracy\\\": mock.ANY, \\\"f1\\\": mock.ANY}\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n checkpointing.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"epoch_0\\\")))\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 0:\\\", dummy_results)\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 1:\\\", dummy_results)\\n+ mocked_print.assert_any_call(\\\"epoch 2:\\\", dummy_results)\\n \\n @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n- def test_checkpointing_by_steps(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- checkpointing.py\\n- --checkpointing_steps 2\\n- --output_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n+ def test_load_states_by_steps(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --resume_from_checkpoint {os.path.join(self.tmpdir, \\\"step_4\\\")}\\n+ \\\"\\\"\\\".split()\\n+ dummy_results = {\\\"accuracy\\\": mock.ANY, \\\"f1\\\": mock.ANY}\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n checkpointing.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"step_2\\\")))\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 0:\\\", dummy_results)\\n+ mocked_print.assert_any_call(\\\"epoch 1:\\\", dummy_results)\\n+ mocked_print.assert_any_call(\\\"epoch 2:\\\", dummy_results)\\n \\n @slow\\n def test_cross_validation(self):\\n\",\n \"code_comments\": [\n {\n \"body\": \"How are we sure we will get those values exactly?\",\n \"diff_hunk\": \"@@ -158,30 +158,59 @@ def test_cv_examples(self):\\n self.one_complete_example(\\\"complete_cv_example.py\\\", False, cv_path, special_strings)\\n \\n \\n-class FeatureExamplesTests(unittest.TestCase):\\n+class FeatureExamplesTests(TempDirTestCase):\\n+ clear_on_setup = False\\n+\\n @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n def test_checkpointing_by_epoch(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- checkpointing.py\\n- --checkpointing_steps epoch\\n- --output_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps epoch\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"epoch_1\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_steps(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps 2\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"step_4\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_load_states_by_epoch(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --resume_from_checkpoint {os.path.join(self.tmpdir, \\\"epoch_1\\\")}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n checkpointing.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"epoch_0\\\")))\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 0:\\\", {\\\"accuracy\\\": 0.5, \\\"f1\\\": 0.0})\",\n \"from_author\": false\n },\n {\n \"body\": \"This stems from the scheduler we use in the examples, it makes it impossible for the model to train quickly so we always get an accuracy of .5 and an f1 of 0 for all of our epochs. Hence why none of these example tests check for if we get \\\"good\\\" accuracy, it's for independent behavior.\\r\\n\\r\\n*But* I dug deeper and found `mock.ANY`. In this case we only care about matching the `epoch *` text, not the results. So instead we have something like this:\\r\\n\\r\\n```python\\r\\ndummy_results = {\\\"accuracy\\\":mock.ANY, \\\"f1\\\":mock.ANY}\\r\\nwith self.assertRaises(AssertionError):\\r\\n mocked_print.assert_any_call(\\\"epoch 0:\\\", dummy_results)\\r\\n```\\r\\n\\r\\nWhich helps me sleep much better at night\",\n \"diff_hunk\": \"@@ -158,30 +158,59 @@ def test_cv_examples(self):\\n self.one_complete_example(\\\"complete_cv_example.py\\\", False, cv_path, special_strings)\\n \\n \\n-class FeatureExamplesTests(unittest.TestCase):\\n+class FeatureExamplesTests(TempDirTestCase):\\n+ clear_on_setup = False\\n+\\n @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n def test_checkpointing_by_epoch(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- checkpointing.py\\n- --checkpointing_steps epoch\\n- --output_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps epoch\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"epoch_1\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_steps(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps 2\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"step_4\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_load_states_by_epoch(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --resume_from_checkpoint {os.path.join(self.tmpdir, \\\"epoch_1\\\")}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n checkpointing.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"epoch_0\\\")))\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 0:\\\", {\\\"accuracy\\\": 0.5, \\\"f1\\\": 0.0})\",\n \"from_author\": true\n },\n {\n \"body\": \"You never know if your model might have learned a tiny something, so yes, much better :-)\",\n \"diff_hunk\": \"@@ -158,30 +158,59 @@ def test_cv_examples(self):\\n self.one_complete_example(\\\"complete_cv_example.py\\\", False, cv_path, special_strings)\\n \\n \\n-class FeatureExamplesTests(unittest.TestCase):\\n+class FeatureExamplesTests(TempDirTestCase):\\n+ clear_on_setup = False\\n+\\n @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n def test_checkpointing_by_epoch(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- checkpointing.py\\n- --checkpointing_steps epoch\\n- --output_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps epoch\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"epoch_1\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_steps(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps 2\\n+ --output_dir {self.tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(self.tmpdir, \\\"step_4\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_load_states_by_epoch(self):\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --resume_from_checkpoint {os.path.join(self.tmpdir, \\\"epoch_1\\\")}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n checkpointing.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"epoch_0\\\")))\\n+ with self.assertRaises(AssertionError):\\n+ mocked_print.assert_any_call(\\\"epoch 0:\\\", {\\\"accuracy\\\": 0.5, \\\"f1\\\": 0.0})\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"@sgugger 50/50 on whether to consider these \\\"slow\\\" tests or not. They add ~1.5 min to the CI\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/323\",\n \"pr_id\": 915537956\n },\n {\n \"diff\": \"diff --git a/.gitignore b/.gitignore\\nindex f41377320..7f145cd5c 100644\\n--- a/.gitignore\\n+++ b/.gitignore\\n@@ -132,4 +132,7 @@ dmypy.json\\n .vscode\\n \\n # IntelliJ\\n-.idea\\n\\\\ No newline at end of file\\n+.idea\\n+\\n+# Mac .DS_Store\\n+.DS_Store\\n\\\\ No newline at end of file\\ndiff --git a/CONTRIBUTING.md b/CONTRIBUTING.md\\nindex 3073b3381..fcc7d9b1c 100644\\n--- a/CONTRIBUTING.md\\n+++ b/CONTRIBUTING.md\\n@@ -54,7 +54,7 @@ Did not find it? :( So we can act quickly on it, please follow these steps:\\n * Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n * A short, self-contained, code snippet that allows us to reproduce the bug in\\n less than 30s;\\n-* Provide the with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_congig.yml`)\\n+* Provide the with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_config.yaml`)\\n \\n ### Do you want a new feature?\\n \\ndiff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml\\nindex 1ee741653..d35024d66 100644\\n--- a/docs/source/_toctree.yml\\n+++ b/docs/source/_toctree.yml\\n@@ -23,6 +23,8 @@\\n title: Checkpointing\\n - local: tracking\\n title: Experiment Tracking\\n+ - local: fsdp\\n+ title: Fully Sharded Data Parallel\\n - local: memory\\n title: Memory Utilities\\n title: API Reference\\ndiff --git a/docs/source/fsdp.mdx b/docs/source/fsdp.mdx\\nnew file mode 100644\\nindex 000000000..e2a0210c8\\n--- /dev/null\\n+++ b/docs/source/fsdp.mdx\\n@@ -0,0 +1,120 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Fully Sharded Data Parallel\\n+\\n+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.\\n+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.\\n+To read more about it and the benefits, check out the [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/).\\n+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.\\n+All you need to do is enable it through the config.\\n+\\n+## How it works out the box\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo) with FSDP enabled:\\n+\\n+```bash\\n+compute_environment: LOCAL_MACHINE\\n+deepspeed_config: {}\\n+distributed_type: FSDP\\n+fsdp_config:\\n+ min_num_params: 2000\\n+ offload_params: false\\n+ sharding_strategy: 1\\n+machine_rank: 0\\n+main_process_ip: null\\n+main_process_port: null\\n+main_training_function: main\\n+mixed_precision: 'no'\\n+num_machines: 1\\n+num_processes: 2\\n+use_cpu: false\\n+```\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+Currently, `Accelerate` supports following config through the CLI:\\n+\\n+```bash\\n+`Sharding Strategy`: [1] FULL_SHARD, [2] SHARD_GRAD_OP\\n+`Min Num Params`: FSDP\\\\'s minimum number of parameters for Default Auto Wrapping.\\n+`Offload Params`: Decides Whether to offload parameters and gradients to CPU.\\n+```\\n+\\n+## Few caveats to be aware of\\n+\\n+- PyTorch FSDP auto wraps sub-modules, flattens the parameters and shards the parameters in place.\\n+ Due to this, any optimizer created before model wrapping gets broken and occupies more memory.\\n+ Hence, it is highly recommended and efficient to prepare model before creating optimizer.\\n+ `Accelerate` will automatically wrap the model and create an optimizer for you in case of single model with a warning message.\\n+ > FSDP Warning: When using FSDP, it is efficient and recommended to call prepare for the model before creating the optimizer\\n+\\n+However, below is the recommended way to prepare model and optimizer while using FSDP:\\n+\\n+```diff\\n+model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n++ model = accelerator.prepare(model)\\n+\\n+optimizer = torch.optim.AdamW(params=model.parameters(), lr=lr)\\n+\\n+- model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(model,\\n+- optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+- )\\n+\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n++ )\\n+\\n+```\\n+\\n+- In case of a single model, if you have created optimizer with multiple parameter groups and called prepare with them together,\\n+ then the parameter groups will be lost and the following warning is displayed:\\n+ > FSDP Warning: When using FSDP, several parameter groups will be conflated into\\n+ > a single one due to nested module wrapping and parameter flattening.\\n+ \\n+ This is because parameter groups created before wrapping will have no meaning post wrapping due parameter flattening of nested FSDP modules into 1D arrays (which can consume many layers).\\n+ For instance, below are the named parameters of FSDP model on GPU 0 (When using 2 GPUs. Around 55M (110M/2) params in 1D arrays as this will have the 1st shard of the parameters). \\n+ Here, if one has applied no weight decay for [bias, LayerNorm.weight] named parameters of unwrapped BERT model, \\n+ it can't be applied to the below FSDP wrapped model as there are no named parameters with either of those strings and \\n+ the parameters of those layers are concatenated with parameters of various other layers.\\n+ ```\\n+ {\\n+ '_fsdp_wrapped_module.flat_param': torch.Size([494209]), \\n+ '_fsdp_wrapped_module._fpw_module.bert.embeddings.word_embeddings._fsdp_wrapped_module.flat_param': torch.Size([11720448]), \\n+ '_fsdp_wrapped_module._fpw_module.bert.encoder._fsdp_wrapped_module.flat_param': torch.Size([42527232])\\n+ }\\n+ ```\\n+\\n+\\n+- In case of multiple models, it is necessary to prepare the models before creating optimizers else it will throw an error.\\n+- Mixed precision is currently not supported with FSDP.\\n+\\n+For more control, users can leverage the `FullyShardedDataParallelPlugin` wherein they can specify `auto_wrap_policy`, `backward_prefetch` and `ignored_modules`.\\n+After creating an instance of this class, users can pass it to the Accelerator class instantiation.\\n+For more information on these options, please refer to the PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) code.\\n+\\n+[[autodoc]] utils.FullyShardedDataParallelPlugin\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex eb3b24ce9..781330ace 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -32,6 +32,7 @@\\n from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers\\n from .utils import (\\n DeepSpeedPlugin,\\n+ FullyShardedDataParallelPlugin,\\n LoggerType,\\n PrecisionType,\\n RNGType,\\n@@ -80,6 +81,9 @@ class Accelerator:\\n deepspeed_plugin (`DeepSpeedPlugin`, *optional*):\\n Tweak your DeepSpeed related args using this argument. This argument is optional and can be configured\\n directly using *accelerate config*\\n+ fsdp_plugin (`FullyShardedDataParallelPlugin`, *optional*):\\n+ Tweak your FSDP related args using this argument. This argument is optional and can be configured directly\\n+ using *accelerate config*\\n rng_types (list of `str` or [`~utils.RNGType`]):\\n The list of random number generators to synchronize at the beginning of each iteration in your prepared\\n dataloaders. Should be one or several of:\\n@@ -127,6 +131,7 @@ def __init__(\\n mixed_precision: Union[PrecisionType, str] = None,\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n+ fsdp_plugin: FullyShardedDataParallelPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n log_with: Optional[List[Union[str, LoggerType, GeneralTracker]]] = None,\\n logging_dir: Optional[Union[str, os.PathLike]] = None,\\n@@ -155,6 +160,15 @@ def __init__(\\n deepspeed_plugin, DeepSpeedPlugin\\n ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\n \\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.12.0.dev20220418+cu113\\\"):\\n+ raise ValueError(\\\"FSDP requires PyTorch >= 1.12.0.dev20220418+cu113\\\")\\n+ if fsdp_plugin is None: # init from env variables\\n+ fsdp_plugin = FullyShardedDataParallelPlugin()\\n+ else:\\n+ if not isinstance(fsdp_plugin, FullyShardedDataParallelPlugin):\\n+ raise TypeError(\\\"`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.\\\")\\n+\\n # Kwargs handlers\\n self.ddp_handler = None\\n self.scaler_handler = None\\n@@ -183,6 +197,7 @@ def __init__(\\n mixed_precision=mixed_precision,\\n cpu=cpu,\\n deepspeed_plugin=deepspeed_plugin,\\n+ fsdp_plugin=fsdp_plugin,\\n _from_accelerator=True,\\n **kwargs,\\n )\\n@@ -326,6 +341,44 @@ def _prepare_one(self, obj, first_pass=False):\\n else:\\n return obj\\n \\n+ def _prepare_fsdp(self, *args):\\n+ result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ break\\n+ optimizers = []\\n+\\n+ self._schedulers = []\\n+ self._models = []\\n+ intermediate_result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ if len(obj.param_groups) > 1:\\n+ logger.warn(\\n+ \\\"FSDP Warning: When using FSDP, several parameter groups will be conflated into \\\"\\n+ \\\"a single one due to nested module wrapping and parameter flattening.\\\"\\n+ )\\n+ optimizer = obj.optimizer.__class__(model.parameters(), **obj.optimizer.defaults)\\n+ obj = self.prepare_optimizer(optimizer)\\n+ optimizers.append(obj)\\n+ elif isinstance(obj, torch.nn.Module):\\n+ self._models.append(obj)\\n+ intermediate_result.append(obj)\\n+\\n+ for obj in intermediate_result:\\n+ if isinstance(obj, AcceleratedScheduler):\\n+ obj.optimizer = optimizers\\n+ for i, opt in enumerate(self._optimizers):\\n+ if getattr(obj.scheduler, \\\"optimizer\\\", None) == opt.optimizer:\\n+ obj.scheduler.optimizer = optimizers[i]\\n+ obj.optimizers = [optimizers[i]]\\n+ break\\n+ self._schedulers.append(obj)\\n+ result.append(obj)\\n+ self._optimizers = optimizers\\n+ return tuple(result)\\n+\\n def prepare(self, *args):\\n \\\"\\\"\\\"\\n Prepare all objects passed in `args` for distributed training and mixed precision, then return them in the same\\n@@ -337,6 +390,25 @@ def prepare(self, *args):\\n - `torch.nn.Module`: PyTorch Module\\n - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ model_count = 0\\n+ optimizer_present = False\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model_count += 1\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer_present = True\\n+ if model_count > 1 and optimizer_present:\\n+ raise ValueError(\\n+ \\\"For FSDP to work with multiple models (>1), \\\"\\n+ \\\"prepare must be called for all the models before optimizers are created\\\"\\n+ )\\n+ elif model_count == 1 and optimizer_present:\\n+ logger.warn(\\n+ \\\"FSDP Warning: When using FSDP, \\\"\\n+ \\\"it is efficient and recommended to call prepare for the model before creating the optimizer\\\"\\n+ )\\n+\\n # On TPUs, putting the model on the XLA device will create new parameters, so the corresponding optimizer will\\n # have parameters disconnected from the model (so no training :-( ).\\n # If the model and optimizer have parameters on different devices we raise an error.\\n@@ -373,16 +445,33 @@ def prepare(self, *args):\\n if isinstance(obj, torch.optim.Optimizer):\\n obj._switch_parameters(mapping)\\n \\n+ if self.distributed_type == DistributedType.FSDP and model_count == 1 and optimizer_present:\\n+ result = self._prepare_fsdp(*result)\\n+\\n return result if len(result) > 1 else result[0]\\n \\n def prepare_model(self, model):\\n- if self.device_placement:\\n+ if self.device_placement and self.distributed_type != DistributedType.FSDP:\\n model = model.to(self.device)\\n if self.distributed_type == DistributedType.MULTI_GPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n+ elif self.distributed_type == DistributedType.FSDP:\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP\\n+\\n+ fsdp_plugin = self.state.fsdp_plugin\\n+ model = FSDP(\\n+ model,\\n+ sharding_strategy=fsdp_plugin.sharding_strategy,\\n+ cpu_offload=fsdp_plugin.cpu_offload,\\n+ auto_wrap_policy=fsdp_plugin.auto_wrap_policy,\\n+ backward_prefetch=fsdp_plugin.backward_prefetch,\\n+ ignored_modules=fsdp_plugin.ignored_modules,\\n+ )\\n+ if not fsdp_plugin.cpu_offload.offload_params:\\n+ model.to(self.device)\\n elif self.distributed_type == DistributedType.MULTI_CPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n@@ -544,6 +633,12 @@ def clip_grad_norm_(self, parameters, max_norm, norm_type=2):\\n \\\"\\\"\\\"\\n Should be used in place of `torch.nn.utils.clip_grad_norm_`.\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ parameters = [p for p in parameters]\\n+ for model in self._models:\\n+ if parameters == [p for p in model.parameters()]:\\n+ model.clip_grad_norm_(max_norm, norm_type)\\n+ return\\n self.unscale_gradients()\\n torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=norm_type)\\n \\ndiff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex d72680bea..69464ea0b 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -99,6 +99,34 @@ def get_cluster_input():\\n default=1,\\n )\\n \\n+ if distributed_type in [DistributedType.MULTI_GPU]:\\n+ use_fsdp = _ask_field(\\n+ \\\"Do you want to use FullyShardedDataParallel? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ if use_fsdp:\\n+ distributed_type = DistributedType.FSDP\\n+ fsdp_config = {}\\n+ if distributed_type == DistributedType.FSDP:\\n+ fsdp_config[\\\"sharding_strategy\\\"] = _ask_field(\\n+ \\\"What should be your sharding strategy ([1] FULL_SHARD, [2] SHARD_GRAD_OP)? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ )\\n+ fsdp_config[\\\"offload_params\\\"] = _ask_field(\\n+ \\\"Do you want to offload parameters and gradients to CPU? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ fsdp_config[\\\"min_num_params\\\"] = _ask_field(\\n+ \\\"What should be your FSDP's minimum number of parameters for Default Auto Wrapping Policy? [1e8]: \\\",\\n+ lambda x: int(x),\\n+ default=1e8,\\n+ )\\n+\\n if distributed_type == DistributedType.TPU:\\n main_training_function = _ask_field(\\n \\\"What is the name of the function in your script that should be launched in all parallel scripts? [main]: \\\",\\n@@ -134,5 +162,6 @@ def get_cluster_input():\\n main_process_port=main_process_port,\\n main_training_function=main_training_function,\\n deepspeed_config=deepspeed_config,\\n+ fsdp_config=fsdp_config,\\n use_cpu=use_cpu,\\n )\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 5af912fc3..fadbe6211 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -136,6 +136,8 @@ class ClusterConfig(BaseConfig):\\n \\n # args for deepspeed_plugin\\n deepspeed_config: dict = None\\n+ # args for fsdp\\n+ fsdp_config: dict = None\\n \\n \\n @dataclass\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex f2cab1ccb..9fa10da7b 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -51,6 +51,30 @@ def launch_command_parser(subparsers=None):\\n action=\\\"store_true\\\",\\n help=\\\"Whether to use deepspeed.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--use_fsdp\\\",\\n+ default=False,\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Whether to use fsdp.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--offload_params\\\",\\n+ default=\\\"false\\\",\\n+ type=str,\\n+ help=\\\"Decides Whether (true|false) to offload parameters and gradients to CPU. (useful only when `use_fsdp` flag is passed).\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--min_num_params\\\",\\n+ type=int,\\n+ default=1e8,\\n+ help=\\\"FSDP's minimum number of parameters for Default Auto Wrapping. (useful only when `use_fsdp` flag is passed).\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--sharding_strategy\\\",\\n+ type=int,\\n+ default=1,\\n+ help=\\\"FSDP's Sharding Strategy. (useful only when `use_fsdp` flag is passed).\\\",\\n+ )\\n parser.add_argument(\\n \\\"--tpu\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not this should launch a TPU training.\\\"\\n )\\n@@ -225,7 +249,11 @@ def multi_gpu_launcher(args):\\n mixed_precision = \\\"fp16\\\"\\n \\n current_env[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n-\\n+ if args.use_fsdp:\\n+ current_env[\\\"USE_FSDP\\\"] = \\\"true\\\"\\n+ current_env[\\\"FSDP_OFFLOAD_PARAMS\\\"] = str(args.offload_params).lower()\\n+ current_env[\\\"FSDP_MIN_NUM_PARAMS\\\"] = str(args.min_num_params)\\n+ current_env[\\\"FSDP_SHARDING_STRATEGY\\\"] = str(args.sharding_strategy)\\n process = subprocess.Popen(cmd, env=current_env)\\n process.wait()\\n if process.returncode != 0:\\n@@ -433,8 +461,8 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if sum([args.multi_gpu, args.tpu, args.use_deepspeed]) > 1:\\n- raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`.\\\")\\n+ if sum([args.multi_gpu, args.tpu, args.use_deepspeed, args.use_fsdp]) > 1:\\n+ raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`, `--use_fsdp`.\\\")\\n \\n defaults = None\\n # Get the default from the config file.\\n@@ -444,6 +472,7 @@ def launch_command(args):\\n args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n+ args.use_fsdp = defaults.distributed_type == DistributedType.FSDP\\n if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n # Update args with the defaults\\n for name, attr in defaults.__dict__.items():\\n@@ -451,6 +480,8 @@ def launch_command(args):\\n for k in defaults.deepspeed_config:\\n if getattr(args, k) is None:\\n setattr(args, k, defaults.deepspeed_config[k])\\n+ for k in defaults.fsdp_config:\\n+ setattr(args, k, defaults.fsdp_config[k])\\n continue\\n \\n # Those args are handled separately\\n@@ -472,6 +503,8 @@ def launch_command(args):\\n # Use the proper launcher\\n if args.use_deepspeed and not args.cpu:\\n deepspeed_launcher(args)\\n+ elif args.use_fsdp and not args.cpu:\\n+ multi_gpu_launcher(args)\\n elif args.multi_gpu and not args.cpu:\\n multi_gpu_launcher(args)\\n elif args.tpu and not args.cpu:\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex b0521c7eb..df2e36e9a 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -89,6 +89,7 @@ class DistributedType(str, Enum):\\n MULTI_CPU = \\\"MULTI_CPU\\\"\\n MULTI_GPU = \\\"MULTI_GPU\\\"\\n DEEPSPEED = \\\"DEEPSPEED\\\"\\n+ FSDP = \\\"FSDP\\\"\\n TPU = \\\"TPU\\\"\\n \\n \\n@@ -149,6 +150,7 @@ def __init__(\\n mixed_precision: str = None,\\n cpu: bool = False,\\n deepspeed_plugin=None,\\n+ fsdp_plugin=None,\\n _from_accelerator: bool = False,\\n **kwargs,\\n ):\\n@@ -206,7 +208,13 @@ def __init__(\\n self.mixed_precision = (\\n parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n )\\n-\\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.distributed_type = DistributedType.FSDP\\n+ if self.mixed_precision != \\\"no\\\":\\n+ raise ValueError(\\n+ \\\"Mixed precision is currently not supported for FSDP. Please set `mixed_precision` to `no`.\\\"\\n+ )\\n+ self.fsdp_plugin = fsdp_plugin\\n elif get_int_from_env([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"], 1) > 1:\\n self.distributed_type = DistributedType.MULTI_CPU\\n if is_ccl_available() and get_int_from_env([\\\"CCL_WORKER_COUNT\\\"], 0) > 0:\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 9bcd87f5f..8101fb7ec 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -12,15 +12,17 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import functools\\n import importlib\\n import os\\n import random\\n+import typing\\n from collections.abc import Mapping\\n from contextlib import contextmanager\\n from dataclasses import dataclass, field\\n from enum import Enum, EnumMeta\\n from functools import update_wrapper\\n-from typing import Any, List, Optional, Union\\n+from typing import Any, Callable, Iterable, List, Optional, Union\\n \\n import numpy as np\\n import torch\\n@@ -738,6 +740,57 @@ def __post_init__(self):\\n }\\n \\n \\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ sharding_strategy: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are [1] FULL_SHARD, [2] SHARD_GRAD_OP\\\"},\\n+ )\\n+ backward_prefetch: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are [1] BACKWARD_PRE, [2] BACKWARD_POST\\\"},\\n+ )\\n+ auto_wrap_policy: \\\"typing.Any\\\" = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A callable specifying a policy to recursively wrap layers with FSDP\\\"},\\n+ )\\n+ cpu_offload: Optional[Callable] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Decides Whether to offload parameters and gradients to CPU.\\\"},\\n+ )\\n+ min_num_params: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"FSDP's minimum number of parameters for Default Auto Wrapping.\\\"}\\n+ )\\n+ ignored_modules: Optional[Iterable[torch.nn.Module]] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A list of modules to ignore for FSDP.\\\"},\\n+ )\\n+\\n+ def __post_init__(self):\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload, ShardingStrategy\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ if self.sharding_strategy is None:\\n+ self.sharding_strategy = ShardingStrategy(int(os.environ.get(\\\"FSDP_SHARDING_STRATEGY\\\", 1)))\\n+\\n+ if self.cpu_offload is None:\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.cpu_offload = CPUOffload(offload_params=True)\\n+ else:\\n+ self.cpu_offload = CPUOffload(offload_params=False)\\n+\\n+ if self.min_num_params is None:\\n+ self.min_num_params = int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", 0))\\n+\\n+ if self.auto_wrap_policy is None:\\n+ if self.min_num_params > 0:\\n+ self.auto_wrap_policy = functools.partial(default_auto_wrap_policy, min_num_params=self.min_num_params)\\n+\\n+\\n @contextmanager\\n def patch_environment(**kwargs):\\n \\\"\\\"\\\"\\n\",\n \"code_comments\": [\n {\n \"body\": \"This is a first step but it assumes there is only one model and one optimizer with all the model parameters. We can call this method before the model is prepared and prepare it there, which would allow us to identify which parameters are use in which optimizers and then properly re-instantiate them with the right parameters/parameters groups.\\r\\n\\r\\nEven better would be to replace the parameters in the existing optimizers without re-instantiating as we are losing parameter groups etc.\\r\\n\\r\\n\",\n \"diff_hunk\": \"@@ -348,6 +349,32 @@ def _prepare_one(self, obj, first_pass=False):\\n else:\\n return obj\\n \\n+ def _prepare_fsdp(self, *args):\\n+ result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ break\\n+ optimizers = []\\n+\\n+ self._schedulers = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer = obj.optimizer.__class__(model.parameters(), **obj.optimizer.defaults)\\n+ obj = self.prepare_optimizer(optimizer)\\n+ optimizers.append(obj)\\n+ elif isinstance(obj, AcceleratedScheduler):\\n+ obj.optimizer = optimizers\\n+ for i, opt in enumerate(self._optimizers):\\n+ if getattr(obj.scheduler, \\\"optimizer\\\", None) == opt.optimizer:\\n+ obj.scheduler.optimizer = optimizers[i]\\n+ obj.optimizers = [optimizers[i]]\\n+ break\\n+ self._schedulers.append(obj)\\n+ result.append(obj)\\n+ self._optimizers = optimizers\\n+ return tuple(result)\",\n \"from_author\": false\n },\n {\n \"body\": \"Is this still necessary?\",\n \"diff_hunk\": \"@@ -359,6 +386,19 @@ def prepare(self, *args):\\n - `torch.nn.Module`: PyTorch Module\\n - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ model_count = 0\\n+ optimizer_present = False\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model_count += 1\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer_present = True\\n+ if model_count > 1 and optimizer_present:\\n+ raise ValueError(\\n+ \\\"For FSDP to work, prepare must be called for all the models before optimizers are created\\\"\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"Those two should also be added to the state, and we should get them from it here.\",\n \"diff_hunk\": \"@@ -405,6 +448,21 @@ def prepare_model(self, model):\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n+ elif self.distributed_type == DistributedType.FSDP:\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ auto_wrap_policy = None\\n+ cpu_offload = None\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ cpu_offload = CPUOffload(offload_params=True)\\n+\\n+ if int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", \\\"0\\\")) > 0:\\n+ auto_wrap_policy = functools.partial(\\n+ default_auto_wrap_policy, min_num_params=int(os.environ[\\\"FSDP_MIN_NUM_PARAMS\\\"])\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"Was it not out in 1.11 ?. Let's use the `base_version` attribute to compare to 1.12.0 without anything added ;-)\",\n \"diff_hunk\": \"@@ -472,6 +499,10 @@ def launch_command(args):\\n # Use the proper launcher\\n if args.use_deepspeed and not args.cpu:\\n deepspeed_launcher(args)\\n+ elif args.use_fsdp and not args.cpu:\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.12.0.dev20220418+cu113\\\"):\\n+ raise ValueError(\\\"FSDP requires PyTorch >= 1.12.0.dev20220418+cu113\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"We should throw an error if we have mixed_precision different from \\\"no\\\" instead of silently ignoring what the user said in their config.\",\n \"diff_hunk\": \"@@ -203,10 +204,13 @@ def __init__(\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n- self.mixed_precision = (\\n- parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n- )\\n-\\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.distributed_type = DistributedType.FSDP\\n+ self.mixed_precision = \\\"no\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Hello, I've updated the code as per yesterday's offline discussion. \",\n \"diff_hunk\": \"@@ -348,6 +349,32 @@ def _prepare_one(self, obj, first_pass=False):\\n else:\\n return obj\\n \\n+ def _prepare_fsdp(self, *args):\\n+ result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ break\\n+ optimizers = []\\n+\\n+ self._schedulers = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer = obj.optimizer.__class__(model.parameters(), **obj.optimizer.defaults)\\n+ obj = self.prepare_optimizer(optimizer)\\n+ optimizers.append(obj)\\n+ elif isinstance(obj, AcceleratedScheduler):\\n+ obj.optimizer = optimizers\\n+ for i, opt in enumerate(self._optimizers):\\n+ if getattr(obj.scheduler, \\\"optimizer\\\", None) == opt.optimizer:\\n+ obj.scheduler.optimizer = optimizers[i]\\n+ obj.optimizers = [optimizers[i]]\\n+ break\\n+ self._schedulers.append(obj)\\n+ result.append(obj)\\n+ self._optimizers = optimizers\\n+ return tuple(result)\",\n \"from_author\": true\n },\n {\n \"body\": \"Yes, currently we will only be able to handle the case of single model and hence throwing error in case of multiple models. \",\n \"diff_hunk\": \"@@ -359,6 +386,19 @@ def prepare(self, *args):\\n - `torch.nn.Module`: PyTorch Module\\n - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ model_count = 0\\n+ optimizer_present = False\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model_count += 1\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer_present = True\\n+ if model_count > 1 and optimizer_present:\\n+ raise ValueError(\\n+ \\\"For FSDP to work, prepare must be called for all the models before optimizers are created\\\"\\n+ )\",\n \"from_author\": true\n },\n {\n \"body\": \"Done. Created FullyShardedDataParallelPlugin for handling the FSDP config.\",\n \"diff_hunk\": \"@@ -405,6 +448,21 @@ def prepare_model(self, model):\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n+ elif self.distributed_type == DistributedType.FSDP:\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ auto_wrap_policy = None\\n+ cpu_offload = None\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ cpu_offload = CPUOffload(offload_params=True)\\n+\\n+ if int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", \\\"0\\\")) > 0:\\n+ auto_wrap_policy = functools.partial(\\n+ default_auto_wrap_policy, min_num_params=int(os.environ[\\\"FSDP_MIN_NUM_PARAMS\\\"])\\n+ )\",\n \"from_author\": true\n },\n {\n \"body\": \"As mentioned offline, at present the model saving/checkpointing is supported through nightly version only.\",\n \"diff_hunk\": \"@@ -472,6 +499,10 @@ def launch_command(args):\\n # Use the proper launcher\\n if args.use_deepspeed and not args.cpu:\\n deepspeed_launcher(args)\\n+ elif args.use_fsdp and not args.cpu:\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.12.0.dev20220418+cu113\\\"):\\n+ raise ValueError(\\\"FSDP requires PyTorch >= 1.12.0.dev20220418+cu113\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -203,10 +204,13 @@ def __init__(\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n- self.mixed_precision = (\\n- parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n- )\\n-\\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.distributed_type = DistributedType.FSDP\\n+ self.mixed_precision = \\\"no\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"For new code, we try to avoid assert, so please use a test and rasie a `TypeError` here.\",\n \"diff_hunk\": \"@@ -155,6 +160,16 @@ def __init__(\\n deepspeed_plugin, DeepSpeedPlugin\\n ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\n \\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.12.0.dev20220418+cu113\\\"):\\n+ raise ValueError(\\\"FSDP requires PyTorch >= 1.12.0.dev20220418+cu113\\\")\\n+ if fsdp_plugin is None: # init from env variables\\n+ fsdp_plugin = FullyShardedDataParallelPlugin()\\n+ else:\\n+ assert isinstance(\\n+ fsdp_plugin, FullyShardedDataParallelPlugin\\n+ ), \\\"`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Split to respect the 119 char limit please :-)\",\n \"diff_hunk\": \"@@ -326,6 +342,43 @@ def _prepare_one(self, obj, first_pass=False):\\n else:\\n return obj\\n \\n+ def _prepare_fsdp(self, *args):\\n+ result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ break\\n+ optimizers = []\\n+\\n+ self._schedulers = []\\n+ self._models = []\\n+ intermediate_result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ if len(obj.param_groups) > 1:\\n+ logger.warn(\\n+ \\\"FSDP Warning: When using FSDP, several parameter groups will be conflated into a single one due to nested module wrapping and parameter flattening.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"The error message could be made clearer then.\",\n \"diff_hunk\": \"@@ -359,6 +386,19 @@ def prepare(self, *args):\\n - `torch.nn.Module`: PyTorch Module\\n - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ model_count = 0\\n+ optimizer_present = False\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model_count += 1\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer_present = True\\n+ if model_count > 1 and optimizer_present:\\n+ raise ValueError(\\n+ \\\"For FSDP to work, prepare must be called for all the models before optimizers are created\\\"\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"There are two consecutive calls to `to` here in this case, would be better to only do one.\",\n \"diff_hunk\": \"@@ -373,16 +443,33 @@ def prepare(self, *args):\\n if isinstance(obj, torch.optim.Optimizer):\\n obj._switch_parameters(mapping)\\n \\n+ if self.distributed_type == DistributedType.FSDP:\\n+ result = self._prepare_fsdp(*result)\\n+\\n return result if len(result) > 1 else result[0]\\n \\n def prepare_model(self, model):\\n- if self.device_placement:\\n+ if self.device_placement and self.distributed_type != DistributedType.FSDP:\\n model = model.to(self.device)\\n if self.distributed_type == DistributedType.MULTI_GPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n+ elif self.distributed_type == DistributedType.FSDP:\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP\\n+\\n+ fsdp_plugin = self.state.fsdp_plugin\\n+ model = FSDP(\\n+ model,\\n+ sharding_strategy=fsdp_plugin.sharding_strategy,\\n+ cpu_offload=fsdp_plugin.cpu_offload,\\n+ auto_wrap_policy=fsdp_plugin.auto_wrap_policy,\\n+ backward_prefetch=fsdp_plugin.backward_prefetch,\\n+ ignored_modules=fsdp_plugin.ignored_modules,\\n+ ).to(self.device)\\n+ if fsdp_plugin.cpu_offload.offload_params:\\n+ model.to(\\\"cpu\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"Mixed precision is currently not supported for FSDP. Please set `mixed_precision` to `no`.\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -206,7 +208,13 @@ def __init__(\\n self.mixed_precision = (\\n parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n )\\n-\\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.distributed_type = DistributedType.FSDP\\n+ if self.mixed_precision != \\\"no\\\":\\n+ raise ValueError(\\n+ \\\"Mixed precision is currently not supported for FSDPS. Please set `mixed_precision` to `no`.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Why add this here, is this used anywhere? The dataclass in itself should be enough to contain the full config?\",\n \"diff_hunk\": \"@@ -738,6 +739,68 @@ def __post_init__(self):\\n }\\n \\n \\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy\\n+\\n+ sharding_strategy: Optional[ShardingStrategy] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are {}\\\".format(ShardingStrategy.__members__)},\\n+ )\\n+ backward_prefetch: Optional[BackwardPrefetch] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are {}\\\".format(BackwardPrefetch.__members__)},\\n+ )\\n+ auto_wrap_policy: Optional[Callable] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A callable specifying a policy to recursively wrap layers with FSDP\\\"},\\n+ )\\n+ cpu_offload: Optional[CPUOffload] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Decides Whether to offload parameters and gradients to CPU.\\\"},\\n+ )\\n+ min_num_params: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"FSDP's minimum number of parameters for Default Auto Wrapping.\\\"}\\n+ )\\n+ ignored_modules: Optional[Iterable[torch.nn.Module]] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A list of modules to ignore for FSDP.\\\"},\\n+ )\\n+\\n+ def __post_init__(self):\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload, ShardingStrategy\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ if self.sharding_strategy is None:\\n+ self.sharding_strategy = ShardingStrategy(int(os.environ.get(\\\"FSDP_SHARDING_STRATEGY\\\", 1)))\\n+\\n+ if self.cpu_offload is None:\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.cpu_offload = CPUOffload(offload_params=True)\\n+ else:\\n+ self.cpu_offload = CPUOffload(offload_params=False)\\n+\\n+ if self.min_num_params is None:\\n+ self.min_num_params = int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", 0))\\n+\\n+ if self.auto_wrap_policy is None:\\n+ if self.min_num_params > 0:\\n+ self.auto_wrap_policy = functools.partial(default_auto_wrap_policy, min_num_params=self.min_num_params)\\n+\\n+ self.fsdp_config = {\\n+ \\\"sharding_strategy\\\": str(self.sharding_strategy),\\n+ \\\"cpu_offload\\\": self.cpu_offload.offload_params,\\n+ \\\"min_num_params\\\": self.min_num_params,\\n+ \\\"is_default_auto_wrap_policy\\\": self.auto_wrap_policy.__name__ == \\\"default_auto_wrap_policy\\\",\\n+ \\\"ignored_modules_present\\\": self.ignored_modules is not None,\\n+ \\\"backward_prefetch_present\\\": self.backward_prefetch is not None,\\n+ }\",\n \"from_author\": false\n },\n {\n \"body\": \"As said offline this is the line making the CI red.\",\n \"diff_hunk\": \"@@ -738,6 +739,68 @@ def __post_init__(self):\\n }\\n \\n \\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy\",\n \"from_author\": false\n },\n {\n \"body\": \"Got it. Thanks for pointing this out. Fixed this.\",\n \"diff_hunk\": \"@@ -738,6 +739,68 @@ def __post_init__(self):\\n }\\n \\n \\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy\",\n \"from_author\": true\n },\n {\n \"body\": \"It was used sort of \\\"__repr__\\\" to be printed when printing the accelerator state. removed this as the dataclass should be the full config.\",\n \"diff_hunk\": \"@@ -738,6 +739,68 @@ def __post_init__(self):\\n }\\n \\n \\n+@dataclass\\n+class FullyShardedDataParallelPlugin:\\n+ \\\"\\\"\\\"\\n+ This plugin is used to enable fully sharded data parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch, CPUOffload, ShardingStrategy\\n+\\n+ sharding_strategy: Optional[ShardingStrategy] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are {}\\\".format(ShardingStrategy.__members__)},\\n+ )\\n+ backward_prefetch: Optional[BackwardPrefetch] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are {}\\\".format(BackwardPrefetch.__members__)},\\n+ )\\n+ auto_wrap_policy: Optional[Callable] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A callable specifying a policy to recursively wrap layers with FSDP\\\"},\\n+ )\\n+ cpu_offload: Optional[CPUOffload] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Decides Whether to offload parameters and gradients to CPU.\\\"},\\n+ )\\n+ min_num_params: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"FSDP's minimum number of parameters for Default Auto Wrapping.\\\"}\\n+ )\\n+ ignored_modules: Optional[Iterable[torch.nn.Module]] = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"A list of modules to ignore for FSDP.\\\"},\\n+ )\\n+\\n+ def __post_init__(self):\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload, ShardingStrategy\\n+ from torch.distributed.fsdp.wrap import default_auto_wrap_policy\\n+\\n+ if self.sharding_strategy is None:\\n+ self.sharding_strategy = ShardingStrategy(int(os.environ.get(\\\"FSDP_SHARDING_STRATEGY\\\", 1)))\\n+\\n+ if self.cpu_offload is None:\\n+ if os.environ.get(\\\"FSDP_OFFLOAD_PARAMS\\\", \\\"false\\\") == \\\"true\\\":\\n+ self.cpu_offload = CPUOffload(offload_params=True)\\n+ else:\\n+ self.cpu_offload = CPUOffload(offload_params=False)\\n+\\n+ if self.min_num_params is None:\\n+ self.min_num_params = int(os.environ.get(\\\"FSDP_MIN_NUM_PARAMS\\\", 0))\\n+\\n+ if self.auto_wrap_policy is None:\\n+ if self.min_num_params > 0:\\n+ self.auto_wrap_policy = functools.partial(default_auto_wrap_policy, min_num_params=self.min_num_params)\\n+\\n+ self.fsdp_config = {\\n+ \\\"sharding_strategy\\\": str(self.sharding_strategy),\\n+ \\\"cpu_offload\\\": self.cpu_offload.offload_params,\\n+ \\\"min_num_params\\\": self.min_num_params,\\n+ \\\"is_default_auto_wrap_policy\\\": self.auto_wrap_policy.__name__ == \\\"default_auto_wrap_policy\\\",\\n+ \\\"ignored_modules_present\\\": self.ignored_modules is not None,\\n+ \\\"backward_prefetch_present\\\": self.backward_prefetch is not None,\\n+ }\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -373,16 +443,33 @@ def prepare(self, *args):\\n if isinstance(obj, torch.optim.Optimizer):\\n obj._switch_parameters(mapping)\\n \\n+ if self.distributed_type == DistributedType.FSDP:\\n+ result = self._prepare_fsdp(*result)\\n+\\n return result if len(result) > 1 else result[0]\\n \\n def prepare_model(self, model):\\n- if self.device_placement:\\n+ if self.device_placement and self.distributed_type != DistributedType.FSDP:\\n model = model.to(self.device)\\n if self.distributed_type == DistributedType.MULTI_GPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n+ elif self.distributed_type == DistributedType.FSDP:\\n+ from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP\\n+\\n+ fsdp_plugin = self.state.fsdp_plugin\\n+ model = FSDP(\\n+ model,\\n+ sharding_strategy=fsdp_plugin.sharding_strategy,\\n+ cpu_offload=fsdp_plugin.cpu_offload,\\n+ auto_wrap_policy=fsdp_plugin.auto_wrap_policy,\\n+ backward_prefetch=fsdp_plugin.backward_prefetch,\\n+ ignored_modules=fsdp_plugin.ignored_modules,\\n+ ).to(self.device)\\n+ if fsdp_plugin.cpu_offload.offload_params:\\n+ model.to(\\\"cpu\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -326,6 +342,43 @@ def _prepare_one(self, obj, first_pass=False):\\n else:\\n return obj\\n \\n+ def _prepare_fsdp(self, *args):\\n+ result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ break\\n+ optimizers = []\\n+\\n+ self._schedulers = []\\n+ self._models = []\\n+ intermediate_result = []\\n+ for obj in args:\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ if len(obj.param_groups) > 1:\\n+ logger.warn(\\n+ \\\"FSDP Warning: When using FSDP, several parameter groups will be conflated into a single one due to nested module wrapping and parameter flattening.\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -155,6 +160,16 @@ def __init__(\\n deepspeed_plugin, DeepSpeedPlugin\\n ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\n \\n+ if os.environ.get(\\\"USE_FSDP\\\", \\\"false\\\") == \\\"true\\\":\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.12.0.dev20220418+cu113\\\"):\\n+ raise ValueError(\\\"FSDP requires PyTorch >= 1.12.0.dev20220418+cu113\\\")\\n+ if fsdp_plugin is None: # init from env variables\\n+ fsdp_plugin = FullyShardedDataParallelPlugin()\\n+ else:\\n+ assert isinstance(\\n+ fsdp_plugin, FullyShardedDataParallelPlugin\\n+ ), \\\"`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -359,6 +386,19 @@ def prepare(self, *args):\\n - `torch.nn.Module`: PyTorch Module\\n - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n+ if self.distributed_type == DistributedType.FSDP:\\n+ model_count = 0\\n+ optimizer_present = False\\n+ for obj in args:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model_count += 1\\n+ if isinstance(obj, torch.optim.Optimizer):\\n+ optimizer_present = True\\n+ if model_count > 1 and optimizer_present:\\n+ raise ValueError(\\n+ \\\"For FSDP to work, prepare must be called for all the models before optimizers are created\\\"\\n+ )\",\n \"from_author\": true\n },\n {\n \"body\": \"Can we add the new guide without changing the indentation of the whole file? ;-)\",\n \"diff_hunk\": \"@@ -1,26 +1,28 @@\\n-- sections: \\n- - local: index\\n- title: π€ Accelerate\\n- - local: quicktour\\n- title: Quick tour\\n- - local: installation\\n- title: Installation\\n+- sections:\\n+ - local: index\\n+ title: π€ Accelerate\\n+ - local: quicktour\\n+ title: Quick tour\\n+ - local: installation\\n+ title: Installation\\n title: Get started\\n - sections:\\n- - local: sagemaker\\n- title: Amazon SageMaker\\n+ - local: sagemaker\\n+ title: Amazon SageMaker\\n title: Guides\\n - sections:\\n- - local: accelerator\\n- title: Accelerator\\n- - local: launcher\\n- title: Notebook Launcher\\n- - local: kwargs\\n- title: Kwargs Handlers\\n- - local: internal\\n- title: Internals\\n- - local: checkpoint\\n- title: Checkpointing\\n- - local: tracking\\n- title: Experiment Tracking\\n+ - local: accelerator\\n+ title: Accelerator\\n+ - local: launcher\\n+ title: Notebook Launcher\\n+ - local: kwargs\\n+ title: Kwargs Handlers\\n+ - local: internal\\n+ title: Internals\\n+ - local: checkpoint\\n+ title: Checkpointing\\n+ - local: tracking\\n+ title: Experiment Tracking\\n+ - local: fsdp\\n+ title: Fully Sharded Data Parallel\",\n \"from_author\": false\n },\n {\n \"body\": \"I would put this before the API doc (so before the line [[autodoc]] above).\",\n \"diff_hunk\": \"@@ -0,0 +1,107 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Fully Sharded Data Parallel\\n+\\n+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.\\n+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.\\n+To read more about it and the benefits, check out the [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/).\\n+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.\\n+All you need to do is enable it through the config.\\n+\\n+## How it works out the box\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo) with FSDP enabled:\\n+\\n+```bash\\n+compute_environment: LOCAL_MACHINE\\n+deepspeed_config: {}\\n+distributed_type: FSDP\\n+fsdp_config:\\n+ min_num_params: 2000\\n+ offload_params: false\\n+ sharding_strategy: 1\\n+machine_rank: 0\\n+main_process_ip: null\\n+main_process_port: null\\n+main_training_function: main\\n+mixed_precision: 'no'\\n+num_machines: 1\\n+num_processes: 2\\n+use_cpu: false\\n+```\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+Currently, `Accelerate` supports following config through the CLI:\\n+\\n+```bash\\n+`Sharding Strategy`: [1] FULL_SHARD, [2] SHARD_GRAD_OP\\n+`Min Num Params`: FSDP\\\\'s minimum number of parameters for Default Auto Wrapping.\\n+`Offload Params`: Decides Whether to offload parameters and gradients to CPU.\\n+```\\n+\\n+For more control, users can leverage the `FullyShardedDataParallelPlugin` wherein they can specify `auto_wrap_policy`, `backward_prefetch` and `ignored_modules`.\\n+After creating an instance of this class, users can pass it to the Accelerator class instantiation.\\n+For more information on these options, please refer to the PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) code.\\n+\\n+[[autodoc]] utils.FullyShardedDataParallelPlugin\\n+\\n+## Few caveats to be aware of:\",\n \"from_author\": false\n },\n {\n \"body\": \"You should highlight that FSDP throws away any parameter groups anyway.\",\n \"diff_hunk\": \"@@ -0,0 +1,107 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Fully Sharded Data Parallel\\n+\\n+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.\\n+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.\\n+To read more about it and the benefits, check out the [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/).\\n+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.\\n+All you need to do is enable it through the config.\\n+\\n+## How it works out the box\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo) with FSDP enabled:\\n+\\n+```bash\\n+compute_environment: LOCAL_MACHINE\\n+deepspeed_config: {}\\n+distributed_type: FSDP\\n+fsdp_config:\\n+ min_num_params: 2000\\n+ offload_params: false\\n+ sharding_strategy: 1\\n+machine_rank: 0\\n+main_process_ip: null\\n+main_process_port: null\\n+main_training_function: main\\n+mixed_precision: 'no'\\n+num_machines: 1\\n+num_processes: 2\\n+use_cpu: false\\n+```\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+Currently, `Accelerate` supports following config through the CLI:\\n+\\n+```bash\\n+`Sharding Strategy`: [1] FULL_SHARD, [2] SHARD_GRAD_OP\\n+`Min Num Params`: FSDP\\\\'s minimum number of parameters for Default Auto Wrapping.\\n+`Offload Params`: Decides Whether to offload parameters and gradients to CPU.\\n+```\\n+\\n+For more control, users can leverage the `FullyShardedDataParallelPlugin` wherein they can specify `auto_wrap_policy`, `backward_prefetch` and `ignored_modules`.\\n+After creating an instance of this class, users can pass it to the Accelerator class instantiation.\\n+For more information on these options, please refer to the PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) code.\\n+\\n+[[autodoc]] utils.FullyShardedDataParallelPlugin\\n+\\n+## Few caveats to be aware of:\\n+\\n+- PyTorch FSDP auto wraps sub-modules, flattens the parameters and shards the parameters in place.\\n+ Due to this, any optimizer created before model wrapping gets broken and occupies more memory.\\n+ Hence, it is highly recommended and efficient to prepare model before creating optimizer.\\n+ `Accelerate` will automatically wrap the model and create an optimizer for you in case of single model with a warning message.\\n+ > FSDP Warning: When using FSDP, it is efficient and recommended to call prepare for the model before creating the optimizer\\n+\\n+However, below is the recommended way to prepare model and optimizer while using FSDP:\\n+\\n+```diff\\n+model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n++ model = accelerator.prepare(model)\\n+\\n+optimizer = torch.optim.AdamW(params=model.parameters(), lr=lr)\\n+\\n+- model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(model,\\n+- optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+- )\\n+\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n++ )\\n+\\n+```\\n+\\n+- In case of a single model, if you have created optimizer with multiple optimizer groups and called prepare with them together,\\n+ then the optimizer groups will be lost and the following warning is displayed:\\n+\\n+ > FSDP Warning: When using FSDP, several parameter groups will be conflated into\\n+ > a single one due to nested module wrapping and parameter flattening.\",\n \"from_author\": false\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -0,0 +1,107 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Fully Sharded Data Parallel\\n+\\n+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.\\n+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.\\n+To read more about it and the benefits, check out the [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/).\\n+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.\\n+All you need to do is enable it through the config.\\n+\\n+## How it works out the box\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo) with FSDP enabled:\\n+\\n+```bash\\n+compute_environment: LOCAL_MACHINE\\n+deepspeed_config: {}\\n+distributed_type: FSDP\\n+fsdp_config:\\n+ min_num_params: 2000\\n+ offload_params: false\\n+ sharding_strategy: 1\\n+machine_rank: 0\\n+main_process_ip: null\\n+main_process_port: null\\n+main_training_function: main\\n+mixed_precision: 'no'\\n+num_machines: 1\\n+num_processes: 2\\n+use_cpu: false\\n+```\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+Currently, `Accelerate` supports following config through the CLI:\\n+\\n+```bash\\n+`Sharding Strategy`: [1] FULL_SHARD, [2] SHARD_GRAD_OP\\n+`Min Num Params`: FSDP\\\\'s minimum number of parameters for Default Auto Wrapping.\\n+`Offload Params`: Decides Whether to offload parameters and gradients to CPU.\\n+```\\n+\\n+For more control, users can leverage the `FullyShardedDataParallelPlugin` wherein they can specify `auto_wrap_policy`, `backward_prefetch` and `ignored_modules`.\\n+After creating an instance of this class, users can pass it to the Accelerator class instantiation.\\n+For more information on these options, please refer to the PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) code.\\n+\\n+[[autodoc]] utils.FullyShardedDataParallelPlugin\\n+\\n+## Few caveats to be aware of:\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -1,26 +1,28 @@\\n-- sections: \\n- - local: index\\n- title: π€ Accelerate\\n- - local: quicktour\\n- title: Quick tour\\n- - local: installation\\n- title: Installation\\n+- sections:\\n+ - local: index\\n+ title: π€ Accelerate\\n+ - local: quicktour\\n+ title: Quick tour\\n+ - local: installation\\n+ title: Installation\\n title: Get started\\n - sections:\\n- - local: sagemaker\\n- title: Amazon SageMaker\\n+ - local: sagemaker\\n+ title: Amazon SageMaker\\n title: Guides\\n - sections:\\n- - local: accelerator\\n- title: Accelerator\\n- - local: launcher\\n- title: Notebook Launcher\\n- - local: kwargs\\n- title: Kwargs Handlers\\n- - local: internal\\n- title: Internals\\n- - local: checkpoint\\n- title: Checkpointing\\n- - local: tracking\\n- title: Experiment Tracking\\n+ - local: accelerator\\n+ title: Accelerator\\n+ - local: launcher\\n+ title: Notebook Launcher\\n+ - local: kwargs\\n+ title: Kwargs Handlers\\n+ - local: internal\\n+ title: Internals\\n+ - local: checkpoint\\n+ title: Checkpointing\\n+ - local: tracking\\n+ title: Experiment Tracking\\n+ - local: fsdp\\n+ title: Fully Sharded Data Parallel\",\n \"from_author\": true\n },\n {\n \"body\": \"Done.\",\n \"diff_hunk\": \"@@ -0,0 +1,107 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Fully Sharded Data Parallel\\n+\\n+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.\\n+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.\\n+To read more about it and the benefits, check out the [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/).\\n+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.\\n+All you need to do is enable it through the config.\\n+\\n+## How it works out the box\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo) with FSDP enabled:\\n+\\n+```bash\\n+compute_environment: LOCAL_MACHINE\\n+deepspeed_config: {}\\n+distributed_type: FSDP\\n+fsdp_config:\\n+ min_num_params: 2000\\n+ offload_params: false\\n+ sharding_strategy: 1\\n+machine_rank: 0\\n+main_process_ip: null\\n+main_process_port: null\\n+main_training_function: main\\n+mixed_precision: 'no'\\n+num_machines: 1\\n+num_processes: 2\\n+use_cpu: false\\n+```\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+Currently, `Accelerate` supports following config through the CLI:\\n+\\n+```bash\\n+`Sharding Strategy`: [1] FULL_SHARD, [2] SHARD_GRAD_OP\\n+`Min Num Params`: FSDP\\\\'s minimum number of parameters for Default Auto Wrapping.\\n+`Offload Params`: Decides Whether to offload parameters and gradients to CPU.\\n+```\\n+\\n+For more control, users can leverage the `FullyShardedDataParallelPlugin` wherein they can specify `auto_wrap_policy`, `backward_prefetch` and `ignored_modules`.\\n+After creating an instance of this class, users can pass it to the Accelerator class instantiation.\\n+For more information on these options, please refer to the PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) code.\\n+\\n+[[autodoc]] utils.FullyShardedDataParallelPlugin\\n+\\n+## Few caveats to be aware of:\\n+\\n+- PyTorch FSDP auto wraps sub-modules, flattens the parameters and shards the parameters in place.\\n+ Due to this, any optimizer created before model wrapping gets broken and occupies more memory.\\n+ Hence, it is highly recommended and efficient to prepare model before creating optimizer.\\n+ `Accelerate` will automatically wrap the model and create an optimizer for you in case of single model with a warning message.\\n+ > FSDP Warning: When using FSDP, it is efficient and recommended to call prepare for the model before creating the optimizer\\n+\\n+However, below is the recommended way to prepare model and optimizer while using FSDP:\\n+\\n+```diff\\n+model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n++ model = accelerator.prepare(model)\\n+\\n+optimizer = torch.optim.AdamW(params=model.parameters(), lr=lr)\\n+\\n+- model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(model,\\n+- optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+- )\\n+\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n++ optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n++ )\\n+\\n+```\\n+\\n+- In case of a single model, if you have created optimizer with multiple optimizer groups and called prepare with them together,\\n+ then the optimizer groups will be lost and the following warning is displayed:\\n+\\n+ > FSDP Warning: When using FSDP, several parameter groups will be conflated into\\n+ > a single one due to nested module wrapping and parameter flattening.\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/321\",\n \"pr_id\": 914156436\n },\n {\n \"diff\": \"diff --git a/docs/source/tracking.mdx b/docs/source/tracking.mdx\\nindex 959317887..6d4ca437c 100644\\n--- a/docs/source/tracking.mdx\\n+++ b/docs/source/tracking.mdx\\n@@ -28,12 +28,12 @@ Currently `Accelerate` supports three trackers out-of-the-box:\\n \\n To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]:\\n ```python\\n-from accelerate import Accelerate\\n+from accelerate import Accelerator\\n from accelerate.utils import LoggerType\\n \\n-accelerator = Accelerate(log_with=\\\"all\\\") # For all available trackers in the environment\\n-accelerator = Accelerate(log_with=\\\"wandb\\\")\\n-accelerator = Accelerate(log_with=[\\\"wandb\\\", LoggerType.TENSORBOARD])\\n+accelerator = Accelerator(log_with=\\\"all\\\") # For all available trackers in the environment\\n+accelerator = Accelerator(log_with=\\\"wandb\\\")\\n+accelerator = Accelerator(log_with=[\\\"wandb\\\", LoggerType.TENSORBOARD])\\n ```\\n \\n At the start of your experiment [`~Accelerator.init_trackers`] should be used to setup your project, and potentially add any experiment hyperparameters to be logged:\\n@@ -123,14 +123,14 @@ be used with the API:\\n \\n ```python\\n tracker = MyCustomTracker(\\\"some_run_name\\\")\\n-accelerator = Accelerate(log_with=tracker)\\n+accelerator = Accelerator(log_with=tracker)\\n ```\\n \\n These also can be mixed with existing trackers, including with `\\\"all\\\"`:\\n \\n ```python\\n tracker = MyCustomTracker(\\\"some_run_name\\\")\\n-accelerator = Accelerate(log_with=[tracker, \\\"all\\\"])\\n+accelerator = Accelerator(log_with=[tracker, \\\"all\\\"])\\n ```\\n \\n ## When a wrapper cannot work\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/320\",\n \"pr_id\": 913898567\n },\n {\n \"diff\": \"diff --git a/examples/by_feature/multi_process_metrics.py b/examples/by_feature/multi_process_metrics.py\\nnew file mode 100644\\nindex 000000000..abba1a746\\n--- /dev/null\\n+++ b/examples/by_feature/multi_process_metrics.py\\n@@ -0,0 +1,215 @@\\n+# coding=utf-8\\n+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to properly calculate the metrics on the\\n+# validation dataset when in a distributed system, and builds off the\\n+# `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To help focus on the differences in the code, building `DataLoaders`\\n+# was refactored into its own function.\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ model.eval()\\n+ samples_seen = 0\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ # New Code #\\n+ # First we check if it's a distributed system\\n+ if accelerator.num_processes > 1:\\n+ # Then see if we're on the last batch of our eval dataloader\\n+ if step == len(eval_dataloader):\\n+ # Last batch needs to be truncated on distributed systems as it contains additional samples\\n+ predictions = predictions[: len(eval_dataloader.dataset) - samples_seen]\\n+ references = references[: len(eval_dataloader.dataset) - samples_seen]\\n+ else:\\n+ # Otherwise we add the number of samples seen\\n+ samples_seen += references.shape[0]\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nindex 354412aa5..3ecd3bf91 100644\\n--- a/tests/test_examples.py\\n+++ b/tests/test_examples.py\\n@@ -33,13 +33,14 @@\\n if SRC_DIRS is not None:\\n import checkpointing\\n import cross_validation\\n+ import multi_process_metrics\\n import tracking\\n \\n # DataLoaders built from `test_samples/MRPC` for quick testing\\n # Should mock `{script_name}.get_dataloaders` via:\\n # @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n \\n-EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\"]\\n+EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\", \\\"multi_process_metrics.py\\\"]\\n \\n \\n def mocked_dataloaders(accelerator, batch_size: int = 16):\\n@@ -182,18 +183,6 @@ def test_checkpointing_by_steps(self):\\n checkpointing.main()\\n self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"step_2\\\")))\\n \\n- @mock.patch(\\\"tracking.get_dataloaders\\\", mocked_dataloaders)\\n- def test_tracking(self):\\n- with tempfile.TemporaryDirectory() as tmpdir:\\n- testargs = f\\\"\\\"\\\"\\n- tracking.py\\n- --with_tracking\\n- --logging_dir {tmpdir}\\n- \\\"\\\"\\\".split()\\n- with mock.patch.object(sys, \\\"argv\\\", testargs):\\n- tracking.main()\\n- self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"tracking\\\")))\\n-\\n @slow\\n def test_cross_validation(self):\\n testargs = \\\"\\\"\\\"\\n@@ -205,3 +194,21 @@ def test_cross_validation(self):\\n cross_validation.main()\\n call = mocked_print.mock_calls[-1]\\n self.assertGreaterEqual(call.args[1][\\\"accuracy\\\"], 0.75)\\n+\\n+ @mock.patch(\\\"multi_process_metrics.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_multi_process_metrics(self):\\n+ testargs = [\\\"multi_process_metrics.py\\\"]\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ multi_process_metrics.main()\\n+\\n+ @mock.patch(\\\"tracking.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_tracking(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ testargs = f\\\"\\\"\\\"\\n+ tracking.py\\n+ --with_tracking\\n+ --logging_dir {tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ tracking.main()\\n+ self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"tracking\\\")))\\n\",\n \"code_comments\": [\n {\n \"body\": \"Should be named `multi_process_metrics` as the problem arises as soon as you have several processes, not several nodes.\",\n \"diff_hunk\": \"@@ -0,0 +1,215 @@\\n+# coding=utf-8\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n# Copyright 2022 The HuggingFace Inc. team. All rights reserved.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,215 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"Note: This is just an initial to make sure the format and whatnot looks right and then all the other examples will follow suite :) \",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/319\",\n \"pr_id\": 913416186\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a79012d5c..eb3b24ce9 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -725,6 +725,13 @@ def free_memory(self):\\n gc.collect()\\n torch.cuda.empty_cache()\\n \\n+ def clear(self):\\n+ \\\"\\\"\\\"\\n+ Alias for [`Accelerate.free_memory`], releases all references to the internal objects stored and call the\\n+ garbage collector. You should call this method between two trainings with different models/optimizers.\\n+ \\\"\\\"\\\"\\n+ self.free_memory()\\n+\\n def _get_named_parameters(self, *args):\\n named_parameters = {}\\n for obj in args:\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n Alias for [`Accelerate.free_memory`], releases all references to the internal objects stored and call the garbage\\r\\n```\",\n \"diff_hunk\": \"@@ -725,6 +725,13 @@ def free_memory(self):\\n gc.collect()\\n torch.cuda.empty_cache()\\n \\n+ def clear(self):\\n+ \\\"\\\"\\\"\\n+ Alias for `Accelerate.free_memory`, releases all references to the internal objects stored and call the garbage\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/318\",\n \"pr_id\": 913400743\n },\n {\n \"diff\": \"diff --git a/examples/by_feature/README.md b/examples/by_feature/README.md\\nindex 40ffa3c1e..f0db09937 100644\\n--- a/examples/by_feature/README.md\\n+++ b/examples/by_feature/README.md\\n@@ -54,3 +54,15 @@ These arguments should be added at the end of any method for starting the python\\n ```bash\\n accelerate launch ./tracking.py --with_tracking\\n ```\\n+\\n+### Cross Validation (`cross_validation.py`)\\n+\\n+- Shows how to use `Accelerator.free_memory` and run cross validation efficiently with `datasets`.\\n+- Arguments available:\\n+ - `num_folds`, the number of folds the training dataset should be split into.\\n+\\n+These arguments should be added at the end of any method for starting the python script (such as `python`, `accelerate launch`, `python -m torch.distributed.launch`), such as:\\n+\\n+```bash\\n+accelerate launch ./cross_validation.py --num_folds 2\\n+```\\ndiff --git a/examples/by_feature/cross_validation.py b/examples/by_feature/cross_validation.py\\nnew file mode 100644\\nindex 000000000..9fdc3fe72\\n--- /dev/null\\n+++ b/examples/by_feature/cross_validation.py\\n@@ -0,0 +1,275 @@\\n+# coding=utf-8\\n+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import DatasetDict, load_dataset, load_metric\\n+\\n+# New Code #\\n+# We'll be using StratifiedKFold for this example\\n+from sklearn.model_selection import StratifiedKFold\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing how to perform Cross Validation,\\n+# and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To help focus on the differences in the code, building `DataLoaders`\\n+# was refactored into its own function.\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+# New Code #\\n+# We need a different `get_dataloaders` function that will build dataloaders by indexs\\n+\\n+\\n+def get_fold_dataloaders(\\n+ accelerator: Accelerator, dataset: DatasetDict, train_idxs: List[int], valid_idxs: List[int], batch_size: int = 16\\n+):\\n+ \\\"\\\"\\\"\\n+ Gets a set of train, valid, and test dataloaders for a particular fold\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ The main `Accelerator` object\\n+ train_idxs (list of `int`):\\n+ The split indicies for the training dataset\\n+ valid_idxs (list of `int`):\\n+ The split indicies for the validation dataset\\n+ batch_size (`int`):\\n+ The size of the minibatch. Default is 16\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = DatasetDict(\\n+ {\\n+ \\\"train\\\": dataset[\\\"train\\\"].select(train_idxs),\\n+ \\\"validation\\\": dataset[\\\"train\\\"].select(valid_idxs),\\n+ \\\"test\\\": dataset[\\\"validation\\\"],\\n+ }\\n+ )\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ test_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"test\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader, test_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # New Code #\\n+ test_labels = None\\n+ test_predictions = []\\n+ # Download the dataset\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ # Create our splits\\n+ kfold = StratifiedKFold(n_splits=int(args.num_folds))\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+\\n+ # New Code #\\n+ # Create our folds:\\n+ folds = kfold.split(np.zeros(datasets[\\\"train\\\"].num_rows), datasets[\\\"train\\\"][\\\"label\\\"])\\n+\\n+ # Iterate over them\\n+ for train_idxs, valid_idxs in folds:\\n+ train_dataloader, eval_dataloader, test_dataloader = get_fold_dataloaders(\\n+ accelerator,\\n+ datasets,\\n+ train_idxs,\\n+ valid_idxs,\\n+ )\\n+ if test_labels is None:\\n+ test_labels = datasets[\\\"validation\\\"][\\\"label\\\"]\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+\\n+ # New Code #\\n+ # We also run predictions on the test set at the very end\\n+ fold_predictions = []\\n+ for step, batch in enumerate(test_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ fold_predictions.append(predictions.cpu())\\n+ metric.add_batch(\\n+ predictions=predictions.argmax(dim=-1),\\n+ references=references,\\n+ )\\n+ test_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ test_predictions.append(torch.cat(fold_predictions, dim=0))\\n+ # We now need to release all our memory and get rid of the current model, optimizer, etc\\n+ accelerator.free_memory()\\n+ # New Code #\\n+ # Finally we check the accuracy of our folded results:\\n+ preds = torch.stack(test_predictions, dim=0).sum(dim=0).div(int(config[\\\"n_splits\\\"])).argmax(dim=-1)\\n+ test_metric = metric.compute(predictions=preds, references=test_labels)\\n+ accelerator.print(\\\"Average test metrics from all folds:\\\", test_metric)\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ # New Code #\\n+ parser.add_argument(\\\"--num_folds\\\", type=int, default=3, help=\\\"The number of splits to perform across the dataset\\\")\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex 6a9e66d6a..e348e161f 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -18,6 +18,7 @@\\n import sys\\n import tempfile\\n import unittest\\n+from distutils.util import strtobool\\n from pathlib import Path\\n from typing import List, Union\\n from unittest import mock\\n@@ -28,6 +29,36 @@\\n from ..utils import gather, is_tensorflow_available\\n \\n \\n+def parse_flag_from_env(key, default=False):\\n+ try:\\n+ value = os.environ[key]\\n+ except KeyError:\\n+ # KEY isn't set, default to `default`.\\n+ _value = default\\n+ else:\\n+ # KEY is set, convert it to True or False.\\n+ try:\\n+ _value = strtobool(value)\\n+ except ValueError:\\n+ # More values are supported, but let's keep the message simple.\\n+ raise ValueError(f\\\"If set, {key} must be yes or no.\\\")\\n+ return _value\\n+\\n+\\n+_run_slow_tests = parse_flag_from_env(\\\"RUN_SLOW\\\", default=False)\\n+\\n+\\n+def slow(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test as slow. Slow tests are skipped by default. Set the RUN_SLOW environment variable to a\\n+ truthy value to run them.\\n+ \\\"\\\"\\\"\\n+ if not _run_slow_tests:\\n+ return unittest.skip(\\\"test is slow\\\")(test_case)\\n+ else:\\n+ return test_case\\n+\\n+\\n class TempDirTestCase(unittest.TestCase):\\n \\\"\\\"\\\"\\n A TestCase class that keeps a single `tempfile.TemporaryDirectory` open for the duration of the class, wipes its\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nindex d60d7c08f..354412aa5 100644\\n--- a/tests/test_examples.py\\n+++ b/tests/test_examples.py\\n@@ -22,6 +22,7 @@\\n \\n from accelerate import DistributedType\\n from accelerate.test_utils.examples import compare_against_test\\n+from accelerate.test_utils.testing import slow\\n from datasets import load_dataset\\n from transformers import AutoTokenizer\\n \\n@@ -31,12 +32,15 @@\\n \\n if SRC_DIRS is not None:\\n import checkpointing\\n+ import cross_validation\\n import tracking\\n \\n # DataLoaders built from `test_samples/MRPC` for quick testing\\n # Should mock `{script_name}.get_dataloaders` via:\\n # @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n \\n+EXCLUDE_EXAMPLES = [\\\"cross_validation.py\\\"]\\n+\\n \\n def mocked_dataloaders(accelerator, batch_size: int = 16):\\n tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n@@ -117,21 +121,22 @@ def one_complete_example(\\n by_feature_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))\\n examples_path = os.path.abspath(\\\"examples\\\")\\n for item in os.listdir(by_feature_path):\\n- item_path = os.path.join(by_feature_path, item)\\n- if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\n- with self.subTest(\\n- tested_script=complete_file_name,\\n- feature_script=item,\\n- tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\",\\n- ):\\n- diff = compare_against_test(\\n- os.path.join(examples_path, complete_file_name), item_path, parser_only, secondary_filename\\n- )\\n- diff = \\\"\\\\n\\\".join(diff)\\n- if special_strings is not None:\\n- for string in special_strings:\\n- diff = diff.replace(string, \\\"\\\")\\n- self.assertEqual(diff, \\\"\\\")\\n+ if item not in EXCLUDE_EXAMPLES:\\n+ item_path = os.path.join(by_feature_path, item)\\n+ if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\n+ with self.subTest(\\n+ tested_script=complete_file_name,\\n+ feature_script=item,\\n+ tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\",\\n+ ):\\n+ diff = compare_against_test(\\n+ os.path.join(examples_path, complete_file_name), item_path, parser_only, secondary_filename\\n+ )\\n+ diff = \\\"\\\\n\\\".join(diff)\\n+ if special_strings is not None:\\n+ for string in special_strings:\\n+ diff = diff.replace(string, \\\"\\\")\\n+ self.assertEqual(diff, \\\"\\\")\\n \\n def test_nlp_examples(self):\\n self.one_complete_example(\\\"complete_nlp_example.py\\\", True)\\n@@ -188,3 +193,15 @@ def test_tracking(self):\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n tracking.main()\\n self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"tracking\\\")))\\n+\\n+ @slow\\n+ def test_cross_validation(self):\\n+ testargs = \\\"\\\"\\\"\\n+ cross_validation.py\\n+ --num_folds 2\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ with mock.patch(\\\"accelerate.Accelerator.print\\\") as mocked_print:\\n+ cross_validation.main()\\n+ call = mocked_print.mock_calls[-1]\\n+ self.assertGreaterEqual(call.args[1][\\\"accuracy\\\"], 0.75)\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"<s>Still todo is update the script docs, but code wise it's good</s> \\r\\n\\r\\nDone!\",\n \"from_author\": true\n },\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/317\",\n \"pr_id\": 913389268\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 514b3a4f4..a79012d5c 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -29,7 +29,7 @@\\n from .optimizer import AcceleratedOptimizer\\n from .scheduler import AcceleratedScheduler\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n-from .tracking import CometMLTracker, GeneralTracker, TensorBoardTracker, WandBTracker, get_available_trackers\\n+from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers\\n from .utils import (\\n DeepSpeedPlugin,\\n LoggerType,\\n@@ -39,9 +39,6 @@\\n extract_model_from_parallel,\\n gather,\\n get_pretty_name,\\n- is_comet_ml_available,\\n- is_tensorboard_available,\\n- is_wandb_available,\\n pad_across_processes,\\n save,\\n wait_for_everyone,\\n@@ -132,32 +129,13 @@ def __init__(\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n log_with: Optional[List[Union[str, LoggerType, GeneralTracker]]] = None,\\n- logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\",\\n+ logging_dir: Optional[Union[str, os.PathLike]] = None,\\n dispatch_batches: Optional[bool] = None,\\n step_scheduler_with_optimizer: bool = True,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n- loggers = []\\n- if log_with is not None:\\n- if not isinstance(log_with, (list, tuple)):\\n- log_with = [log_with]\\n- logger.debug(f\\\"{log_with}\\\")\\n- if \\\"all\\\" in log_with or LoggerType.ALL in log_with:\\n- loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers()\\n- else:\\n- for log_type in log_with:\\n- if log_type not in LoggerType and not issubclass(type(log_type), GeneralTracker):\\n- raise ValueError(\\n- f\\\"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}\\\"\\n- )\\n- if issubclass(type(log_type), GeneralTracker):\\n- loggers.append(log_type)\\n- else:\\n- log_type = LoggerType(log_type)\\n- if log_type not in loggers:\\n- loggers.append(log_type)\\n- self.log_with = loggers\\n self.logging_dir = logging_dir\\n+ self.log_with = filter_trackers(log_with, self.logging_dir)\\n \\n if mixed_precision is not None:\\n mixed_precision = str(mixed_precision)\\n@@ -644,12 +622,13 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n if issubclass(type(tracker), GeneralTracker):\\n # Custom trackers are already initialized\\n self.trackers.append(tracker)\\n- elif str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n- self.trackers.append(TensorBoardTracker(project_name, self.logging_dir))\\n- elif str(tracker).lower() == \\\"wandb\\\" and is_wandb_available():\\n- self.trackers.append(WandBTracker(project_name))\\n- elif str(tracker).lower() == \\\"comet_ml\\\" and is_comet_ml_available():\\n- self.trackers.append(CometMLTracker(project_name))\\n+ else:\\n+ tracker_init = LOGGER_TYPE_TO_CLASS[str(tracker)]\\n+ if getattr(tracker_init, \\\"requires_logging_directory\\\"):\\n+ # We can skip this check since it was done in `__init__`\\n+ self.trackers.append(tracker_init(project_name, self.logging_dir))\\n+ else:\\n+ self.trackers.append(tracker_init(project_name))\\n if config is not None:\\n for tracker in self.trackers:\\n tracker.store_init_configuration(config)\\ndiff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py\\nindex 8d496a3d1..de3a19310 100644\\n--- a/src/accelerate/tracking.py\\n+++ b/src/accelerate/tracking.py\\n@@ -17,8 +17,8 @@\\n \\n import logging\\n import os\\n-from abc import ABCMeta, abstractmethod\\n-from typing import Optional, Union\\n+from abc import ABCMeta, abstractmethod, abstractproperty\\n+from typing import List, Optional, Union\\n \\n from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n \\n@@ -54,6 +54,13 @@ class GeneralTracker(object, metaclass=ABCMeta):\\n A base Tracker class to be used for all logging integration implementations.\\n \\\"\\\"\\\"\\n \\n+ @abstractproperty\\n+ def requires_logging_directory(self):\\n+ \\\"\\\"\\\"\\n+ Whether the logger requires a directory to store their logs. Should either return `True` or `False`.\\n+ \\\"\\\"\\\"\\n+ pass\\n+\\n @abstractmethod\\n def store_init_configuration(self, values: dict):\\n \\\"\\\"\\\"\\n@@ -100,7 +107,9 @@ class TensorBoardTracker(GeneralTracker):\\n Location for TensorBoard logs to be stored.\\n \\\"\\\"\\\"\\n \\n- def __init__(self, run_name: str, logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\"):\\n+ requires_logging_directory = True\\n+\\n+ def __init__(self, run_name: str, logging_dir: Optional[Union[str, os.PathLike]]):\\n self.run_name = run_name\\n self.logging_dir = os.path.join(logging_dir, run_name)\\n self.writer = tensorboard.SummaryWriter(self.logging_dir)\\n@@ -157,6 +166,8 @@ class WandBTracker(GeneralTracker):\\n The name of the experiment run.\\n \\\"\\\"\\\"\\n \\n+ requires_logging_directory = False\\n+\\n def __init__(self, run_name: str):\\n self.run_name = run_name\\n self.run = wandb.init(self.run_name)\\n@@ -209,6 +220,8 @@ class CometMLTracker(GeneralTracker):\\n The name of the experiment run.\\n \\\"\\\"\\\"\\n \\n+ requires_logging_directory = False\\n+\\n def __init__(self, run_name: str):\\n self.run_name = run_name\\n self.writer = Experiment(project_name=run_name)\\n@@ -250,3 +263,59 @@ def finish(self):\\n \\\"\\\"\\\"\\n self.writer.end()\\n logger.info(\\\"CometML run closed\\\")\\n+\\n+\\n+LOGGER_TYPE_TO_CLASS = {\\\"tensorboard\\\": TensorBoardTracker, \\\"wandb\\\": WandBTracker, \\\"comet_ml\\\": CometMLTracker}\\n+\\n+\\n+def filter_trackers(\\n+ log_with: List[Union[str, LoggerType, GeneralTracker]], logging_dir: Union[str, os.PathLike] = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Takes in a list of potential tracker types and checks that:\\n+ - The tracker wanted is available in that environment\\n+ - Filters out repeats of tracker types\\n+ - If `all` is in `log_with`, will return all trackers in the environment\\n+ - If a tracker requires a `logging_dir`, ensures that `logging_dir` is not `None`\\n+\\n+ Args:\\n+ log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):\\n+ A list of loggers to be setup for experiment tracking. Should be one or several of:\\n+\\n+ - `\\\"all\\\"`\\n+ - `\\\"tensorboard\\\"`\\n+ - `\\\"wandb\\\"`\\n+ - `\\\"comet_ml\\\"`\\n+ If `\\\"all`\\\" is selected, will pick up all available trackers in the environment and intialize them. Can also\\n+ accept implementations of `GeneralTracker` for custom trackers, and can be combined with `\\\"all\\\"`.\\n+ logging_dir (`str`, `os.PathLike`, *optional*):\\n+ A path to a directory for storing logs of locally-compatible loggers.\\n+ \\\"\\\"\\\"\\n+ loggers = []\\n+ if log_with is not None:\\n+ if not isinstance(log_with, (list, tuple)):\\n+ log_with = [log_with]\\n+ logger.debug(f\\\"{log_with}\\\")\\n+ if \\\"all\\\" in log_with or LoggerType.ALL in log_with:\\n+ loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers()\\n+ else:\\n+ for log_type in log_with:\\n+ if log_type not in LoggerType and not issubclass(type(log_type), GeneralTracker):\\n+ raise ValueError(f\\\"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}\\\")\\n+ if issubclass(type(log_type), GeneralTracker):\\n+ loggers.append(log_type)\\n+ else:\\n+ log_type = LoggerType(log_type)\\n+ if log_type not in loggers:\\n+ if log_type in get_available_trackers():\\n+ tracker_init = LOGGER_TYPE_TO_CLASS[str(log_type)]\\n+ if getattr(tracker_init, \\\"requires_logging_directory\\\"):\\n+ if logging_dir is None:\\n+ raise ValueError(\\n+ f\\\"Logging with `{str(log_type)}` requires a `logging_dir` to be passed in.\\\"\\n+ )\\n+ loggers.append(log_type)\\n+ else:\\n+ logger.info(f\\\"Tried adding logger {log_type}, but package is unavailable in the system.\\\")\\n+\\n+ return loggers\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex b3974afe2..c5b940a46 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -103,6 +103,12 @@ def test_log(self):\\n self.assertEqual(iteration, values[\\\"iteration\\\"])\\n self.assertEqual(my_text, values[\\\"my_text\\\"])\\n \\n+ def test_logging_dir(self):\\n+ with self.assertRaisesRegex(ValueError, \\\"Logging with `tensorboard` requires a `logging_dir`\\\"):\\n+ _ = Accelerator(log_with=\\\"tensorboard\\\")\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ _ = Accelerator(log_with=\\\"tensorboard\\\", logging_dir=dirpath)\\n+\\n \\n @mock.patch.dict(os.environ, {\\\"WANDB_MODE\\\": \\\"offline\\\"})\\n class WandBTrackingTest(TempDirTestCase, MockingTestCase):\\n@@ -237,6 +243,8 @@ class MyCustomTracker(GeneralTracker):\\n \\\"some_string\\\",\\n ]\\n \\n+ requires_logging_directory = False\\n+\\n def __init__(self, dir: str):\\n self.f = open(f\\\"{dir}/log.csv\\\", \\\"w+\\\")\\n self.writer = csv.DictWriter(self.f, fieldnames=self._col_names)\\n\",\n \"code_comments\": [\n {\n \"body\": \"Why not use a class attribute directly? We could set a default then (I don't think this actually defaults to False).\",\n \"diff_hunk\": \"@@ -54,6 +54,14 @@ class GeneralTracker(object, metaclass=ABCMeta):\\n A base Tracker class to be used for all logging integration implementations.\\n \\\"\\\"\\\"\\n \\n+ @abstractproperty\\n+ def requires_logging_directory(self):\\n+ \\\"\\\"\\\"\\n+ Whether the logger requires a directory to store their logs. Should either return `True` or `False`. The\\n+ default behavior is `False`\\n+ \\\"\\\"\\\"\\n+ pass\",\n \"from_author\": false\n },\n {\n \"body\": \"Very nice!\",\n \"diff_hunk\": \"@@ -644,12 +653,13 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n if issubclass(type(tracker), GeneralTracker):\\n # Custom trackers are already initialized\\n self.trackers.append(tracker)\\n- elif str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n- self.trackers.append(TensorBoardTracker(project_name, self.logging_dir))\\n- elif str(tracker).lower() == \\\"wandb\\\" and is_wandb_available():\\n- self.trackers.append(WandBTracker(project_name))\\n- elif str(tracker).lower() == \\\"comet_ml\\\" and is_comet_ml_available():\\n- self.trackers.append(CometMLTracker(project_name))\\n+ else:\",\n \"from_author\": false\n },\n {\n \"body\": \"This won't right. (This is also evidence of me going back and forth with it). Having it like this IMO forces implementations to think about how they want the behavior to go, and have it explicit in the source code for users interested in the code to see. \\r\\n\\r\\nFor example, forcing it to be an abstract property/function, W&B could eventually make it a conditional where if it's in `offline_mode` (by checking the env var), then it would be True, otherwise False.\\r\\n\\r\\nBut, I'm not against just making it a normal class attr directly\",\n \"diff_hunk\": \"@@ -54,6 +54,14 @@ class GeneralTracker(object, metaclass=ABCMeta):\\n A base Tracker class to be used for all logging integration implementations.\\n \\\"\\\"\\\"\\n \\n+ @abstractproperty\\n+ def requires_logging_directory(self):\\n+ \\\"\\\"\\\"\\n+ Whether the logger requires a directory to store their logs. Should either return `True` or `False`. The\\n+ default behavior is `False`\\n+ \\\"\\\"\\\"\\n+ pass\",\n \"from_author\": true\n },\n {\n \"body\": \"In that case, you should remove the default behavior mention in the docstring, as there is no default :-)\",\n \"diff_hunk\": \"@@ -54,6 +54,14 @@ class GeneralTracker(object, metaclass=ABCMeta):\\n A base Tracker class to be used for all logging integration implementations.\\n \\\"\\\"\\\"\\n \\n+ @abstractproperty\\n+ def requires_logging_directory(self):\\n+ \\\"\\\"\\\"\\n+ Whether the logger requires a directory to store their logs. Should either return `True` or `False`. The\\n+ default behavior is `False`\\n+ \\\"\\\"\\\"\\n+ pass\",\n \"from_author\": false\n },\n {\n \"body\": \"Much cleaner!\",\n \"diff_hunk\": \"@@ -132,32 +129,13 @@ def __init__(\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n log_with: Optional[List[Union[str, LoggerType, GeneralTracker]]] = None,\\n- logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\",\\n+ logging_dir: Optional[Union[str, os.PathLike]] = None,\\n dispatch_batches: Optional[bool] = None,\\n step_scheduler_with_optimizer: bool = True,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n- loggers = []\\n- if log_with is not None:\\n- if not isinstance(log_with, (list, tuple)):\\n- log_with = [log_with]\\n- logger.debug(f\\\"{log_with}\\\")\\n- if \\\"all\\\" in log_with or LoggerType.ALL in log_with:\\n- loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers()\\n- else:\\n- for log_type in log_with:\\n- if log_type not in LoggerType and not issubclass(type(log_type), GeneralTracker):\\n- raise ValueError(\\n- f\\\"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}\\\"\\n- )\\n- if issubclass(type(log_type), GeneralTracker):\\n- loggers.append(log_type)\\n- else:\\n- log_type = LoggerType(log_type)\\n- if log_type not in loggers:\\n- loggers.append(log_type)\\n- self.log_with = loggers\\n self.logging_dir = logging_dir\\n+ self.log_with = filter_trackers(log_with, self.logging_dir)\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"@sgugger pinging for a rereview just to make sure the refactor seems sound to you π \",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/316\",\n \"pr_id\": 910332479\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex e18686e12..514b3a4f4 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -440,7 +440,10 @@ def _prepare_deepspeed(self, *args):\\n batch_size_per_device * deepspeed_plugin.gradient_accumulation_steps * self.num_processes\\n )\\n \\n- result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+ result = [\\n+ self._prepare_one(obj, first_pass=True) if isinstance(obj, torch.utils.data.DataLoader) else obj\\n+ for obj in args\\n+ ]\\n \\n model = None\\n optimizer = None\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/315\",\n \"pr_id\": 908519146\n },\n {\n \"diff\": \"diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml\\nindex c213a9167..5020c6cc4 100644\\n--- a/.github/workflows/test.yml\\n+++ b/.github/workflows/test.yml\\n@@ -14,4 +14,17 @@ jobs:\\n - name: Install Python dependencies\\n run: pip install setuptools==59.5.0; pip install -e .[test,test_trackers]\\n - name: Run Tests\\n- run: make test\\n\\\\ No newline at end of file\\n+ run: make test\\n+ \\n+ test_examples:\\n+ runs-on: ubuntu-latest\\n+ steps:\\n+ - uses: actions/checkout@v2\\n+ - name: Set up Python 3.6\\n+ uses: actions/setup-python@v2\\n+ with:\\n+ python-version: 3.6\\n+ - name: Install Python dependencies\\n+ run: pip install setuptools==59.5.0; pip install -e .[test] tensorboard\\n+ - name: Run Tests\\n+ run: make test_examples\\n\\\\ No newline at end of file\\ndiff --git a/Makefile b/Makefile\\nindex e5b557f10..db7893565 100644\\n--- a/Makefile\\n+++ b/Makefile\\n@@ -25,4 +25,7 @@ style:\\n \\t\\n # Run tests for the library\\n test:\\n-\\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/\\n\\\\ No newline at end of file\\n+\\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/ --ignore=./tests/test_examples.py\\n+\\n+test_examples:\\n+\\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/test_examples.py\\ndiff --git a/examples/by_feature/checkpointing.py b/examples/by_feature/checkpointing.py\\nindex 35205107d..e595a8db7 100644\\n--- a/examples/by_feature/checkpointing.py\\n+++ b/examples/by_feature/checkpointing.py\\n@@ -115,14 +115,17 @@ def training_function(config, args):\\n \\n # New Code #\\n # Parse out whether we are saving every epoch or after a certain number of batches\\n- if args.checkpointing_steps == \\\"epoch\\\":\\n- checkpointing_steps = args.checkpointing_steps\\n- elif args.checkpointing_steps.isdigit():\\n- checkpointing_steps = int(args.checkpointing_steps)\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n else:\\n- raise ValueError(\\n- f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n- )\\n+ checkpointing_steps = None\\n \\n set_seed(seed)\\n \\n@@ -162,21 +165,29 @@ def training_function(config, args):\\n \\n # New Code #\\n # We need to keep track of how many total steps we have iterated over\\n- if isinstance(checkpointing_steps, int):\\n- overall_step = 0\\n+ overall_step = 0\\n \\n # We need to load the checkpoint back in before training here with `load_state`\\n # The total number of epochs is adjusted based on where the state is being loaded from,\\n # as we assume continuation of the same training script\\n if args.resume_from_checkpoint:\\n- accelerator.print(f\\\"Resuming from checkpoint: {args.resume_from_checkpoint}\\\")\\n- accelerator.load_state(args.resume_from_checkpoint)\\n-\\n- if \\\"epoch\\\" in args.resume_from_checkpoint:\\n- num_epochs -= int(args.resume_from_checkpoint.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ path = os.path.basename(args.resume_from_checkpoint)\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ # Extract `epoch_{i}` or `step_{i}`\\n+ training_difference = os.path.splitext(path)[0]\\n+\\n+ if \\\"epoch\\\" in training_difference:\\n+ num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n resume_step = None\\n else:\\n- resume_step = int(args.resume_from_checkpoint.replace(\\\"step_\\\", \\\"\\\"))\\n+ resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n num_epochs -= resume_step // len(train_dataloader)\\n # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n@@ -200,6 +211,8 @@ def training_function(config, args):\\n optimizer.step()\\n lr_scheduler.step()\\n optimizer.zero_grad()\\n+ # New Code #\\n+ overall_step += 1\\n \\n # New Code #\\n # We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`\\n@@ -237,7 +250,7 @@ def training_function(config, args):\\n # Will contain files: \\\"pytorch_model.bin\\\", \\\"optimizer.bin\\\", \\\"scheduler.bin\\\", and \\\"random_states.pkl\\\"\\n # If mixed precision was used, will also save a \\\"scalar.bin\\\" file\\n if checkpointing_steps == \\\"epoch\\\":\\n- output_dir = f\\\"epoch_{num_epochs}\\\"\\n+ output_dir = f\\\"epoch_{epoch}\\\"\\n if args.output_dir is not None:\\n output_dir = os.path.join(args.output_dir, output_dir)\\n accelerator.save_state(output_dir)\\n@@ -258,7 +271,7 @@ def main():\\n parser.add_argument(\\n \\\"--checkpointing_steps\\\",\\n type=str,\\n- default=\\\"epoch\\\",\\n+ default=None,\\n help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n )\\n parser.add_argument(\\ndiff --git a/examples/by_feature/tracking.py b/examples/by_feature/tracking.py\\nindex ca11fa04b..170211e5e 100644\\n--- a/examples/by_feature/tracking.py\\n+++ b/examples/by_feature/tracking.py\\n@@ -13,6 +13,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n import argparse\\n+import logging\\n+import os\\n \\n import torch\\n from torch.utils.data import DataLoader\\n@@ -28,6 +30,9 @@\\n )\\n \\n \\n+logger = logging.getLogger(__name__)\\n+\\n+\\n ########################################################################\\n # This is a fully working simple example to use Accelerate,\\n # specifically showcasing the experiment tracking capability,\\n@@ -110,7 +115,9 @@ def training_function(config, args):\\n # Note: If using a custom `Tracker` class, should be passed in here such as:\\n # >>> log_with = [\\\"all\\\", MyCustomTrackerClassInstance()]\\n if args.with_tracking:\\n- accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\", logging_dir=args.logging_dir\\n+ )\\n else:\\n accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n@@ -158,7 +165,10 @@ def training_function(config, args):\\n # New Code #\\n # We need to initalize the trackers we use. Overall configurations can also be stored\\n if args.with_tracking:\\n- accelerator.init_trackers(\\\"accelerate_glue_with_tracking\\\", config)\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.init_trackers(run, config)\\n \\n # Now we train the model\\n for epoch in range(num_epochs):\\n@@ -173,7 +183,8 @@ def training_function(config, args):\\n outputs = model(**batch)\\n loss = outputs.loss\\n # New Code #\\n- total_loss += loss.detach().float()\\n+ if args.with_tracking:\\n+ total_loss += loss.detach().float()\\n loss = loss / gradient_accumulation_steps\\n accelerator.backward(loss)\\n if step % gradient_accumulation_steps == 0:\\n@@ -202,14 +213,21 @@ def training_function(config, args):\\n # New Code #\\n # To actually log, we call `Accelerator.log`\\n # The values passed can be of `str`, `int`, or `float`\\n- accelerator.log(\\n- {\\\"accuracy\\\": eval_metric[\\\"accuracy\\\"], \\\"f1\\\": eval_metric[\\\"f1\\\"], \\\"train_loss\\\": total_loss, \\\"epoch\\\": epoch}\\n- )\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\n+ \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\n+ \\\"f1\\\": eval_metric[\\\"f1\\\"],\\n+ \\\"train_loss\\\": total_loss,\\n+ \\\"epoch\\\": epoch,\\n+ }\\n+ )\\n \\n # New Code #\\n # When a run is finished, you should call `accelerator.end_training()`\\n # to close all of the open trackers\\n- accelerator.end_training()\\n+ if args.with_tracking:\\n+ accelerator.end_training()\\n \\n \\n def main():\\n@@ -229,6 +247,12 @@ def main():\\n action=\\\"store_true\\\",\\n help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--logging_dir\\\",\\n+ type=str,\\n+ default=\\\"logs\\\",\\n+ help=\\\"Location on where to store experiment tracking logs`\\\",\\n+ )\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n training_function(config, args)\\ndiff --git a/examples/complete_cv_example.py b/examples/complete_cv_example.py\\nindex e62568a39..01033498c 100644\\n--- a/examples/complete_cv_example.py\\n+++ b/examples/complete_cv_example.py\\n@@ -74,16 +74,12 @@ def __getitem__(self, idx):\\n def training_function(config, args):\\n # Initialize accelerator\\n if args.with_tracking:\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\", logging_dir=args.logging_dir\\n+ )\\n else:\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n \\n- if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n- checkpointing_steps = args.checkpointing_steps\\n- if args.checkpointing_steps.isdigit():\\n- checkpointing_steps = int(args.checkpointing_steps)\\n- else:\\n- checkpointing_steps = None\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n num_epochs = int(config[\\\"num_epochs\\\"])\\n@@ -93,9 +89,25 @@ def training_function(config, args):\\n if not isinstance(image_size, (list, tuple)):\\n image_size = (image_size, image_size)\\n \\n+ # Parse out whether we are saving every epoch or after a certain number of batches\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+ else:\\n+ checkpointing_steps = None\\n+\\n # We need to initialize the trackers we use, and also store our configuration\\n if args.with_tracking:\\n- accelerator.init_trackers(\\\"cv_example\\\", config)\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.init_trackers(run, config)\\n \\n # Grab all the image filenames\\n file_names = [os.path.join(args.data_dir, fname) for fname in os.listdir(args.data_dir) if fname.endswith(\\\".jpg\\\")]\\n@@ -163,24 +175,27 @@ def training_function(config, args):\\n )\\n \\n # Potentially load in the weights and states from a previous save\\n- state_restored = True\\n if args.resume_from_checkpoint:\\n if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n accelerator.load_state(args.resume_from_checkpoint)\\n- resume_step = None\\n+ path = os.path.basename(args.resume_from_checkpoint)\\n else:\\n # Get the most recent checkpoint\\n dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n dirs.sort(key=os.path.getctime)\\n path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n- if \\\"epoch\\\" in path.name:\\n- num_epochs -= int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n- else:\\n- resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n- num_epochs -= resume_step // len(train_dataloader)\\n- resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n- state_restored = False\\n+ # Extract `epoch_{i}` or `step_{i}`\\n+ training_difference = os.path.splitext(path)[0]\\n+\\n+ if \\\"epoch\\\" in training_difference:\\n+ num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ resume_step = None\\n+ else:\\n+ resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n \\n overall_step = 0\\n # Now we train the model\\n@@ -190,8 +205,9 @@ def training_function(config, args):\\n total_loss = 0\\n for step, batch in enumerate(train_dataloader):\\n # We need to skip steps until we reach the resumed step\\n- if args.resume_from_checkpoint and epoch == 0 and step < resume_step:\\n- continue\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ if resume_step is not None and step < resume_step:\\n+ pass\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n inputs = (batch[\\\"image\\\"] - mean) / std\\n@@ -206,32 +222,40 @@ def training_function(config, args):\\n optimizer.zero_grad()\\n overall_step += 1\\n if isinstance(checkpointing_steps, int):\\n+ output_dir = f\\\"step_{overall_step}\\\"\\n if overall_step % checkpointing_steps == 0:\\n- accelerator.save_state(f\\\"step_{overall_step}\\\")\\n- if state_restored:\\n- model.eval()\\n- accurate = 0\\n- num_elems = 0\\n- for step, batch in enumerate(eval_dataloader):\\n- # We could avoid this line since we set the accelerator with `device_placement=True`.\\n- batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n- inputs = (batch[\\\"image\\\"] - mean) / std\\n- with torch.no_grad():\\n- outputs = model(inputs)\\n- predictions = outputs.argmax(dim=-1)\\n- accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch[\\\"label\\\"])\\n- num_elems += accurate_preds.shape[0]\\n- accurate += accurate_preds.long().sum()\\n-\\n- eval_metric = accurate.item() / num_elems\\n- # Use accelerator.print to print only on the main process.\\n- accelerator.print(f\\\"epoch {epoch}: {100 * eval_metric:.2f}\\\")\\n- if args.with_tracking:\\n- accelerator.log(\\n- {\\\"accuracy\\\": 100 * eval_metric, \\\"total_loss\\\": total_loss, \\\"epoch\\\": epoch}, step=overall_step\\n- )\\n- if args.checkpointing_steps == \\\"epoch\\\":\\n- accelerator.save_state(f\\\"epoch_{epoch}\\\")\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+ model.eval()\\n+ accurate = 0\\n+ num_elems = 0\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n+ inputs = (batch[\\\"image\\\"] - mean) / std\\n+ with torch.no_grad():\\n+ outputs = model(inputs)\\n+ predictions = outputs.argmax(dim=-1)\\n+ accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch[\\\"label\\\"])\\n+ num_elems += accurate_preds.shape[0]\\n+ accurate += accurate_preds.long().sum()\\n+\\n+ eval_metric = accurate.item() / num_elems\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}: {100 * eval_metric:.2f}\\\")\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\\"accuracy\\\": 100 * eval_metric, \\\"total_loss\\\": total_loss, \\\"epoch\\\": epoch}, step=overall_step\\n+ )\\n+ if checkpointing_steps == \\\"epoch\\\":\\n+ output_dir = f\\\"epoch_{epoch}\\\"\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+\\n+ if args.with_tracking:\\n+ accelerator.end_training()\\n \\n \\n def main():\\n@@ -254,6 +278,12 @@ def main():\\n default=None,\\n help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--output_dir\\\",\\n+ type=str,\\n+ default=\\\".\\\",\\n+ help=\\\"Optional save directory where all checkpoint folders will be stored. Default is the current working directory.\\\",\\n+ )\\n parser.add_argument(\\n \\\"--resume_from_checkpoint\\\",\\n type=str,\\n@@ -262,9 +292,15 @@ def main():\\n )\\n parser.add_argument(\\n \\\"--with_tracking\\\",\\n- required=False,\\n+ action=\\\"store_true\\\",\\n help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--logging_dir\\\",\\n+ type=str,\\n+ default=\\\"logs\\\",\\n+ help=\\\"Location on where to store experiment tracking logs`\\\",\\n+ )\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 3e-2, \\\"num_epochs\\\": 3, \\\"seed\\\": 42, \\\"batch_size\\\": 64, \\\"image_size\\\": 224}\\n training_function(config, args)\\ndiff --git a/examples/complete_nlp_example.py b/examples/complete_nlp_example.py\\nindex 57125aa29..a0e8d568c 100644\\n--- a/examples/complete_nlp_example.py\\n+++ b/examples/complete_nlp_example.py\\n@@ -55,14 +55,21 @@\\n def training_function(config, args):\\n # Initialize accelerator\\n if args.with_tracking:\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ accelerator = Accelerator(\\n+ cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\", logging_dir=args.logging_dir\\n+ )\\n else:\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n \\n if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n- checkpointing_steps = args.checkpointing_steps\\n- if args.checkpointing_steps.isdigit():\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n else:\\n checkpointing_steps = None\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n@@ -74,7 +81,10 @@ def training_function(config, args):\\n \\n # We need to initialize the trackers we use, and also store our configuration\\n if args.with_tracking:\\n- accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+ run = os.path.split(__file__)[-1].split(\\\".\\\")[0]\\n+ if args.logging_dir:\\n+ run = os.path.join(args.logging_dir, run)\\n+ accelerator.init_trackers(run, config)\\n \\n tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n@@ -143,27 +153,31 @@ def collate_fn(examples):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n+ overall_step = 0\\n+\\n # Potentially load in the weights and states from a previous save\\n- state_restored = True\\n if args.resume_from_checkpoint:\\n if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n accelerator.load_state(args.resume_from_checkpoint)\\n- resume_step = None\\n+ path = os.path.basename(args.resume_from_checkpoint)\\n else:\\n # Get the most recent checkpoint\\n dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n dirs.sort(key=os.path.getctime)\\n path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n- if \\\"epoch\\\" in path.name:\\n- num_epochs -= int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n- else:\\n- resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n- num_epochs -= resume_step // len(train_dataloader)\\n- resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n- state_restored = False\\n+ # Extract `epoch_{i}` or `step_{i}`\\n+ training_difference = os.path.splitext(path)[0]\\n+\\n+ if \\\"epoch\\\" in training_difference:\\n+ num_epochs -= int(training_difference.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ resume_step = None\\n+ else:\\n+ resume_step = int(training_difference.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n \\n- overall_step = 0\\n # Now we train the model\\n for epoch in range(num_epochs):\\n model.train()\\n@@ -171,8 +185,9 @@ def collate_fn(examples):\\n total_loss = 0\\n for step, batch in enumerate(train_dataloader):\\n # We need to skip steps until we reach the resumed step\\n- if args.resume_from_checkpoint and epoch == 0 and step < resume_step:\\n- continue\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ if resume_step is not None and step < resume_step:\\n+ pass\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch.to(accelerator.device)\\n outputs = model(**batch)\\n@@ -190,42 +205,51 @@ def collate_fn(examples):\\n overall_step += 1\\n \\n if isinstance(checkpointing_steps, int):\\n+ output_dir = f\\\"step_{overall_step}\\\"\\n if overall_step % checkpointing_steps == 0:\\n- accelerator.save_state(f\\\"step_{overall_step}\\\")\\n- if state_restored:\\n- model.eval()\\n- for step, batch in enumerate(eval_dataloader):\\n- # We could avoid this line since we set the accelerator with `device_placement=True`.\\n- batch.to(accelerator.device)\\n- with torch.no_grad():\\n- outputs = model(**batch)\\n- predictions = outputs.logits.argmax(dim=-1)\\n- metric.add_batch(\\n- predictions=accelerator.gather(predictions),\\n- references=accelerator.gather(batch[\\\"labels\\\"]),\\n- )\\n-\\n- eval_metric = metric.compute()\\n- # Use accelerator.print to print only on the main process.\\n- accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n- if args.with_tracking:\\n- accelerator.log(\\n- {\\n- \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\n- \\\"f1\\\": eval_metric[\\\"f1\\\"],\\n- \\\"total_loss\\\": total_loss,\\n- \\\"epoch\\\": epoch,\\n- },\\n- step=overall_step,\\n- )\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ # It is slightly faster to call this once, than multiple times\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\n+ \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\n+ \\\"f1\\\": eval_metric[\\\"f1\\\"],\\n+ \\\"train_loss\\\": total_loss,\\n+ \\\"epoch\\\": epoch,\\n+ }\\n+ )\\n+\\n+ if checkpointing_steps == \\\"epoch\\\":\\n+ output_dir = f\\\"epoch_{epoch}\\\"\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n \\n- if args.checkpointing_steps == \\\"epoch\\\":\\n- accelerator.save_state(f\\\"epoch_{epoch}\\\")\\n+ if args.with_tracking:\\n+ accelerator.end_training()\\n \\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n parser.add_argument(\\n \\\"--mixed_precision\\\",\\n type=str,\\n@@ -250,9 +274,21 @@ def main():\\n )\\n parser.add_argument(\\n \\\"--with_tracking\\\",\\n- required=False,\\n+ action=\\\"store_true\\\",\\n help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--output_dir\\\",\\n+ type=str,\\n+ default=\\\".\\\",\\n+ help=\\\"Optional save directory where all checkpoint folders will be stored. Default is the current working directory.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--logging_dir\\\",\\n+ type=str,\\n+ default=\\\"logs\\\",\\n+ help=\\\"Location on where to store experiment tracking logs`\\\",\\n+ )\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n training_function(config, args)\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex b14b067be..a80b42d13 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -73,7 +73,7 @@ def __getitem__(self, idx):\\n \\n def training_function(config, args):\\n # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mix_precision)\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mix_precision)\\n \\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n@@ -185,7 +185,6 @@ def training_function(config, args):\\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n parser.add_argument(\\\"--data_dir\\\", required=True, help=\\\"The data folder on disk.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n parser.add_argument(\\n \\\"--mixed_precision\\\",\\n type=str,\\n@@ -195,6 +194,12 @@ def main():\\n \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n \\\"and an Nvidia Ampere GPU.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 3e-2, \\\"num_epochs\\\": 3, \\\"seed\\\": 42, \\\"batch_size\\\": 64, \\\"image_size\\\": 224}\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 915d35807..87cfd7698 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -49,21 +49,19 @@\\n EVAL_BATCH_SIZE = 32\\n \\n \\n-def training_function(config, args):\\n- # Initialize accelerator\\n- accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n- # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n- lr = config[\\\"lr\\\"]\\n- num_epochs = int(config[\\\"num_epochs\\\"])\\n- correct_bias = config[\\\"correct_bias\\\"]\\n- seed = int(config[\\\"seed\\\"])\\n- batch_size = int(config[\\\"batch_size\\\"])\\n-\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n- metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n-\\n- set_seed(seed)\\n \\n def tokenize_function(examples):\\n # max_length=None => use the model max length (it's actually the default)\\n@@ -81,12 +79,6 @@ def tokenize_function(examples):\\n # transformers library\\n tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n \\n- # If the batch size is too big we use gradient accumulation\\n- gradient_accumulation_steps = 1\\n- if batch_size > MAX_GPU_BATCH_SIZE:\\n- gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n- batch_size = MAX_GPU_BATCH_SIZE\\n-\\n def collate_fn(examples):\\n # On TPU it's best to pad everything to the same length or training will be very slow.\\n if accelerator.distributed_type == DistributedType.TPU:\\n@@ -101,6 +93,29 @@ def collate_fn(examples):\\n tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n )\\n \\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ set_seed(seed)\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n \\n@@ -148,9 +163,10 @@ def collate_fn(examples):\\n with torch.no_grad():\\n outputs = model(**batch)\\n predictions = outputs.logits.argmax(dim=-1)\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n metric.add_batch(\\n- predictions=accelerator.gather(predictions),\\n- references=accelerator.gather(batch[\\\"labels\\\"]),\\n+ predictions=predictions,\\n+ references=references,\\n )\\n \\n eval_metric = metric.compute()\\ndiff --git a/setup.py b/setup.py\\nindex 0ce1e5af4..7e26759d1 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -20,7 +20,12 @@\\n extras[\\\"docs\\\"] = []\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n- \\\"pytest-xdist\\\"\\n+ \\\"pytest-xdist\\\",\\n+ \\\"pytest-subtests\\\",\\n+ \\\"datasets\\\",\\n+ \\\"transformers\\\",\\n+ \\\"scipy\\\",\\n+ \\\"sklearn\\\"\\n ]\\n extras[\\\"test_trackers\\\"] = [\\\"wandb\\\", \\\"comet-ml\\\", \\\"tensorflow\\\"]\\n extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\ndiff --git a/src/accelerate/test_utils/examples.py b/src/accelerate/test_utils/examples.py\\nnew file mode 100644\\nindex 000000000..4e4092c0e\\n--- /dev/null\\n+++ b/src/accelerate/test_utils/examples.py\\n@@ -0,0 +1,139 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\\"\\\"\\\"\\n+A collection of utilities for comparing `examples/complete_*_example.py` scripts with the capabilities inside of each\\n+`examples/by_feature` example. `compare_against_test` is the main function that should be used when testing, while the\\n+others are used to either get the code that matters, or to preprocess them (such as stripping comments)\\n+\\\"\\\"\\\"\\n+\\n+import os\\n+from typing import List\\n+\\n+\\n+def get_function_contents_by_name(lines: List[str], name: str):\\n+ \\\"\\\"\\\"\\n+ Extracts a function from `lines` of segmented source code with the name `name`.\\n+\\n+ Args:\\n+ lines (`List[str]`):\\n+ Source code of a script seperated by line.\\n+ name (`str`):\\n+ The name of the function to extract. Should be either `training_function` or `main`\\n+ \\\"\\\"\\\"\\n+ if name != \\\"training_function\\\" and name != \\\"main\\\":\\n+ raise ValueError(f\\\"Incorrect function name passed: {name}, choose either 'main' or 'training_function'\\\")\\n+ good_lines, found_start = [], False\\n+ for line in lines:\\n+ if not found_start and f\\\"def {name}\\\" in line:\\n+ found_start = True\\n+ good_lines.append(line)\\n+ continue\\n+ if found_start:\\n+ if name == \\\"training_function\\\" and \\\"def main\\\" in line:\\n+ return good_lines\\n+ if name == \\\"main\\\" and \\\"if __name__\\\" in line:\\n+ return good_lines\\n+ good_lines.append(line)\\n+\\n+\\n+def clean_lines(lines: List[str]):\\n+ \\\"\\\"\\\"\\n+ Filters `lines` and removes any entries that start with a comment ('#') or is just a newline ('\\\\n')\\n+\\n+ Args:\\n+ lines (`List[str]`):\\n+ Source code of a script seperated by line.\\n+ \\\"\\\"\\\"\\n+ return [line for line in lines if not line.lstrip().startswith(\\\"#\\\") and line != \\\"\\\\n\\\"]\\n+\\n+\\n+def compare_against_test(base_filename: str, feature_filename: str, parser_only: bool, secondary_filename: str = None):\\n+ \\\"\\\"\\\"\\n+ Tests whether the additional code inside of `feature_filename` was implemented in `base_filename`. This should be\\n+ used when testing to see if `complete_*_.py` examples have all of the implementations from each of the\\n+ `examples/by_feature/*` scripts.\\n+\\n+ It utilizes `nlp_example.py` to extract out all of the repeated training code, so that only the new additional code\\n+ is examined and checked. If something *other* than `nlp_example.py` should be used, such as `cv_example.py` for the\\n+ `complete_cv_example.py` script, it should be passed in for the `secondary_filename` parameter.\\n+\\n+ Args:\\n+ base_filename (`str` or `os.PathLike`):\\n+ The filepath of a single \\\"complete\\\" example script to test, such as `examples/complete_cv_example.py`\\n+ feature_filename (`str` or `os.PathLike`):\\n+ The filepath of a single feature example script. The contents of this script are checked to see if they\\n+ exist in `base_filename`\\n+ parser_only (`bool`):\\n+ Whether to compare only the `main()` sections in both files, or to compare the contents of\\n+ `training_loop()`\\n+ secondary_filename (`str`, *optional*):\\n+ A potential secondary filepath that should be included in the check. This function extracts the base\\n+ functionalities off of \\\"examples/nlp_example.py\\\", so if `base_filename` is a script other than\\n+ `complete_nlp_example.py`, the template script should be included here. Such as `examples/cv_example.py`\\n+ \\\"\\\"\\\"\\n+ with open(base_filename, \\\"r\\\") as f:\\n+ base_file_contents = f.readlines()\\n+ with open(os.path.abspath(os.path.join(\\\"examples\\\", \\\"nlp_example.py\\\")), \\\"r\\\") as f:\\n+ full_file_contents = f.readlines()\\n+ with open(feature_filename, \\\"r\\\") as f:\\n+ feature_file_contents = f.readlines()\\n+ if secondary_filename is not None:\\n+ with open(secondary_filename, \\\"r\\\") as f:\\n+ secondary_file_contents = f.readlines()\\n+\\n+ # This is our base, we remove all the code from here in our `full_filename` and `feature_filename` to find the new content\\n+ if parser_only:\\n+ base_file_func = clean_lines(get_function_contents_by_name(base_file_contents, \\\"main\\\"))\\n+ full_file_func = clean_lines(get_function_contents_by_name(full_file_contents, \\\"main\\\"))\\n+ feature_file_func = clean_lines(get_function_contents_by_name(feature_file_contents, \\\"main\\\"))\\n+ if secondary_filename is not None:\\n+ secondary_file_func = clean_lines(get_function_contents_by_name(secondary_file_contents, \\\"main\\\"))\\n+ else:\\n+ base_file_func = clean_lines(get_function_contents_by_name(base_file_contents, \\\"training_function\\\"))\\n+ full_file_func = clean_lines(get_function_contents_by_name(full_file_contents, \\\"training_function\\\"))\\n+ feature_file_func = clean_lines(get_function_contents_by_name(feature_file_contents, \\\"training_function\\\"))\\n+ if secondary_filename is not None:\\n+ secondary_file_func = clean_lines(\\n+ get_function_contents_by_name(secondary_file_contents, \\\"training_function\\\")\\n+ )\\n+\\n+ _dl_line = \\\"train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\\\n\\\"\\n+\\n+ # Specific code in our script that differs from the full version, aka what is new\\n+ new_feature_code = []\\n+ passed_idxs = [] # We keep track of the idxs just in case it's a repeated statement\\n+ for i, line in enumerate(feature_file_func):\\n+ if i not in passed_idxs:\\n+ if (line not in full_file_func) and (line.lstrip() != _dl_line):\\n+ new_feature_code.append(line)\\n+ passed_idxs.append(i)\\n+\\n+ # Extract out just the new parts from the full_file_training_func\\n+ new_full_example_parts = []\\n+ passed_idxs = [] # We keep track of the idxs just in case it's a repeated statement\\n+ for i, line in enumerate(base_file_func):\\n+ if i not in passed_idxs:\\n+ if (line not in full_file_func) and (line.lstrip() != _dl_line):\\n+ new_full_example_parts.append(line)\\n+ passed_idxs.append(i)\\n+\\n+ # Finally, get the overall diff\\n+ diff_from_example = [line for line in new_feature_code if line not in new_full_example_parts]\\n+ if secondary_filename is not None:\\n+ diff_from_two = [line for line in full_file_contents if line not in secondary_file_func]\\n+ diff_from_example = [line for line in diff_from_example if line not in diff_from_two]\\n+\\n+ return diff_from_example\\ndiff --git a/tests/test_examples.py b/tests/test_examples.py\\nnew file mode 100644\\nindex 000000000..d60d7c08f\\n--- /dev/null\\n+++ b/tests/test_examples.py\\n@@ -0,0 +1,190 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import sys\\n+import tempfile\\n+import unittest\\n+from unittest import mock\\n+\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import DistributedType\\n+from accelerate.test_utils.examples import compare_against_test\\n+from datasets import load_dataset\\n+from transformers import AutoTokenizer\\n+\\n+\\n+SRC_DIRS = [os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))]\\n+sys.path.extend(SRC_DIRS)\\n+\\n+if SRC_DIRS is not None:\\n+ import checkpointing\\n+ import tracking\\n+\\n+# DataLoaders built from `test_samples/MRPC` for quick testing\\n+# Should mock `{script_name}.get_dataloaders` via:\\n+# @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n+\\n+\\n+def mocked_dataloaders(accelerator, batch_size: int = 16):\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ data_files = {\\\"train\\\": \\\"tests/test_samples/MRPC/train.csv\\\", \\\"validation\\\": \\\"tests/test_samples/MRPC/dev.csv\\\"}\\n+ datasets = load_dataset(\\\"csv\\\", data_files=data_files)\\n+ label_list = datasets[\\\"train\\\"].unique(\\\"label\\\")\\n+\\n+ label_to_id = {v: i for i, v in enumerate(label_list)}\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(\\n+ examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None, padding=\\\"max_length\\\"\\n+ )\\n+ if \\\"label\\\" in examples:\\n+ outputs[\\\"labels\\\"] = [label_to_id[l] for l in examples[\\\"label\\\"]]\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"sentence1\\\", \\\"sentence2\\\", \\\"label\\\"],\\n+ )\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=2)\\n+ eval_dataloader = DataLoader(tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=1)\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+class ExampleDifferenceTests(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ This TestCase checks that all of the `complete_*` scripts contain all of the\\n+ information found in the `by_feature` scripts, line for line. If one fails,\\n+ then a complete example does not contain all of the features in the features\\n+ scripts, and should be updated.\\n+\\n+ Each example script should be a single test (such as `test_nlp_example`),\\n+ and should run `one_complete_example` twice: once with `parser_only=True`,\\n+ and the other with `parser_only=False`. This is so that when the test\\n+ failures are returned to the user, they understand if the discrepancy lies in\\n+ the `main` function, or the `training_loop` function. Otherwise it will be\\n+ unclear.\\n+\\n+ Also, if there are any expected differences between the base script used and\\n+ `complete_nlp_example.py` (the canonical base script), these should be included in\\n+ `special_strings`. These would be differences in how something is logged, print statements,\\n+ etc (such as calls to `Accelerate.log()`)\\n+ \\\"\\\"\\\"\\n+\\n+ def one_complete_example(\\n+ self, complete_file_name: str, parser_only: bool, secondary_filename: str = None, special_strings: list = None\\n+ ):\\n+ \\\"\\\"\\\"\\n+ Tests a single `complete` example against all of the implemented `by_feature` scripts\\n+\\n+ Args:\\n+ complete_file_name (`str`):\\n+ The filename of a complete example\\n+ parser_only (`bool`):\\n+ Whether to look at the main training function, or the argument parser\\n+ secondary_filename (`str`, *optional*):\\n+ A potential secondary base file to strip all script information not relevant for checking,\\n+ such as \\\"cv_example.py\\\" when testing \\\"complete_cv_example.py\\\"\\n+ special_strings (`list`, *optional*):\\n+ A list of strings to potentially remove before checking no differences are left. These should be\\n+ diffs that are file specific, such as different logging variations between files.\\n+ \\\"\\\"\\\"\\n+ self.maxDiff = None\\n+ by_feature_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))\\n+ examples_path = os.path.abspath(\\\"examples\\\")\\n+ for item in os.listdir(by_feature_path):\\n+ item_path = os.path.join(by_feature_path, item)\\n+ if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\n+ with self.subTest(\\n+ tested_script=complete_file_name,\\n+ feature_script=item,\\n+ tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\",\\n+ ):\\n+ diff = compare_against_test(\\n+ os.path.join(examples_path, complete_file_name), item_path, parser_only, secondary_filename\\n+ )\\n+ diff = \\\"\\\\n\\\".join(diff)\\n+ if special_strings is not None:\\n+ for string in special_strings:\\n+ diff = diff.replace(string, \\\"\\\")\\n+ self.assertEqual(diff, \\\"\\\")\\n+\\n+ def test_nlp_examples(self):\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", True)\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", False)\\n+\\n+ def test_cv_examples(self):\\n+ cv_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"cv_example.py\\\"))\\n+ special_strings = [\\n+ \\\" \\\" * 16 + \\\"{\\\\n\\\\n\\\",\\n+ \\\" \\\" * 18 + '\\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\\\n\\\\n',\\n+ \\\" \\\" * 18 + '\\\"f1\\\": eval_metric[\\\"f1\\\"],\\\\n\\\\n',\\n+ \\\" \\\" * 18 + '\\\"train_loss\\\": total_loss,\\\\n\\\\n',\\n+ \\\" \\\" * 18 + '\\\"epoch\\\": epoch,\\\\n\\\\n',\\n+ \\\" \\\" * 16 + \\\"}\\\\n\\\",\\n+ \\\" \\\" * 8,\\n+ ]\\n+ self.one_complete_example(\\\"complete_cv_example.py\\\", True, cv_path, special_strings)\\n+ self.one_complete_example(\\\"complete_cv_example.py\\\", False, cv_path, special_strings)\\n+\\n+\\n+class FeatureExamplesTests(unittest.TestCase):\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_epoch(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps epoch\\n+ --output_dir {tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"epoch_0\\\")))\\n+\\n+ @mock.patch(\\\"checkpointing.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_checkpointing_by_steps(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ testargs = f\\\"\\\"\\\"\\n+ checkpointing.py\\n+ --checkpointing_steps 2\\n+ --output_dir {tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ checkpointing.main()\\n+ self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"step_2\\\")))\\n+\\n+ @mock.patch(\\\"tracking.get_dataloaders\\\", mocked_dataloaders)\\n+ def test_tracking(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ testargs = f\\\"\\\"\\\"\\n+ tracking.py\\n+ --with_tracking\\n+ --logging_dir {tmpdir}\\n+ \\\"\\\"\\\".split()\\n+ with mock.patch.object(sys, \\\"argv\\\", testargs):\\n+ tracking.main()\\n+ self.assertTrue(os.path.exists(os.path.join(tmpdir, \\\"tracking\\\")))\\ndiff --git a/tests/test_samples/MRPC/dev.csv b/tests/test_samples/MRPC/dev.csv\\nnew file mode 100644\\nindex 000000000..96beccda9\\n--- /dev/null\\n+++ b/tests/test_samples/MRPC/dev.csv\\n@@ -0,0 +1,7 @@\\n+label,sentence1,sentence2\\n+equivalent,He said the foodservice pie business doesn 't fit the company 's long-term growth strategy .,\\\"\\\"\\\" The foodservice pie business does not fit our long-term growth strategy .\\\"\\n+not_equivalent,Magnarelli said Racicot hated the Iraqi regime and looked forward to using his long years of training in the war .,\\\"His wife said he was \\\"\\\" 100 percent behind George Bush \\\"\\\" and looked forward to using his years of training in the war .\\\"\\n+not_equivalent,\\\"The dollar was at 116.92 yen against the yen , flat on the session , and at 1.2891 against the Swiss franc , also flat .\\\",\\\"The dollar was at 116.78 yen JPY = , virtually flat on the session , and at 1.2871 against the Swiss franc CHF = , down 0.1 percent .\\\"\\n+equivalent,The AFL-CIO is waiting until October to decide if it will endorse a candidate .,The AFL-CIO announced Wednesday that it will decide in October whether to endorse a candidate before the primaries .\\n+not_equivalent,No dates have been set for the civil or the criminal trial .,\\\"No dates have been set for the criminal or civil cases , but Shanley has pleaded not guilty .\\\"\\n+equivalent,Wal-Mart said it would check all of its million-plus domestic workers to ensure they were legally employed .,It has also said it would review all of its domestic employees more than 1 million to ensure they have legal status .\\ndiff --git a/tests/test_samples/MRPC/train.csv b/tests/test_samples/MRPC/train.csv\\nnew file mode 100644\\nindex 000000000..96beccda9\\n--- /dev/null\\n+++ b/tests/test_samples/MRPC/train.csv\\n@@ -0,0 +1,7 @@\\n+label,sentence1,sentence2\\n+equivalent,He said the foodservice pie business doesn 't fit the company 's long-term growth strategy .,\\\"\\\"\\\" The foodservice pie business does not fit our long-term growth strategy .\\\"\\n+not_equivalent,Magnarelli said Racicot hated the Iraqi regime and looked forward to using his long years of training in the war .,\\\"His wife said he was \\\"\\\" 100 percent behind George Bush \\\"\\\" and looked forward to using his years of training in the war .\\\"\\n+not_equivalent,\\\"The dollar was at 116.92 yen against the yen , flat on the session , and at 1.2891 against the Swiss franc , also flat .\\\",\\\"The dollar was at 116.78 yen JPY = , virtually flat on the session , and at 1.2871 against the Swiss franc CHF = , down 0.1 percent .\\\"\\n+equivalent,The AFL-CIO is waiting until October to decide if it will endorse a candidate .,The AFL-CIO announced Wednesday that it will decide in October whether to endorse a candidate before the primaries .\\n+not_equivalent,No dates have been set for the civil or the criminal trial .,\\\"No dates have been set for the criminal or civil cases , but Shanley has pleaded not guilty .\\\"\\n+equivalent,Wal-Mart said it would check all of its million-plus domestic workers to ensure they were legally employed .,It has also said it would review all of its domestic employees more than 1 million to ensure they have legal status .\\n\",\n \"code_comments\": [\n {\n \"body\": \"Why not always do this?\",\n \"diff_hunk\": \"@@ -200,6 +200,8 @@ def training_function(config, args):\\n optimizer.step()\\n lr_scheduler.step()\\n optimizer.zero_grad()\\n+ if isinstance(checkpointing_steps, int):\\n+ overall_step += 1\",\n \"from_author\": false\n },\n {\n \"body\": \"It's only needed if we save via checkpointing steps rather than epoch, so didn't want people to assume we *always* need to do that. \\r\\n\\r\\n(Which means a comment is needed!)\",\n \"diff_hunk\": \"@@ -200,6 +200,8 @@ def training_function(config, args):\\n optimizer.step()\\n lr_scheduler.step()\\n optimizer.zero_grad()\\n+ if isinstance(checkpointing_steps, int):\\n+ overall_step += 1\",\n \"from_author\": true\n },\n {\n \"body\": \"Yeah I get the variable won't be used if we don't checkpoint with steps, but it doesn't hurt to always have it (and would save one line of code).\",\n \"diff_hunk\": \"@@ -200,6 +200,8 @@ def training_function(config, args):\\n optimizer.step()\\n lr_scheduler.step()\\n optimizer.zero_grad()\\n+ if isinstance(checkpointing_steps, int):\\n+ overall_step += 1\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n# Copyright 2022 The HuggingFace Team. All rights reserved.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,132 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\",\n \"from_author\": false\n },\n {\n \"body\": \"A quick intro here would be useful.\",\n \"diff_hunk\": \"@@ -0,0 +1,132 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\ndef get_train_func(lines: list):\\r\\n```\\r\\nIf we use type annotations, better use `List[str]` here.\",\n \"diff_hunk\": \"@@ -0,0 +1,132 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\n+import logging\\n+import os\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_train_func(lines: list):\",\n \"from_author\": false\n },\n {\n \"body\": \"Sounds like it could be refactored with the previous one and an extra arg?\",\n \"diff_hunk\": \"@@ -0,0 +1,132 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\n+import logging\\n+import os\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_train_func(lines: list):\\n+ \\\"\\\"\\\"\\n+ Finds the main training function from inside segmented source code.\\n+\\n+ Args:\\n+ lines (`list`):\\n+ Source code of a script\\n+ \\\"\\\"\\\"\\n+ good_lines, found_start = [], False\\n+ for line in lines:\\n+ if not found_start and \\\"def training_function\\\" in line:\\n+ found_start = True\\n+ good_lines.append(line)\\n+ continue\\n+ if found_start:\\n+ if \\\"def main\\\" in line:\\n+ return good_lines\\n+ good_lines.append(line)\\n+\\n+\\n+def get_main_func(lines: list):\",\n \"from_author\": false\n },\n {\n \"body\": \"Those do not match the signature. Also this could be expanded a little bit, I'm not sure I fully understand.\",\n \"diff_hunk\": \"@@ -0,0 +1,132 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+\\n+import logging\\n+import os\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_train_func(lines: list):\\n+ \\\"\\\"\\\"\\n+ Finds the main training function from inside segmented source code.\\n+\\n+ Args:\\n+ lines (`list`):\\n+ Source code of a script\\n+ \\\"\\\"\\\"\\n+ good_lines, found_start = [], False\\n+ for line in lines:\\n+ if not found_start and \\\"def training_function\\\" in line:\\n+ found_start = True\\n+ good_lines.append(line)\\n+ continue\\n+ if found_start:\\n+ if \\\"def main\\\" in line:\\n+ return good_lines\\n+ good_lines.append(line)\\n+\\n+\\n+def get_main_func(lines: list):\\n+ \\\"\\\"\\\"\\n+ Finds the main function from inside segmented source code\\n+\\n+ Args:\\n+ lines (`list`):\\n+ Source code of a script\\n+ \\\"\\\"\\\"\\n+ good_lines, found_start = [], False\\n+ for line in lines:\\n+ if not found_start and \\\"def main\\\" in line:\\n+ found_start = True\\n+ good_lines.append(line)\\n+ continue\\n+ if found_start:\\n+ if \\\"if __name__\\\" in line:\\n+ return good_lines\\n+ good_lines.append(line)\\n+\\n+\\n+def clean_lines(lines: list):\\n+ \\\"\\\"\\\"\\n+ Filters `lines` and removes any entries that start with a comment ('#') or is just a newline ('\\\\n')\\n+\\n+ Args:\\n+ lines (`list`):\\n+ Source code of a script\\n+ \\\"\\\"\\\"\\n+ return [line for line in lines if not line.lstrip().startswith(\\\"#\\\") and line != \\\"\\\\n\\\"]\\n+\\n+\\n+def compare_against_test(base_filename: str, feature_filename: str, parser_only: bool, secondary_filename: str = None):\\n+ \\\"\\\"\\\"\\n+ Checks whether the content aligned in `test_filename` is included inside of `full_filename`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n# Copyright 2022 The HuggingFace Team. All rights reserved.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,176 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\",\n \"from_author\": false\n },\n {\n \"body\": \"It seems we always use the method with both flags, should we just remove that arg and put the two tests inside?\",\n \"diff_hunk\": \"@@ -0,0 +1,176 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import sys\\n+import tempfile\\n+import unittest\\n+from unittest import mock\\n+\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import DistributedType\\n+from accelerate.test_utils.examples import compare_against_test\\n+from datasets import load_dataset\\n+from transformers import AutoTokenizer\\n+\\n+\\n+SRC_DIRS = [os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))]\\n+sys.path.extend(SRC_DIRS)\\n+\\n+if SRC_DIRS is not None:\\n+ import checkpointing\\n+ import tracking\\n+\\n+# DataLoaders built from `test_samples/MRPC` for quick testing\\n+# Should mock `{script_name}.get_dataloaders` via:\\n+# @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n+\\n+\\n+def mocked_dataloaders(accelerator, batch_size: int = 16):\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ data_files = {\\\"train\\\": \\\"tests/test_samples/MRPC/train.csv\\\", \\\"validation\\\": \\\"tests/test_samples/MRPC/dev.csv\\\"}\\n+ datasets = load_dataset(\\\"csv\\\", data_files=data_files)\\n+ label_list = datasets[\\\"train\\\"].unique(\\\"label\\\")\\n+\\n+ label_to_id = {v: i for i, v in enumerate(label_list)}\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(\\n+ examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None, padding=\\\"max_length\\\"\\n+ )\\n+ if \\\"label\\\" in examples:\\n+ outputs[\\\"labels\\\"] = [label_to_id[l] for l in examples[\\\"label\\\"]]\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"sentence1\\\", \\\"sentence2\\\", \\\"label\\\"],\\n+ )\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=2)\\n+ eval_dataloader = DataLoader(tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=1)\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+class ExampleDifferenceTests(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ This TestCase checks that all of the `complete_*` scripts contain all of the\\n+ information found in the `by_feature` scripts, line for line.\\n+ \\\"\\\"\\\"\\n+\\n+ def one_complete_example(\\n+ self, complete_file_name: str, parser_only: bool, secondary_filename: str = None, special_strings: list = None\\n+ ):\\n+ \\\"\\\"\\\"\\n+ Tests a single `complete` example against all of the implemented `by_feature` scripts\\n+\\n+ Args:\\n+ complete_file_name (`str`):\\n+ The filename of a complete example\\n+ parser_only (`bool`):\\n+ Whether to look at the main training function, or the argument parser\\n+ secondary_filename (`str`, *optional*):\\n+ A potential secondary base file to strip all script information not relevant for checking,\\n+ such as \\\"cv_example.py\\\" when testing \\\"complete_cv_example.py\\\"\\n+ special_strings (`list`, *optional*):\\n+ A list of strings to potentially remove before checking no differences are left. These should be\\n+ diffs that are file specific, such as different logging variations between files.\\n+ \\\"\\\"\\\"\\n+ self.maxDiff = None\\n+ by_feature_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))\\n+ examples_path = os.path.abspath(\\\"examples\\\")\\n+ for item in os.listdir(by_feature_path):\\n+ item_path = os.path.join(by_feature_path, item)\\n+ if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\n+ with self.subTest(\\n+ tested_script=complete_file_name,\\n+ feature_script=item,\\n+ tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\",\\n+ ):\\n+ diff = compare_against_test(\\n+ os.path.join(examples_path, complete_file_name), item_path, parser_only, secondary_filename\\n+ )\\n+ diff = \\\"\\\\n\\\".join(diff)\\n+ if special_strings is not None:\\n+ for string in special_strings:\\n+ diff = diff.replace(string, \\\"\\\")\\n+ self.assertEqual(diff, \\\"\\\")\\n+\\n+ def test_nlp_examples(self):\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", True)\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", False)\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"I'm making a note for this inside of the documentation, but the reasoning for separation is it lets the test failure be more readable as to what section failed, rather than one complete error.\\r\\nNotice the `tested_section` part\\r\\nE.g.:\\r\\n\\r\\n```bash\\r\\n_________ ExampleDifferenceTests.test_cv_example (feature_script='tracking.py', tested_script='complete_cv_example.py', tested_section='training_function()') _________\\r\\n```\\r\\nvs:\\r\\n```bash\\r\\n_________ ExampleDifferenceTests.test_cv_example (feature_script='tracking.py', tested_script='complete_cv_example.py', tested_section='main()') _________\\r\\n```\\r\\n\\r\\n(This is a `pytest-subtest` hack)\",\n \"diff_hunk\": \"@@ -0,0 +1,176 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import sys\\n+import tempfile\\n+import unittest\\n+from unittest import mock\\n+\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import DistributedType\\n+from accelerate.test_utils.examples import compare_against_test\\n+from datasets import load_dataset\\n+from transformers import AutoTokenizer\\n+\\n+\\n+SRC_DIRS = [os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))]\\n+sys.path.extend(SRC_DIRS)\\n+\\n+if SRC_DIRS is not None:\\n+ import checkpointing\\n+ import tracking\\n+\\n+# DataLoaders built from `test_samples/MRPC` for quick testing\\n+# Should mock `{script_name}.get_dataloaders` via:\\n+# @mock.patch(\\\"{script_name}.get_dataloaders\\\", mocked_dataloaders)\\n+\\n+\\n+def mocked_dataloaders(accelerator, batch_size: int = 16):\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ data_files = {\\\"train\\\": \\\"tests/test_samples/MRPC/train.csv\\\", \\\"validation\\\": \\\"tests/test_samples/MRPC/dev.csv\\\"}\\n+ datasets = load_dataset(\\\"csv\\\", data_files=data_files)\\n+ label_list = datasets[\\\"train\\\"].unique(\\\"label\\\")\\n+\\n+ label_to_id = {v: i for i, v in enumerate(label_list)}\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(\\n+ examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None, padding=\\\"max_length\\\"\\n+ )\\n+ if \\\"label\\\" in examples:\\n+ outputs[\\\"labels\\\"] = [label_to_id[l] for l in examples[\\\"label\\\"]]\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"sentence1\\\", \\\"sentence2\\\", \\\"label\\\"],\\n+ )\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=2)\\n+ eval_dataloader = DataLoader(tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=1)\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+class ExampleDifferenceTests(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ This TestCase checks that all of the `complete_*` scripts contain all of the\\n+ information found in the `by_feature` scripts, line for line.\\n+ \\\"\\\"\\\"\\n+\\n+ def one_complete_example(\\n+ self, complete_file_name: str, parser_only: bool, secondary_filename: str = None, special_strings: list = None\\n+ ):\\n+ \\\"\\\"\\\"\\n+ Tests a single `complete` example against all of the implemented `by_feature` scripts\\n+\\n+ Args:\\n+ complete_file_name (`str`):\\n+ The filename of a complete example\\n+ parser_only (`bool`):\\n+ Whether to look at the main training function, or the argument parser\\n+ secondary_filename (`str`, *optional*):\\n+ A potential secondary base file to strip all script information not relevant for checking,\\n+ such as \\\"cv_example.py\\\" when testing \\\"complete_cv_example.py\\\"\\n+ special_strings (`list`, *optional*):\\n+ A list of strings to potentially remove before checking no differences are left. These should be\\n+ diffs that are file specific, such as different logging variations between files.\\n+ \\\"\\\"\\\"\\n+ self.maxDiff = None\\n+ by_feature_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))\\n+ examples_path = os.path.abspath(\\\"examples\\\")\\n+ for item in os.listdir(by_feature_path):\\n+ item_path = os.path.join(by_feature_path, item)\\n+ if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\n+ with self.subTest(\\n+ tested_script=complete_file_name,\\n+ feature_script=item,\\n+ tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\",\\n+ ):\\n+ diff = compare_against_test(\\n+ os.path.join(examples_path, complete_file_name), item_path, parser_only, secondary_filename\\n+ )\\n+ diff = \\\"\\\\n\\\".join(diff)\\n+ if special_strings is not None:\\n+ for string in special_strings:\\n+ diff = diff.replace(string, \\\"\\\")\\n+ self.assertEqual(diff, \\\"\\\")\\n+\\n+ def test_nlp_examples(self):\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", True)\\n+ self.one_complete_example(\\\"complete_nlp_example.py\\\", False)\\n+\",\n \"from_author\": true\n },\n {\n \"body\": \"Should go inside triple quotes.\",\n \"diff_hunk\": \"@@ -0,0 +1,143 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# A collection of utilities for comparing `examples/complete_*_example.py` scripts with the capabilities inside of each\\n+# `examples/by_feature` example. `compare_against_test` is the main function that should be used when testing,\\n+# while the others are used to either get the code that matters, or to preprocess them (such as stripping comments)\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"I've come up with a solution to make sure that also the main `complete_` examples will raise an error if they differ from the bits inside of `by_feature`. Now eventually it would be good to have an exclusion list of files for when we *wouldn't* expect to see some feature added (such as say cross validation). But we'll cross that bridge when we get there. In the meantime here is the report generated back to the user from pytest:\\r\\n\\r\\n(Note: `pytest-subtests` was added as a dep to make sure we could use `TestCase.subTest` and make this code clean and efficient)\\r\\n```bash\\r\\n======================================================================= short test summary info =======================================================================\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_cv_example_body - AssertionError: 14 != 0\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_cv_example_body - AssertionError: 27 != 0\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_cv_example_parser - AssertionError: 1 != 0\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_cv_example_parser - AssertionError: 4 != 0\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_nlp_example_parser - AssertionError: 1 != 0\\r\\nSUBFAIL tests/test_examples.py::ExampleDifferenceTests::test_complete_nlp_example_parser - AssertionError: 1 != 0\\r\\n=============================================================== 6 failed, 4 passed, 1 warning in 1.64s ================================================================\\r\\n```\\r\\n\\r\\n{{ Removed full trace, see the following message for an example }} \",\n \"from_author\": true\n },\n {\n \"body\": \"Slightly tweaked how they look, I've now included it posting the source code diffs. I believe this is a must as it will tell the user exactly what parts were missing from the full example:\\r\\n\\r\\n```bash\\r\\n============================================================================== FAILURES ===============================================================================\\r\\n_________ ExampleDifferenceTests.test_cv_example (feature_script='tracking.py', tested_script='complete_cv_example.py', tested_section='training_function()') _________\\r\\n\\r\\nself = <test_examples.ExampleDifferenceTests testMethod=test_cv_example>, complete_file_name = 'complete_cv_example.py', parser_only = False\\r\\n\\r\\n def one_complete_example(self, complete_file_name: str, parser_only: bool):\\r\\n \\\"\\\"\\\"\\r\\n Tests a single `complete` example against all of the implemented `by_feature` scripts\\r\\n \\r\\n Args:\\r\\n complete_file_name (`str`):\\r\\n The filename of a complete example\\r\\n parser_only (`bool`):\\r\\n Whether to look at the main training function, or the argument parser\\r\\n \\\"\\\"\\\"\\r\\n self.maxDiff = None\\r\\n by_feature_path = os.path.abspath(os.path.join(\\\"examples\\\", \\\"by_feature\\\"))\\r\\n examples_path = os.path.abspath(\\\"examples\\\")\\r\\n for item in os.listdir(by_feature_path):\\r\\n item_path = os.path.join(by_feature_path, item)\\r\\n if os.path.isfile(item_path) and \\\".py\\\" in item_path:\\r\\n with self.subTest(tested_script=complete_file_name, feature_script=item, tested_section=\\\"main()\\\" if parser_only else \\\"training_function()\\\"):\\r\\n diff = compare_against_test(\\r\\n os.path.join(examples_path, \\\"nlp_example.py\\\"),\\r\\n os.path.join(examples_path, complete_file_name),\\r\\n item_path,\\r\\n parser_only\\r\\n )\\r\\n> self.assertEqual('\\\\n'.join(diff), '')\\r\\nE AssertionError: ' accelerator = Accelerator(cpu=arg[693 chars]()\\\\n' != ''\\r\\nE - accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\r\\nE - \\r\\nE - accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\r\\nE - \\r\\nE - accelerator.init_trackers(\\\"nlp_example\\\", config)\\r\\nE - \\r\\nE - predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\r\\nE - \\r\\nE - predictions=predictions,\\r\\nE - \\r\\nE - references=references,\\r\\nE - \\r\\nE - accelerator.log(\\r\\nE - \\r\\nE - {\\r\\nE - \\r\\nE - \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\r\\nE - \\r\\nE - \\\"f1\\\": eval_metric[\\\"f1\\\"],\\r\\nE - \\r\\nE - \\\"train_loss\\\": total_loss,\\r\\nE - \\r\\nE - \\\"epoch\\\": epoch,\\r\\nE - \\r\\nE - }\\r\\nE - \\r\\nE - accelerator.end_training()\\r\\n\\r\\ntests/test_examples.py:107: AssertionError\\r\\n```\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/313\",\n \"pr_id\": 906668672\n },\n {\n \"diff\": \"diff --git a/examples/README.md b/examples/README.md\\nindex 115384a42..bb248e9d1 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -186,10 +186,20 @@ To run it in each of these various modes, use the following commands:\\n \\n ## Finer Examples\\n \\n-While the first two scripts are extremely barebones when it comes to what you can do with accelerate, there are two complementary scripts for each: `complete_cv_example.py` and `complete_nlp_example.py`.\\n+While the first two scripts are extremely barebones when it comes to what you can do with accelerate, more advanced features are documented in two other locations.\\n \\n-These two serve to document what else the `Accelerate` library is able to do, outside of just the basic training loop. They each have the following additional arguments:\\n+### `by_feature` examples\\n+\\n+These scripts are *individual* examples highlighting one particular feature or use-case within Accelerate. They all stem from the [nlp_example.py](./nlp_example.py) script, and any changes or modifications is denoted with a `# New Code #` comment.\\n+\\n+Read the README.md file located in the `by_feature` folder for more information.\\n+\\n+### `complete_*` examples\\n+\\n+These two scripts contain *every* single feature currently available in Accelerate in one place, as one giant script.\\n+\\n+New arguments that can be passed include:\\n \\n - `checkpointing_steps`, whether the various states should be saved at the end of every `n` steps, or `\\\"epoch\\\"` for each epoch. States are then saved to folders named `step_{n}` or `epoch_{n}`\\n - `resume_from_checkpoint`, should be used if you want to resume training off of a previous call to the script and passed a `checkpointing_steps` to it.\\n-- `with_tracking`, should be used if you want to log the training run using all available experiment trackers in your environment. Currently supported trackers include TensorBoard, Weights and Biases, and CometML.\\n\\\\ No newline at end of file\\n+- `with_tracking`, should be used if you want to log the training run using all available experiment trackers in your environment. Currently supported trackers include TensorBoard, Weights and Biases, and CometML.\\ndiff --git a/examples/by_feature/README.md b/examples/by_feature/README.md\\nnew file mode 100644\\nindex 000000000..40ffa3c1e\\n--- /dev/null\\n+++ b/examples/by_feature/README.md\\n@@ -0,0 +1,56 @@\\n+# What are these scripts?\\n+\\n+All scripts in this folder originate from the `nlp_example.py` file, as it is a very simplistic NLP training example using Accelerate with zero extra features.\\n+\\n+From there, each further script adds in just **one** feature of Accelerate, showing how you can quickly modify your own scripts to implement these capabilities.\\n+\\n+A full example with all of these parts integrated together can be found in the `complete_nlp_example.py` script and `complete_cv_example.py` script.\\n+\\n+Adjustments to each script from the base `nlp_example.py` file can be found quickly by searching for \\\"# New Code #\\\"\\n+\\n+## Example Scripts by Feature and their Arguments\\n+\\n+### Base Example (`../nlp_example.py`)\\n+\\n+- Shows how to use `Accelerator` in an extremely simplistic PyTorch training loop\\n+- Arguments available:\\n+ - `mixed_precision`, whether to use mixed precision. (\\\"no\\\", \\\"fp16\\\", or \\\"bf16\\\")\\n+ - `cpu`, whether to train using only the CPU. (yes/no/1/0)\\n+\\n+All following scripts also accept these arguments in addition to their added ones.\\n+\\n+These arguments should be added at the end of any method for starting the python script (such as `python`, `accelerate launch`, `python -m torch.distributed.launch`), such as:\\n+\\n+```bash\\n+accelerate launch ../nlp_example.py --mixed_precision fp16 --cpu 0\\n+```\\n+\\n+### Checkpointing and Resuming Training (`checkpointing.py`)\\n+\\n+- Shows how to use `Accelerator.save_state` and `Accelerator.load_state` to save or continue training\\n+- **It is assumed you are continuing off the same training script**\\n+- Arguments available:\\n+ - `checkpointing_steps`, after how many steps the various states should be saved. (\\\"epoch\\\", 1, 2, ...)\\n+ - `output_dir`, where saved state folders should be saved to, default is current working directory\\n+ - `resume_from_checkpoint`, what checkpoint folder to resume from. (\\\"epoch_0\\\", \\\"step_22\\\", ...)\\n+\\n+These arguments should be added at the end of any method for starting the python script (such as `python`, `accelerate launch`, `python -m torch.distributed.launch`), such as:\\n+\\n+(Note, `resume_from_checkpoint` assumes that we've ran the script for one epoch with the `--checkpointing_steps epoch` flag)\\n+\\n+```bash\\n+accelerate launch ./checkpointing.py --checkpointing_steps epoch output_dir \\\"checkpointing_tutorial\\\" --resume_from_checkpoint \\\"checkpointing_tutorial/epoch_0\\\"\\n+```\\n+\\n+### Experiment Tracking (`tracking.py`)\\n+\\n+- Shows how to use `Accelerate.init_trackers` and `Accelerator.log`\\n+- Can be used with Weights and Biases, TensorBoard, or CometML.\\n+- Arguments available:\\n+ - `with_tracking`, whether to load in all available experiment trackers from the environment.\\n+\\n+These arguments should be added at the end of any method for starting the python script (such as `python`, `accelerate launch`, `python -m torch.distributed.launch`), such as:\\n+\\n+```bash\\n+accelerate launch ./tracking.py --with_tracking\\n+```\\ndiff --git a/examples/by_feature/checkpointing.py b/examples/by_feature/checkpointing.py\\nnew file mode 100644\\nindex 000000000..35205107d\\n--- /dev/null\\n+++ b/examples/by_feature/checkpointing.py\\n@@ -0,0 +1,282 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing the checkpointing capability,\\n+# and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To help focus on the differences in the code, building `DataLoaders`\\n+# was refactored into its own function.\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # New Code #\\n+ # Parse out whether we are saving every epoch or after a certain number of batches\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ checkpointing_steps = args.checkpointing_steps\\n+ elif args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ raise ValueError(\\n+ f\\\"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.\\\"\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # New Code #\\n+ # We need to keep track of how many total steps we have iterated over\\n+ if isinstance(checkpointing_steps, int):\\n+ overall_step = 0\\n+\\n+ # We need to load the checkpoint back in before training here with `load_state`\\n+ # The total number of epochs is adjusted based on where the state is being loaded from,\\n+ # as we assume continuation of the same training script\\n+ if args.resume_from_checkpoint:\\n+ accelerator.print(f\\\"Resuming from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+\\n+ if \\\"epoch\\\" in args.resume_from_checkpoint:\\n+ num_epochs -= int(args.resume_from_checkpoint.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ resume_step = None\\n+ else:\\n+ resume_step = int(args.resume_from_checkpoint.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ # If resuming by step, we also need to know exactly how far into the DataLoader we went\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ # New Code #\\n+ # We need to skip steps until we reach the resumed step during the first epoch\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ if resume_step is not None and step < resume_step:\\n+ pass\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ # New Code #\\n+ # We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`\\n+ # These are saved to folders named `step_{overall_step}`\\n+ # Will contain files: \\\"pytorch_model.bin\\\", \\\"optimizer.bin\\\", \\\"scheduler.bin\\\", and \\\"random_states.pkl\\\"\\n+ # If mixed precision was used, will also save a \\\"scalar.bin\\\" file\\n+ if isinstance(checkpointing_steps, int):\\n+ output_dir = f\\\"step_{overall_step}\\\"\\n+ if overall_step % checkpointing_steps == 0:\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True` (the default).\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ # It is slightly faster to call this once, than multiple times\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+\\n+ # New Code #\\n+ # We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`\\n+ # These are saved to folders named `step_{overall_step}`\\n+ # Will contain files: \\\"pytorch_model.bin\\\", \\\"optimizer.bin\\\", \\\"scheduler.bin\\\", and \\\"random_states.pkl\\\"\\n+ # If mixed precision was used, will also save a \\\"scalar.bin\\\" file\\n+ if checkpointing_steps == \\\"epoch\\\":\\n+ output_dir = f\\\"epoch_{num_epochs}\\\"\\n+ if args.output_dir is not None:\\n+ output_dir = os.path.join(args.output_dir, output_dir)\\n+ accelerator.save_state(output_dir)\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ type=str,\\n+ default=\\\"epoch\\\",\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--output_dir\\\",\\n+ type=str,\\n+ default=\\\".\\\",\\n+ help=\\\"Optional save directory where all checkpoint folders will be stored. Default is the current working directory.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"If the training should continue from a checkpoint folder.\\\",\\n+ )\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/examples/by_feature/tracking.py b/examples/by_feature/tracking.py\\nnew file mode 100644\\nindex 000000000..ca11fa04b\\n--- /dev/null\\n+++ b/examples/by_feature/tracking.py\\n@@ -0,0 +1,238 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate,\\n+# specifically showcasing the experiment tracking capability,\\n+# and builds off the `nlp_example.py` script.\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To help focus on the differences in the code, building `DataLoaders`\\n+# was refactored into its own function.\\n+# New additions from the base script can be found quickly by\\n+# looking for the # New Code # tags\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def get_dataloaders(accelerator: Accelerator, batch_size: int = 16):\\n+ \\\"\\\"\\\"\\n+ Creates a set of `DataLoader`s for the `glue` dataset,\\n+ using \\\"bert-base-cased\\\" as the tokenizer.\\n+\\n+ Args:\\n+ accelerator (`Accelerator`):\\n+ An `Accelerator` object\\n+ batch_size (`int`, *optional*):\\n+ The batch size for the train and validation DataLoaders.\\n+ \\\"\\\"\\\"\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ return train_dataloader, eval_dataloader\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize Accelerator\\n+\\n+ # New Code #\\n+ # We pass in \\\"all\\\" to `log_with` to grab all available trackers in the environment\\n+ # Note: If using a custom `Tracker` class, should be passed in here such as:\\n+ # >>> log_with = [\\\"all\\\", MyCustomTrackerClassInstance()]\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+ set_seed(seed)\\n+\\n+ train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # New Code #\\n+ # We need to initalize the trackers we use. Overall configurations can also be stored\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"accelerate_glue_with_tracking\\\", config)\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ # New Code #\\n+ # For our tracking example, we will log the total loss of each epoch\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ # New Code #\\n+ total_loss += loss.detach().float()\\n+ loss = loss / gradient_accumulation_steps\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True` (the default).\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ # It is slightly faster to call this once, than multiple times\\n+ predictions, references = accelerator.gather((predictions, batch[\\\"labels\\\"]))\\n+ metric.add_batch(\\n+ predictions=predictions,\\n+ references=references,\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+\\n+ # New Code #\\n+ # To actually log, we call `Accelerator.log`\\n+ # The values passed can be of `str`, `int`, or `float`\\n+ accelerator.log(\\n+ {\\\"accuracy\\\": eval_metric[\\\"accuracy\\\"], \\\"f1\\\": eval_metric[\\\"f1\\\"], \\\"train_loss\\\": total_loss, \\\"epoch\\\": epoch}\\n+ )\\n+\\n+ # New Code #\\n+ # When a run is finished, you should call `accelerator.end_training()`\\n+ # to close all of the open trackers\\n+ accelerator.end_training()\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--with_tracking\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n+ )\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex a40fe6bef..b14b067be 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -166,7 +166,7 @@ def training_function(config, args):\\n model.eval()\\n accurate = 0\\n num_elems = 0\\n- for step, batch in enumerate(eval_dataloader):\\n+ for _, batch in enumerate(eval_dataloader):\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n inputs = (batch[\\\"image\\\"] - mean) / std\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 8f0d25541..915d35807 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -51,8 +51,7 @@\\n \\n def training_function(config, args):\\n # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n-\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision)\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n num_epochs = int(config[\\\"num_epochs\\\"])\\n@@ -64,6 +63,8 @@ def training_function(config, args):\\n datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n \\n+ set_seed(seed)\\n+\\n def tokenize_function(examples):\\n # max_length=None => use the model max length (it's actually the default)\\n outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n@@ -100,8 +101,6 @@ def collate_fn(examples):\\n tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n )\\n \\n- set_seed(seed)\\n-\\n # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n \\n@@ -161,7 +160,6 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n parser.add_argument(\\n \\\"--mixed_precision\\\",\\n type=str,\\n\",\n \"code_comments\": [\n {\n \"body\": \"Just as a note, I noticed we set_seed *before* building the dataloaders, hence why this change. \",\n \"diff_hunk\": \"@@ -64,6 +63,8 @@ def training_function(config, args):\\n datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n \\n+ set_seed(seed)\\n+\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"A note on `transformers` examples:\\r\\n\\r\\n> This should be decided on a case-by-case basis, as to whether the new feature is important enough to put in those scripts.\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/312\",\n \"pr_id\": 906346536\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex 15eaaecb6..d72680bea 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -54,9 +54,10 @@ def get_cluster_input():\\n \\n if distributed_type == DistributedType.NO:\\n use_cpu = _ask_field(\\n- \\\"Do you want to run your training on CPU only (even if a GPU is available)? [no]:\\\",\\n- lambda x: bool(x),\\n+ \\\"Do you want to run your training on CPU only (even if a GPU is available)? [yes/NO]:\\\",\\n+ _convert_yes_no_to_bool,\\n default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n )\\n elif distributed_type == DistributedType.MULTI_CPU:\\n use_cpu = True\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex b958dbbfc..b3974afe2 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -159,10 +159,10 @@ def test_log(self):\\n break\\n # Check HPS through careful parsing and cleaning\\n cleaned_log = re.sub(r\\\"[\\\\x00-\\\\x1f]+\\\", \\\" \\\", content.decode(\\\"utf8\\\", \\\"ignore\\\"))\\n- self.assertEqual(self.get_value_from_log(\\\"total_loss\\\", cleaned_log), \\\"0.1\\\")\\n- self.assertEqual(self.get_value_from_log(\\\"iteration\\\", cleaned_log), \\\"1\\\")\\n- self.assertEqual(self.get_value_from_log(\\\"my_text\\\", cleaned_log), \\\"some_value\\\")\\n- self.assertEqual(self.get_value_from_log(\\\"_step\\\", cleaned_log), \\\"0\\\")\\n+ self.assertTrue(\\\"0.1\\\" in self.get_value_from_log(\\\"total_loss\\\", cleaned_log))\\n+ self.assertTrue(\\\"1\\\" in self.get_value_from_log(\\\"iteration\\\", cleaned_log))\\n+ self.assertTrue(\\\"some_value\\\" in self.get_value_from_log(\\\"my_text\\\", cleaned_log))\\n+ self.assertTrue(\\\"0\\\" in self.get_value_from_log(\\\"_step\\\", cleaned_log))\\n \\n \\n # Comet has a special `OfflineExperiment` we need to use for testing\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/311\",\n \"pr_id\": 903988203\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 3e21a3ae1..a3fc74cef 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -168,7 +168,7 @@ mpirun -np 2 python examples/nlp_example.py\\n \\n ## Launching training using DeepSpeed\\n \\n-π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. to use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. To use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\n \\n ```python\\n from accelerator import Accelerator, DeepSpeedPlugin\\ndiff --git a/docs/source/quicktour.mdx b/docs/source/quicktour.mdx\\nindex 2b405e8ec..1c62f05f5 100644\\n--- a/docs/source/quicktour.mdx\\n+++ b/docs/source/quicktour.mdx\\n@@ -398,10 +398,6 @@ DeepSpeed support is experimental, so the underlying API will evolve in the near\\n breaking changes. In particular, π€ Accelerate does not support DeepSpeed config you have written yourself yet, this\\n will be added in a next version.\\n \\n-One main caveat for the DeepSpeed integration is that the DeepSpeed launcher always passes a `local_rank` variable to\\n-the training script, so your training script should accept it (whether you launch training with the DeepSpeed launcher\\n-or `accelerate launch`).\\n-\\n <Tip warning={true}>\\n \\n The [`notebook_launcher`] does not support the DeepSpeed integration yet.\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 0cbd66884..f2cab1ccb 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -233,7 +233,7 @@ def multi_gpu_launcher(args):\\n \\n \\n def deepspeed_launcher(args):\\n- cmd = [\\\"deepspeed\\\"]\\n+ cmd = [\\\"deepspeed\\\", \\\"--no_local_rank\\\"]\\n if args.num_machines > 1:\\n cmd.extend(\\n [\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/309\",\n \"pr_id\": 899466884\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 6e0742e02..e18686e12 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -284,9 +284,10 @@ def use_fp16(self):\\n @property\\n def mixed_precision(self):\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- if self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]:\\n+ config = self.state.deepspeed_plugin.deepspeed_config\\n+ if config.get(\\\"fp16\\\", {}).get(\\\"enabled\\\", False):\\n mixed_precision = \\\"fp16\\\"\\n- elif self.state.deepspeed_plugin.deepspeed_config[\\\"bf16\\\"][\\\"enabled\\\"]:\\n+ elif config.get(\\\"bf16\\\", {}).get(\\\"enabled\\\", False):\\n mixed_precision = \\\"bf16\\\"\\n else:\\n mixed_precision = \\\"no\\\"\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n if config.get(\\\"fp16\\\", {}).get(\\\"enabled\\\", False):\\r\\n```\",\n \"diff_hunk\": \"@@ -284,9 +284,10 @@ def use_fp16(self):\\n @property\\n def mixed_precision(self):\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- if self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]:\\n+ config = self.state.deepspeed_plugin.deepspeed_config\\n+ if \\\"fp16\\\" in config and config[\\\"fp16\\\"].get(\\\"enabled\\\", False):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n elif config.get(\\\"bf16\\\", {}).get(\\\"enabled\\\", False):\\r\\n```\",\n \"diff_hunk\": \"@@ -284,9 +284,10 @@ def use_fp16(self):\\n @property\\n def mixed_precision(self):\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- if self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]:\\n+ config = self.state.deepspeed_plugin.deepspeed_config\\n+ if \\\"fp16\\\" in config and config[\\\"fp16\\\"].get(\\\"enabled\\\", False):\\n mixed_precision = \\\"fp16\\\"\\n- elif self.state.deepspeed_plugin.deepspeed_config[\\\"bf16\\\"][\\\"enabled\\\"]:\\n+ elif \\\"bf16\\\" in config and config[\\\"bf16\\\"].get(\\\"enabled\\\", False):\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/308\",\n \"pr_id\": 899386739\n },\n {\n \"diff\": \"diff --git a/examples/README.md b/examples/README.md\\nindex 19995fc0a..115384a42 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -183,3 +183,13 @@ To run it in each of these various modes, use the following commands:\\n ```\\n * In PyTorch:\\n Add an `xmp.spawn` line in your script as you usually do.\\n+\\n+## Finer Examples\\n+\\n+While the first two scripts are extremely barebones when it comes to what you can do with accelerate, there are two complementary scripts for each: `complete_cv_example.py` and `complete_nlp_example.py`.\\n+\\n+These two serve to document what else the `Accelerate` library is able to do, outside of just the basic training loop. They each have the following additional arguments:\\n+\\n+- `checkpointing_steps`, whether the various states should be saved at the end of every `n` steps, or `\\\"epoch\\\"` for each epoch. States are then saved to folders named `step_{n}` or `epoch_{n}`\\n+- `resume_from_checkpoint`, should be used if you want to resume training off of a previous call to the script and passed a `checkpointing_steps` to it.\\n+- `with_tracking`, should be used if you want to log the training run using all available experiment trackers in your environment. Currently supported trackers include TensorBoard, Weights and Biases, and CometML.\\n\\\\ No newline at end of file\\ndiff --git a/examples/complete_cv_example.py b/examples/complete_cv_example.py\\nnew file mode 100644\\nindex 000000000..e62568a39\\n--- /dev/null\\n+++ b/examples/complete_cv_example.py\\n@@ -0,0 +1,274 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+import re\\n+\\n+import numpy as np\\n+import torch\\n+from torch.optim.lr_scheduler import OneCycleLR\\n+from torch.utils.data import DataLoader, Dataset\\n+\\n+import PIL\\n+from accelerate import Accelerator\\n+from timm import create_model\\n+from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a ResNet50 on the Oxford-IIT Pet Dataset\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+# Function to get the label from the filename\\n+def extract_label(fname):\\n+ stem = fname.split(os.path.sep)[-1]\\n+ return re.search(r\\\"^(.*)_\\\\d+\\\\.jpg$\\\", stem).groups()[0]\\n+\\n+\\n+class PetsDataset(Dataset):\\n+ def __init__(self, file_names, image_transform=None, label_to_id=None):\\n+ self.file_names = file_names\\n+ self.image_transform = image_transform\\n+ self.label_to_id = label_to_id\\n+\\n+ def __len__(self):\\n+ return len(self.file_names)\\n+\\n+ def __getitem__(self, idx):\\n+ fname = self.file_names[idx]\\n+ raw_image = PIL.Image.open(fname)\\n+ image = raw_image.convert(\\\"RGB\\\")\\n+ if self.image_transform is not None:\\n+ image = self.image_transform(image)\\n+ label = extract_label(fname)\\n+ if self.label_to_id is not None:\\n+ label = self.label_to_id[label]\\n+ return {\\\"image\\\": image, \\\"label\\\": label}\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+ image_size = config[\\\"image_size\\\"]\\n+ if not isinstance(image_size, (list, tuple)):\\n+ image_size = (image_size, image_size)\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"cv_example\\\", config)\\n+\\n+ # Grab all the image filenames\\n+ file_names = [os.path.join(args.data_dir, fname) for fname in os.listdir(args.data_dir) if fname.endswith(\\\".jpg\\\")]\\n+\\n+ # Build the label correspondences\\n+ all_labels = [extract_label(fname) for fname in file_names]\\n+ id_to_label = list(set(all_labels))\\n+ id_to_label.sort()\\n+ label_to_id = {lbl: i for i, lbl in enumerate(id_to_label)}\\n+\\n+ # Set the seed before splitting the data.\\n+ np.random.seed(seed)\\n+ torch.manual_seed(seed)\\n+ torch.cuda.manual_seed_all(seed)\\n+\\n+ # Split our filenames between train and validation\\n+ random_perm = np.random.permutation(len(file_names))\\n+ cut = int(0.8 * len(file_names))\\n+ train_split = random_perm[:cut]\\n+ eval_split = random_perm[cut:]\\n+\\n+ # For training we use a simple RandomResizedCrop\\n+ train_tfm = Compose([RandomResizedCrop(image_size, scale=(0.5, 1.0)), ToTensor()])\\n+ train_dataset = PetsDataset(\\n+ [file_names[i] for i in train_split], image_transform=train_tfm, label_to_id=label_to_id\\n+ )\\n+\\n+ # For evaluation, we use a deterministic Resize\\n+ eval_tfm = Compose([Resize(image_size), ToTensor()])\\n+ eval_dataset = PetsDataset([file_names[i] for i in eval_split], image_transform=eval_tfm, label_to_id=label_to_id)\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ eval_dataloader = DataLoader(eval_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = create_model(\\\"resnet50d\\\", pretrained=True, num_classes=len(label_to_id))\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Freezing the base model\\n+ for param in model.parameters():\\n+ param.requires_grad = False\\n+ for param in model.get_classifier().parameters():\\n+ param.requires_grad = True\\n+\\n+ # We normalize the batches of images to be a bit faster.\\n+ mean = torch.tensor(model.default_cfg[\\\"mean\\\"])[None, :, None, None].to(accelerator.device)\\n+ std = torch.tensor(model.default_cfg[\\\"std\\\"])[None, :, None, None].to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=lr / 25)\\n+\\n+ # Instantiate learning rate scheduler\\n+ lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=lr, epochs=num_epochs, steps_per_epoch=len(train_dataloader))\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs -= int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ else:\\n+ resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ state_restored = False\\n+\\n+ overall_step = 0\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We need to skip steps until we reach the resumed step\\n+ if args.resume_from_checkpoint and epoch == 0 and step < resume_step:\\n+ continue\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n+ inputs = (batch[\\\"image\\\"] - mean) / std\\n+ outputs = model(inputs)\\n+ loss = torch.nn.functional.cross_entropy(outputs, batch[\\\"label\\\"])\\n+ # We keep track of the loss at each epoch\\n+ if args.with_tracking:\\n+ total_loss += loss.detach().float()\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+ overall_step += 1\\n+ if isinstance(checkpointing_steps, int):\\n+ if overall_step % checkpointing_steps == 0:\\n+ accelerator.save_state(f\\\"step_{overall_step}\\\")\\n+ if state_restored:\\n+ model.eval()\\n+ accurate = 0\\n+ num_elems = 0\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n+ inputs = (batch[\\\"image\\\"] - mean) / std\\n+ with torch.no_grad():\\n+ outputs = model(inputs)\\n+ predictions = outputs.argmax(dim=-1)\\n+ accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch[\\\"label\\\"])\\n+ num_elems += accurate_preds.shape[0]\\n+ accurate += accurate_preds.long().sum()\\n+\\n+ eval_metric = accurate.item() / num_elems\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}: {100 * eval_metric:.2f}\\\")\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\\"accuracy\\\": 100 * eval_metric, \\\"total_loss\\\": total_loss, \\\"epoch\\\": epoch}, step=overall_step\\n+ )\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ accelerator.save_state(f\\\"epoch_{epoch}\\\")\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\\"--data_dir\\\", required=True, help=\\\"The data folder on disk.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"If the training should continue from a checkpoint folder.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--with_tracking\\\",\\n+ required=False,\\n+ help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n+ )\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 3e-2, \\\"num_epochs\\\": 3, \\\"seed\\\": 42, \\\"batch_size\\\": 64, \\\"image_size\\\": 224}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/examples/complete_nlp_example.py b/examples/complete_nlp_example.py\\nnew file mode 100644\\nindex 000000000..57125aa29\\n--- /dev/null\\n+++ b/examples/complete_nlp_example.py\\n@@ -0,0 +1,262 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs -= int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ else:\\n+ resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs -= resume_step // len(train_dataloader)\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ state_restored = False\\n+\\n+ overall_step = 0\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We need to skip steps until we reach the resumed step\\n+ if args.resume_from_checkpoint and epoch == 0 and step < resume_step:\\n+ continue\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ outputs = model(**batch)\\n+ loss = outputs.loss\\n+ loss = loss / gradient_accumulation_steps\\n+ # We keep track of the loss at each epoch\\n+ if args.with_tracking:\\n+ total_loss += loss.detach().float()\\n+ accelerator.backward(loss)\\n+ if step % gradient_accumulation_steps == 0:\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ overall_step += 1\\n+\\n+ if isinstance(checkpointing_steps, int):\\n+ if overall_step % checkpointing_steps == 0:\\n+ accelerator.save_state(f\\\"step_{overall_step}\\\")\\n+ if state_restored:\\n+ model.eval()\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch.to(accelerator.device)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n+ predictions = outputs.logits.argmax(dim=-1)\\n+ metric.add_batch(\\n+ predictions=accelerator.gather(predictions),\\n+ references=accelerator.gather(batch[\\\"labels\\\"]),\\n+ )\\n+\\n+ eval_metric = metric.compute()\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}:\\\", eval_metric)\\n+ if args.with_tracking:\\n+ accelerator.log(\\n+ {\\n+ \\\"accuracy\\\": eval_metric[\\\"accuracy\\\"],\\n+ \\\"f1\\\": eval_metric[\\\"f1\\\"],\\n+ \\\"total_loss\\\": total_loss,\\n+ \\\"epoch\\\": epoch,\\n+ },\\n+ step=overall_step,\\n+ )\\n+\\n+ if args.checkpointing_steps == \\\"epoch\\\":\\n+ accelerator.save_state(f\\\"epoch_{epoch}\\\")\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"If the training should continue from a checkpoint folder.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--with_tracking\\\",\\n+ required=False,\\n+ help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\n+ )\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex 5f2adb7e4..a40fe6bef 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -149,10 +149,6 @@ def training_function(config, args):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n- # Instantiate learning rate scheduler after preparing the training dataloader as the prepare method\\n- # may change its length.\\n- lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=lr, epochs=num_epochs, steps_per_epoch=len(train_dataloader))\\n-\\n # Now we train the model\\n for epoch in range(num_epochs):\\n model.train()\\n\",\n \"code_comments\": [\n {\n \"body\": \"This is the NLP example ;-)\",\n \"diff_hunk\": \"@@ -51,15 +51,28 @@\\n \\n def training_function(config, args):\\n # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n-\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n num_epochs = int(config[\\\"num_epochs\\\"])\\n correct_bias = config[\\\"correct_bias\\\"]\\n seed = int(config[\\\"seed\\\"])\\n batch_size = int(config[\\\"batch_size\\\"])\\n \\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"cv_example\\\", config)\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n help=\\\"Whether to load in all available experiment trackers from the environment and use them for logging.\\\",\\r\\n```\",\n \"diff_hunk\": \"@@ -172,6 +214,19 @@ def main():\\n \\\"and an Nvidia Ampere GPU.\\\",\\n )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ required=False,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\", required=False, help=\\\"If the training should continue from a checkpoint folder.\\\"\\n+ )\\n+ parser.add_argument(\\n+ \\\"--with_tracking\\\",\\n+ required=False,\\n+ help=\\\"Whether to load in all available experiment trackers from the enviornment and use them for logging.\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"I'd put `type=str` and `default=None`here instead of `required=False`\",\n \"diff_hunk\": \"@@ -172,6 +214,19 @@ def main():\\n \\\"and an Nvidia Ampere GPU.\\\",\\n )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ required=False,\",\n \"from_author\": false\n },\n {\n \"body\": \"I'd put `type=str` and `default=None`here\",\n \"diff_hunk\": \"@@ -172,6 +214,19 @@ def main():\\n \\\"and an Nvidia Ampere GPU.\\\",\\n )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\n+ \\\"--checkpointing_steps\\\",\\n+ required=False,\\n+ help=\\\"Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--resume_from_checkpoint\\\", required=False, help=\\\"If the training should continue from a checkpoint folder.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"There is a difference between this argument being None or \\\"\\\". In the second case we want to resume from the last checkpoint ideally.\",\n \"diff_hunk\": \"@@ -127,21 +140,38 @@ def collate_fn(examples):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n+ # Potentially load in the weights and states from a previous save\\n+ if args.resume_from_checkpoint:\",\n \"from_author\": false\n },\n {\n \"body\": \"When resuming a training, we need to skip some steps.\",\n \"diff_hunk\": \"@@ -127,21 +140,38 @@ def collate_fn(examples):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n+ # Potentially load in the weights and states from a previous save\\n+ if args.resume_from_checkpoint:\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+\\n+ overall_step = 0\",\n \"from_author\": false\n },\n {\n \"body\": \"Did you mean `-=` here?\",\n \"diff_hunk\": \"@@ -0,0 +1,262 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs = -int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here, this is weird.\",\n \"diff_hunk\": \"@@ -0,0 +1,262 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs = -int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ else:\\n+ resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs = -resume_step // len(train_dataloader)\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if args.resume_from_checkpoint and epoch == 0 and step < resume_step:\\r\\n continue\\r\\n```\\r\\nand this needs a comment on what we are doing here.\",\n \"diff_hunk\": \"@@ -0,0 +1,262 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs = -int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ else:\\n+ resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs = -resume_step // len(train_dataloader)\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ state_restored = False\\n+\\n+ overall_step = 0\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ for _ in range(resume_step - 1):\\n+ pass\",\n \"from_author\": false\n },\n {\n \"body\": \"Then no need for an else branch\",\n \"diff_hunk\": \"@@ -0,0 +1,262 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+\\n+import torch\\n+from torch.utils.data import DataLoader\\n+\\n+from accelerate import Accelerator, DistributedType\\n+from datasets import load_dataset, load_metric\\n+from transformers import (\\n+ AdamW,\\n+ AutoModelForSequenceClassification,\\n+ AutoTokenizer,\\n+ get_linear_schedule_with_warmup,\\n+ set_seed,\\n+)\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# This example also demonstrates the checkpointing and sharding capabilities\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+MAX_GPU_BATCH_SIZE = 16\\n+EVAL_BATCH_SIZE = 32\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ if args.with_tracking:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, log_with=\\\"all\\\")\\n+ else:\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n+\\n+ if hasattr(args.checkpointing_steps, \\\"isdigit\\\"):\\n+ checkpointing_steps = args.checkpointing_steps\\n+ if args.checkpointing_steps.isdigit():\\n+ checkpointing_steps = int(args.checkpointing_steps)\\n+ else:\\n+ checkpointing_steps = None\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ correct_bias = config[\\\"correct_bias\\\"]\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+\\n+ # We need to initialize the trackers we use, and also store our configuration\\n+ if args.with_tracking:\\n+ accelerator.init_trackers(\\\"nlp_example\\\", config)\\n+\\n+ tokenizer = AutoTokenizer.from_pretrained(\\\"bert-base-cased\\\")\\n+ datasets = load_dataset(\\\"glue\\\", \\\"mrpc\\\")\\n+ metric = load_metric(\\\"glue\\\", \\\"mrpc\\\")\\n+\\n+ def tokenize_function(examples):\\n+ # max_length=None => use the model max length (it's actually the default)\\n+ outputs = tokenizer(examples[\\\"sentence1\\\"], examples[\\\"sentence2\\\"], truncation=True, max_length=None)\\n+ return outputs\\n+\\n+ # Apply the method we just defined to all the examples in all the splits of the dataset\\n+ tokenized_datasets = datasets.map(\\n+ tokenize_function,\\n+ batched=True,\\n+ remove_columns=[\\\"idx\\\", \\\"sentence1\\\", \\\"sentence2\\\"],\\n+ )\\n+\\n+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n+ # transformers library\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n+\\n+ # If the batch size is too big we use gradient accumulation\\n+ gradient_accumulation_steps = 1\\n+ if batch_size > MAX_GPU_BATCH_SIZE:\\n+ gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE\\n+ batch_size = MAX_GPU_BATCH_SIZE\\n+\\n+ def collate_fn(examples):\\n+ # On TPU it's best to pad everything to the same length or training will be very slow.\\n+ if accelerator.distributed_type == DistributedType.TPU:\\n+ return tokenizer.pad(examples, padding=\\\"max_length\\\", max_length=128, return_tensors=\\\"pt\\\")\\n+ return tokenizer.pad(examples, padding=\\\"longest\\\", return_tensors=\\\"pt\\\")\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"train\\\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size\\n+ )\\n+ eval_dataloader = DataLoader(\\n+ tokenized_datasets[\\\"validation\\\"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE\\n+ )\\n+\\n+ set_seed(seed)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n+\\n+ # Instantiate scheduler\\n+ lr_scheduler = get_linear_schedule_with_warmup(\\n+ optimizer=optimizer,\\n+ num_warmup_steps=100,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n+ )\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n+ # Potentially load in the weights and states from a previous save\\n+ state_restored = True\\n+ if args.resume_from_checkpoint:\\n+ if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != \\\"\\\":\\n+ accelerator.print(f\\\"Resumed from checkpoint: {args.resume_from_checkpoint}\\\")\\n+ accelerator.load_state(args.resume_from_checkpoint)\\n+ resume_step = None\\n+ else:\\n+ # Get the most recent checkpoint\\n+ dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]\\n+ dirs.sort(key=os.path.getctime)\\n+ path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last\\n+ if \\\"epoch\\\" in path.name:\\n+ num_epochs = -int(path.name.replace(\\\"epoch_\\\", \\\"\\\"))\\n+ else:\\n+ resume_step = int(path.name.replace(\\\"step_\\\", \\\"\\\"))\\n+ num_epochs = -resume_step // len(train_dataloader)\\n+ resume_step = (num_epochs * len(train_dataloader)) - resume_step\\n+ state_restored = False\\n+\\n+ overall_step = 0\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ if args.with_tracking:\\n+ total_loss = 0\\n+ for step, batch in enumerate(train_dataloader):\\n+ if args.resume_from_checkpoint and epoch == 0:\\n+ for _ in range(resume_step - 1):\\n+ pass\\n+ else:\",\n \"from_author\": false\n },\n {\n \"body\": \"Good catch!\",\n \"diff_hunk\": \"@@ -149,10 +149,6 @@ def training_function(config, args):\\n model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n- # Instantiate learning rate scheduler after preparing the training dataloader as the prepare method\\n- # may change its length.\\n- lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=lr, epochs=num_epochs, steps_per_epoch=len(train_dataloader))\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/307\",\n \"pr_id\": 899272331\n },\n {\n \"diff\": \"diff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py\\nindex 65a5caec2..8d496a3d1 100644\\n--- a/src/accelerate/tracking.py\\n+++ b/src/accelerate/tracking.py\\n@@ -243,3 +243,10 @@ def log(self, values: dict, step: Optional[int] = None):\\n self.writer.set_step(step)\\n self.writer.log_others(values)\\n logger.info(\\\"Successfully logged to CometML\\\")\\n+\\n+ def finish(self):\\n+ \\\"\\\"\\\"\\n+ Closes `comet-ml` writer\\n+ \\\"\\\"\\\"\\n+ self.writer.end()\\n+ logger.info(\\\"CometML run closed\\\")\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex 62c423ef7..b958dbbfc 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -13,11 +13,13 @@\\n # limitations under the License.\\n \\n import csv\\n+import json\\n import logging\\n import os\\n import re\\n import tempfile\\n import unittest\\n+import zipfile\\n from pathlib import Path\\n from typing import Optional\\n from unittest import mock\\n@@ -25,8 +27,9 @@\\n # We use TF to parse the logs\\n from accelerate import Accelerator\\n from accelerate.test_utils.testing import MockingTestCase, TempDirTestCase, require_tensorflow\\n-from accelerate.tracking import GeneralTracker\\n+from accelerate.tracking import CometMLTracker, GeneralTracker\\n from accelerate.utils import is_tensorflow_available\\n+from comet_ml import OfflineExperiment\\n \\n \\n if is_tensorflow_available():\\n@@ -162,6 +165,66 @@ def test_log(self):\\n self.assertEqual(self.get_value_from_log(\\\"_step\\\", cleaned_log), \\\"0\\\")\\n \\n \\n+# Comet has a special `OfflineExperiment` we need to use for testing\\n+def offline_init(self, run_name: str, tmpdir: str):\\n+ self.run_name = run_name\\n+ self.writer = OfflineExperiment(project_name=run_name, offline_directory=tmpdir)\\n+ logger.info(f\\\"Initialized offline CometML project {self.run_name}\\\")\\n+ logger.info(\\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\")\\n+\\n+\\n+@mock.patch.object(CometMLTracker, \\\"__init__\\\", offline_init)\\n+class CometMLTest(unittest.TestCase):\\n+ @staticmethod\\n+ def get_value_from_key(log_list, key: str, is_param: bool = False):\\n+ \\\"Extracts `key` from Comet `log`\\\"\\n+ for log in log_list:\\n+ j = json.loads(log)[\\\"payload\\\"]\\n+ if is_param and \\\"param\\\" in j.keys():\\n+ if j[\\\"param\\\"][\\\"paramName\\\"] == key:\\n+ return j[\\\"param\\\"][\\\"paramValue\\\"]\\n+ if \\\"log_other\\\" in j.keys():\\n+ if j[\\\"log_other\\\"][\\\"key\\\"] == key:\\n+ return j[\\\"log_other\\\"][\\\"val\\\"]\\n+\\n+ def test_init_trackers(self):\\n+ with tempfile.TemporaryDirectory() as d:\\n+ tracker = CometMLTracker(\\\"test_project_with_config\\\", d)\\n+ accelerator = Accelerator(log_with=tracker)\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(None, config)\\n+ accelerator.end_training()\\n+ log = os.listdir(d)[0] # Comet is nice, it's just a zip file here\\n+ # We parse the raw logs\\n+ p = os.path.join(d, log)\\n+ archive = zipfile.ZipFile(p, \\\"r\\\")\\n+ log = archive.open(\\\"messages.json\\\").read().decode(\\\"utf-8\\\")\\n+ list_of_json = log.split(\\\"\\\\n\\\")[:-1]\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"num_iterations\\\", True), 12)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"learning_rate\\\", True), 0.01)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"some_boolean\\\", True), False)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"some_string\\\", True), \\\"some_value\\\")\\n+\\n+ def test_log(self):\\n+ with tempfile.TemporaryDirectory() as d:\\n+ tracker = CometMLTracker(\\\"test_project_with_config\\\", d)\\n+ accelerator = Accelerator(log_with=tracker)\\n+ accelerator.init_trackers(None)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ accelerator.end_training()\\n+ log = os.listdir(d)[0] # Comet is nice, it's just a zip file here\\n+ # We parse the raw logs\\n+ p = os.path.join(d, log)\\n+ archive = zipfile.ZipFile(p, \\\"r\\\")\\n+ log = archive.open(\\\"messages.json\\\").read().decode(\\\"utf-8\\\")\\n+ list_of_json = log.split(\\\"\\\\n\\\")[:-1]\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"curr_step\\\", True), 0)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"total_loss\\\"), 0.1)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"iteration\\\"), 1)\\n+ self.assertEqual(self.get_value_from_key(list_of_json, \\\"my_text\\\"), \\\"some_value\\\")\\n+\\n+\\n class MyCustomTracker(GeneralTracker):\\n \\\"Basic tracker that writes to a csv for testing\\\"\\n _col_names = [\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/306\",\n \"pr_id\": 896538377\n },\n {\n \"diff\": \"diff --git a/docs/source/tracking.mdx b/docs/source/tracking.mdx\\nindex 256e2848b..959317887 100644\\n--- a/docs/source/tracking.mdx\\n+++ b/docs/source/tracking.mdx\\n@@ -106,7 +106,7 @@ from typing import Optional\\n import wandb\\n \\n \\n-class WandBTracker(GeneralTracker):\\n+class MyCustomTracker(GeneralTracker):\\n def __init__(self, run_name: str):\\n self.run_name = run_name\\n wandb.init(self.run_name)\\n@@ -118,6 +118,21 @@ class WandBTracker(GeneralTracker):\\n wandb.log(values, step=step)\\n ```\\n \\n+When you are ready to build your `Accelerator` object, pass in an **instance** of your tracker to [`~Accelerator.log_with`] to have it automatically\\n+be used with the API:\\n+\\n+```python\\n+tracker = MyCustomTracker(\\\"some_run_name\\\")\\n+accelerator = Accelerate(log_with=tracker)\\n+```\\n+\\n+These also can be mixed with existing trackers, including with `\\\"all\\\"`:\\n+\\n+```python\\n+tracker = MyCustomTracker(\\\"some_run_name\\\")\\n+accelerator = Accelerate(log_with=[tracker, \\\"all\\\"])\\n+```\\n+\\n ## When a wrapper cannot work\\n \\n If a library has an API that does not follow a strict `.log` with an overall dictionary such as Neptune.AI, logging can be done manually under an `if accelerator.is_main_process` statement:\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 67c981de3..6e0742e02 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -29,7 +29,7 @@\\n from .optimizer import AcceleratedOptimizer\\n from .scheduler import AcceleratedScheduler\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n-from .tracking import CometMLTracker, TensorBoardTracker, WandBTracker, get_available_trackers\\n+from .tracking import CometMLTracker, GeneralTracker, TensorBoardTracker, WandBTracker, get_available_trackers\\n from .utils import (\\n DeepSpeedPlugin,\\n LoggerType,\\n@@ -94,15 +94,15 @@ class Accelerator:\\n dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n Will default to `[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and `[\\\"generator\\\"]` for PyTorch versions >= 1.6.\\n- log_with (list of `str` or [`~utils.LoggerType`], *optional*):\\n+ log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):\\n A list of loggers to be setup for experiment tracking. Should be one or several of:\\n \\n - `\\\"all\\\"`\\n - `\\\"tensorboard\\\"`\\n - `\\\"wandb\\\"`\\n - `\\\"comet_ml\\\"`\\n-\\n- If `\\\"all`\\\" is selected, will pick up all available trackers in the environment and intialize them.\\n+ If `\\\"all`\\\" is selected, will pick up all available trackers in the environment and intialize them. Can also\\n+ accept implementations of `GeneralTracker` for custom trackers, and can be combined with `\\\"all\\\"`.\\n logging_dir (`str`, `os.PathLike`, *optional*):\\n A path to a directory for storing logs of locally-compatible loggers.\\n dispatch_batches (`bool`, *optional*):\\n@@ -131,26 +131,32 @@ def __init__(\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n- log_with: Optional[List[Union[str, LoggerType]]] = None,\\n+ log_with: Optional[List[Union[str, LoggerType, GeneralTracker]]] = None,\\n logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\",\\n dispatch_batches: Optional[bool] = None,\\n step_scheduler_with_optimizer: bool = True,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ loggers = []\\n if log_with is not None:\\n- if not isinstance(log_with, list):\\n+ if not isinstance(log_with, (list, tuple)):\\n log_with = [log_with]\\n+ logger.debug(f\\\"{log_with}\\\")\\n if \\\"all\\\" in log_with or LoggerType.ALL in log_with:\\n- log_with = get_available_trackers()\\n+ loggers = [o for o in log_with if issubclass(type(o), GeneralTracker)] + get_available_trackers()\\n else:\\n- for i, log_type in enumerate(log_with):\\n- if log_type not in LoggerType:\\n+ for log_type in log_with:\\n+ if log_type not in LoggerType and not issubclass(type(log_type), GeneralTracker):\\n raise ValueError(\\n f\\\"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}\\\"\\n )\\n- log_with[i] = LoggerType(log_type)\\n- log_with = list(set(log_with))\\n- self.log_with = log_with\\n+ if issubclass(type(log_type), GeneralTracker):\\n+ loggers.append(log_type)\\n+ else:\\n+ log_type = LoggerType(log_type)\\n+ if log_type not in loggers:\\n+ loggers.append(log_type)\\n+ self.log_with = loggers\\n self.logging_dir = logging_dir\\n \\n if mixed_precision is not None:\\n@@ -631,7 +637,10 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n \\\"\\\"\\\"\\n self.trackers = []\\n for tracker in self.log_with:\\n- if str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n+ if issubclass(type(tracker), GeneralTracker):\\n+ # Custom trackers are already initialized\\n+ self.trackers.append(tracker)\\n+ elif str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n self.trackers.append(TensorBoardTracker(project_name, self.logging_dir))\\n elif str(tracker).lower() == \\\"wandb\\\" and is_wandb_available():\\n self.trackers.append(WandBTracker(project_name))\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex b1f66b1ae..62c423ef7 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -12,17 +12,20 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import csv\\n import logging\\n import os\\n import re\\n import tempfile\\n import unittest\\n from pathlib import Path\\n+from typing import Optional\\n from unittest import mock\\n \\n # We use TF to parse the logs\\n from accelerate import Accelerator\\n from accelerate.test_utils.testing import MockingTestCase, TempDirTestCase, require_tensorflow\\n+from accelerate.tracking import GeneralTracker\\n from accelerate.utils import is_tensorflow_available\\n \\n \\n@@ -157,3 +160,77 @@ def test_log(self):\\n self.assertEqual(self.get_value_from_log(\\\"iteration\\\", cleaned_log), \\\"1\\\")\\n self.assertEqual(self.get_value_from_log(\\\"my_text\\\", cleaned_log), \\\"some_value\\\")\\n self.assertEqual(self.get_value_from_log(\\\"_step\\\", cleaned_log), \\\"0\\\")\\n+\\n+\\n+class MyCustomTracker(GeneralTracker):\\n+ \\\"Basic tracker that writes to a csv for testing\\\"\\n+ _col_names = [\\n+ \\\"total_loss\\\",\\n+ \\\"iteration\\\",\\n+ \\\"my_text\\\",\\n+ \\\"learning_rate\\\",\\n+ \\\"num_iterations\\\",\\n+ \\\"some_boolean\\\",\\n+ \\\"some_string\\\",\\n+ ]\\n+\\n+ def __init__(self, dir: str):\\n+ self.f = open(f\\\"{dir}/log.csv\\\", \\\"w+\\\")\\n+ self.writer = csv.DictWriter(self.f, fieldnames=self._col_names)\\n+ self.writer.writeheader()\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ logger.info(\\\"Call init\\\")\\n+ self.writer.writerow(values)\\n+\\n+ def log(self, values: dict, step: Optional[int]):\\n+ logger.info(\\\"Call log\\\")\\n+ self.writer.writerow(values)\\n+\\n+ def finish(self):\\n+ self.f.close()\\n+\\n+\\n+class CustomTrackerTestCase(unittest.TestCase):\\n+ def test_init_trackers(self):\\n+ with tempfile.TemporaryDirectory() as d:\\n+ tracker = MyCustomTracker(d)\\n+ accelerator = Accelerator(log_with=tracker)\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(\\\"Some name\\\", config)\\n+ accelerator.end_training()\\n+ with open(f\\\"{d}/log.csv\\\", \\\"r\\\") as f:\\n+ data = csv.DictReader(f)\\n+ data = next(data)\\n+ truth = {\\n+ \\\"total_loss\\\": \\\"\\\",\\n+ \\\"iteration\\\": \\\"\\\",\\n+ \\\"my_text\\\": \\\"\\\",\\n+ \\\"learning_rate\\\": \\\"0.01\\\",\\n+ \\\"num_iterations\\\": \\\"12\\\",\\n+ \\\"some_boolean\\\": \\\"False\\\",\\n+ \\\"some_string\\\": \\\"some_value\\\",\\n+ }\\n+ self.assertDictEqual(data, truth)\\n+\\n+ def test_log(self):\\n+ with tempfile.TemporaryDirectory() as d:\\n+ tracker = MyCustomTracker(d)\\n+ accelerator = Accelerator(log_with=tracker)\\n+ accelerator.init_trackers(\\\"Some name\\\")\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ accelerator.end_training()\\n+ with open(f\\\"{d}/log.csv\\\", \\\"r\\\") as f:\\n+ data = csv.DictReader(f)\\n+ data = next(data)\\n+ truth = {\\n+ \\\"total_loss\\\": \\\"0.1\\\",\\n+ \\\"iteration\\\": \\\"1\\\",\\n+ \\\"my_text\\\": \\\"some_value\\\",\\n+ \\\"learning_rate\\\": \\\"\\\",\\n+ \\\"num_iterations\\\": \\\"\\\",\\n+ \\\"some_boolean\\\": \\\"\\\",\\n+ \\\"some_string\\\": \\\"\\\",\\n+ }\\n+ self.assertDictEqual(data, truth)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n # Custom trackers are already initialized\\r\\n```\",\n \"diff_hunk\": \"@@ -631,7 +637,10 @@ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n \\\"\\\"\\\"\\n self.trackers = []\\n for tracker in self.log_with:\\n- if str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n+ if issubclass(type(tracker), GeneralTracker):\\n+ # Custom tracker that they already initalized\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/305\",\n \"pr_id\": 896232235\n },\n {\n \"diff\": \"diff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex cce7347f6..6a9e66d6a 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -13,8 +13,14 @@\\n # limitations under the License.\\n \\n import asyncio\\n+import os\\n+import shutil\\n import sys\\n+import tempfile\\n import unittest\\n+from pathlib import Path\\n+from typing import List, Union\\n+from unittest import mock\\n \\n import torch\\n \\n@@ -22,6 +28,69 @@\\n from ..utils import gather, is_tensorflow_available\\n \\n \\n+class TempDirTestCase(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ A TestCase class that keeps a single `tempfile.TemporaryDirectory` open for the duration of the class, wipes its\\n+ data at the start of a test, and then destroyes it at the end of the TestCase.\\n+\\n+ Useful for when a class or API requires a single constant folder throughout it's use, such as Weights and Biases\\n+\\n+ The temporary directory location will be stored in `self.tmpdir`\\n+ \\\"\\\"\\\"\\n+\\n+ @classmethod\\n+ def setUpClass(cls):\\n+ \\\"Creates a `tempfile.TemporaryDirectory` and stores it in `cls.tmpdir`\\\"\\n+ cls.tmpdir = tempfile.mkdtemp()\\n+\\n+ @classmethod\\n+ def tearDownClass(cls):\\n+ \\\"Remove `cls.tmpdir` after test suite has finished\\\"\\n+ if os.path.exists(cls.tmpdir):\\n+ shutil.rmtree(cls.tmpdir)\\n+\\n+ def setUp(self):\\n+ \\\"Destroy all contents in `self.tmpdir`, but not `self.tmpdir`\\\"\\n+ for path in Path(self.tmpdir).glob(\\\"**/*\\\"):\\n+ if path.is_file():\\n+ path.unlink()\\n+ elif path.is_dir():\\n+ shutil.rmtree(path)\\n+\\n+\\n+class MockingTestCase(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ A TestCase class designed to dynamically add various mockers that should be used in every test, mimicking the\\n+ behavior of a class-wide mock when defining one normally will not do.\\n+\\n+ Useful when a mock requires specific information available only initialized after `TestCase.setUpClass`, such as\\n+ setting an environment variable with that information.\\n+\\n+ The `add_mocks` function should be ran at the end of a `TestCase`'s `setUp` function, after a call to\\n+ `super().setUp()` such as:\\n+ ```python\\n+ def setUp(self):\\n+ super().setUp()\\n+ mocks = mock.patch.dict(os.environ, {\\\"SOME_ENV_VAR\\\", \\\"SOME_VALUE\\\"})\\n+ self.add_mocks(mocks)\\n+ ```\\n+ \\\"\\\"\\\"\\n+\\n+ def add_mocks(self, mocks: Union[mock.Mock, List[mock.Mock]]):\\n+ \\\"\\\"\\\"\\n+ Add custom mocks for tests that should be repeated on each test. Should be called during\\n+ `MockingTestCase.setUp`, after `super().setUp()`.\\n+\\n+ Args:\\n+ mocks (`mock.Mock` or list of `mock.Mock`):\\n+ Mocks that should be added to the `TestCase` after `TestCase.setUpClass` has been run\\n+ \\\"\\\"\\\"\\n+ self.mocks = mocks if isinstance(mocks, (tuple, list)) else [mocks]\\n+ for m in self.mocks:\\n+ m.start()\\n+ self.addCleanup(m.stop)\\n+\\n+\\n def are_the_same_tensors(tensor):\\n state = AcceleratorState()\\n tensor = tensor[None].clone().to(state.device)\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nindex 8d5ebc6bc..b1f66b1ae 100644\\n--- a/tests/test_tracking.py\\n+++ b/tests/test_tracking.py\\n@@ -15,7 +15,6 @@\\n import logging\\n import os\\n import re\\n-import shutil\\n import tempfile\\n import unittest\\n from pathlib import Path\\n@@ -23,7 +22,7 @@\\n \\n # We use TF to parse the logs\\n from accelerate import Accelerator\\n-from accelerate.test_utils.testing import require_tensorflow\\n+from accelerate.test_utils.testing import MockingTestCase, TempDirTestCase, require_tensorflow\\n from accelerate.utils import is_tensorflow_available\\n \\n \\n@@ -43,13 +42,11 @@ def test_init_trackers(self):\\n hps = None\\n project_name = \\\"test_project_with_config\\\"\\n with tempfile.TemporaryDirectory() as dirpath:\\n- oldpwd = os.getcwd()\\n- os.chdir(dirpath)\\n- accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\", logging_dir=dirpath)\\n config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n accelerator.init_trackers(project_name, config)\\n accelerator.end_training()\\n- for child in Path(project_name).glob(\\\"*/**\\\"):\\n+ for child in Path(f\\\"{dirpath}/{project_name}\\\").glob(\\\"*/**\\\"):\\n log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n # The config log is stored one layer deeper in the logged directory\\n # And names are randomly generated each time\\n@@ -61,7 +58,6 @@ def test_init_trackers(self):\\n plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n if plugin_data.HasField(\\\"session_start_info\\\"):\\n hps = dict(plugin_data.session_start_info.hparams)\\n- os.chdir(oldpwd)\\n \\n self.assertTrue(isinstance(hps, dict))\\n keys = list(hps.keys())\\n@@ -77,16 +73,14 @@ def test_log(self):\\n step = None\\n project_name = \\\"test_project_with_log\\\"\\n with tempfile.TemporaryDirectory() as dirpath:\\n- oldpwd = os.getcwd()\\n- os.chdir(dirpath)\\n- accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\", logging_dir=dirpath)\\n accelerator.init_trackers(project_name)\\n values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n accelerator.log(values, step=0)\\n accelerator.end_training()\\n # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord\\n # Names are randomly generated each time\\n- log = list(filter(lambda x: x.is_file(), Path(project_name).iterdir()))[0]\\n+ log = list(filter(lambda x: x.is_file(), Path(f\\\"{dirpath}/{project_name}\\\").iterdir()))[0]\\n serialized_examples = tf.data.TFRecordDataset(log)\\n for e in serialized_examples:\\n event = event_pb2.Event.FromString(e.numpy())\\n@@ -99,14 +93,18 @@ def test_log(self):\\n iteration = value.simple_value\\n elif value.tag == \\\"my_text/text_summary\\\": # Append /text_summary to the key\\n my_text = value.tensor.string_val[0].decode()\\n- os.chdir(oldpwd)\\n self.assertAlmostEqual(total_loss, values[\\\"total_loss\\\"])\\n self.assertEqual(iteration, values[\\\"iteration\\\"])\\n self.assertEqual(my_text, values[\\\"my_text\\\"])\\n \\n \\n @mock.patch.dict(os.environ, {\\\"WANDB_MODE\\\": \\\"offline\\\"})\\n-class WandBTrackingTest(unittest.TestCase):\\n+class WandBTrackingTest(TempDirTestCase, MockingTestCase):\\n+ def setUp(self):\\n+ super().setUp()\\n+ # wandb let's us override where logs are stored to via the WANDB_DIR env var\\n+ self.add_mocks(mock.patch.dict(os.environ, {\\\"WANDB_DIR\\\": self.tmpdir}))\\n+\\n @staticmethod\\n def get_value_from_log(key: str, log: str, key_occurance: int = 0):\\n \\\"\\\"\\\"\\n@@ -126,7 +124,7 @@ def test_init_trackers(self):\\n accelerator.init_trackers(project_name, config)\\n accelerator.end_training()\\n # The latest offline log is stored at wandb/latest-run/*.wandb\\n- for child in Path(\\\"wandb/latest-run\\\").glob(\\\"*\\\"):\\n+ for child in Path(f\\\"{self.tmpdir}/wandb/latest-run\\\").glob(\\\"*\\\"):\\n logger.info(child)\\n if child.is_file() and child.suffix == \\\".wandb\\\":\\n with open(child, \\\"rb\\\") as f:\\n@@ -148,7 +146,7 @@ def test_log(self):\\n accelerator.log(values, step=0)\\n accelerator.end_training()\\n # The latest offline log is stored at wandb/latest-run/*.wandb\\n- for child in Path(\\\"wandb/latest-run\\\").glob(\\\"*\\\"):\\n+ for child in Path(f\\\"{self.tmpdir}/wandb/latest-run\\\").glob(\\\"*\\\"):\\n if child.is_file() and child.suffix == \\\".wandb\\\":\\n with open(child, \\\"rb\\\") as f:\\n content = f.read()\\n@@ -159,18 +157,3 @@ def test_log(self):\\n self.assertEqual(self.get_value_from_log(\\\"iteration\\\", cleaned_log), \\\"1\\\")\\n self.assertEqual(self.get_value_from_log(\\\"my_text\\\", cleaned_log), \\\"some_value\\\")\\n self.assertEqual(self.get_value_from_log(\\\"_step\\\", cleaned_log), \\\"0\\\")\\n-\\n- def setUp(self):\\n- os.mkdir(\\\".wandb_tests\\\")\\n- os.chdir(\\\".wandb_tests\\\")\\n-\\n- def tearDown(self):\\n- if os.getcwd().endswith(\\\".wandb_tests\\\"):\\n- os.chdir(\\\"..\\\")\\n- if os.path.exists(\\\".wandb_tests\\\"):\\n- shutil.rmtree(\\\".wandb_tests\\\")\\n-\\n- @classmethod\\n- def setUpClass(cls):\\n- if os.path.exists(\\\".wandb_tests\\\"):\\n- shutil.rmtree(\\\".wandb_tests\\\")\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n A TestCase class designed to dynamically add various mockers that should be used in every test, mimicking the behavior\\r\\n```\",\n \"diff_hunk\": \"@@ -13,15 +13,84 @@\\n # limitations under the License.\\n \\n import asyncio\\n+import os\\n+import shutil\\n import sys\\n+import tempfile\\n import unittest\\n+from pathlib import Path\\n+from typing import List, Union\\n+from unittest import mock\\n \\n import torch\\n \\n from ..state import AcceleratorState, is_tpu_available\\n from ..utils import gather, is_tensorflow_available\\n \\n \\n+class TempDirTestCase(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ A TestCase class that keeps a single `tempfile.TemporaryDirectory` open for the duration of the class, wipes its\\n+ data at the start of a test, and then destroyes it at the end of the TestCase.\\n+\\n+ Useful for when a class or API requires a single constant folder throughout it's use, such as Weights and Biases\\n+\\n+ The temporary directory location will be stored in `self.tmpdir`\\n+ \\\"\\\"\\\"\\n+\\n+ @classmethod\\n+ def setUpClass(cls):\\n+ \\\"Creates a `tempfile.TemporaryDirectory` and stores it in `cls.tmpdir`\\\"\\n+ cls.tmpdir = tempfile.mkdtemp()\\n+\\n+ @classmethod\\n+ def tearDownClass(cls):\\n+ \\\"Remove `cls.tmpdir` after test suite has finished\\\"\\n+ if os.path.exists(cls.tmpdir):\\n+ shutil.rmtree(cls.tmpdir)\\n+\\n+ def setUp(self):\\n+ \\\"Destroy all contents in `self.tmpdir`, but not `self.tmpdir`\\\"\\n+ for path in Path(self.tmpdir).glob(\\\"**/*\\\"):\\n+ if path.is_file():\\n+ path.unlink()\\n+ elif path.is_dir():\\n+ shutil.rmtree(path)\\n+\\n+\\n+class MockingTestCase(unittest.TestCase):\\n+ \\\"\\\"\\\"\\n+ A TestCase class designed to dynamically add various mockers that should be used in every test, mimicing a behavior\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/304\",\n \"pr_id\": 896048452\n },\n {\n \"diff\": \"diff --git a/docs/source/internal.mdx b/docs/source/internal.mdx\\nindex bd6924990..94803a62f 100644\\n--- a/docs/source/internal.mdx\\n+++ b/docs/source/internal.mdx\\n@@ -34,6 +34,10 @@ The main work on your PyTorch `DataLoader` is done by the following function:\\n \\n [[autodoc]] data_loader.IterableDatasetShard\\n \\n+## Scheduler\\n+\\n+[[autodoc]] scheduler.AcceleratedScheduler\\n+\\n ## Distributed Config\\n \\n ### AcceleratorState\\ndiff --git a/docs/source/quicktour.mdx b/docs/source/quicktour.mdx\\nindex b6f539fd0..2b405e8ec 100644\\n--- a/docs/source/quicktour.mdx\\n+++ b/docs/source/quicktour.mdx\\n@@ -45,11 +45,13 @@ model on `accelerator.device` or your training will fail on TPU.\\n \\n </Tip>\\n \\n-3. Pass all objects relevant to training (optimizer, model, training dataloader) to the\\n+3. Pass all objects relevant to training (optimizer, model, training dataloader, learning rate scheduler) to the\\n [`~Accelerator.prepare`] method. This will make sure everything is ready for training.\\n \\n ```python\\n-model, optimizer, train_dataloader = accelerator.prepare(model, optimizer, train_dataloader)\\n+model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, lr_scheduler\\n+)\\n ```\\n \\n In particular, your training dataloader will be sharded accross all GPUs/TPU cores available so that each one sees a\\n@@ -74,14 +76,21 @@ training loop.\\n \\n <Tip warning={true}>\\n \\n+You should only pass the learning rate scheduler to [`~Accelerator.prepare`] when the scheduler needs to be stepped\\n+at each optimizer step.\\n+\\n+</Tip>\\n+\\n+<Tip warning={true}>\\n+\\n Your training dataloader may change length when going through this method: if you run on X GPUs, it will have its\\n length divided by X (since your actual batch size will be multiplied by X), unless you set\\n `split_batches=True`.\\n \\n </Tip>\\n \\n-Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n-to create a learning rate scheduler) should go after the call to [`~Accelerator.prepare`].\\n+Any instruction using your training dataloader length (for instance if you want to log the number of total training\\n+steps) should go after the call to [`~Accelerator.prepare`].\\n \\n You can perfectly send your dataloader to [`~Accelerator.prepare`] on its own, but it's best to send the\\n model and optimizer to [`~Accelerator.prepare`] together.\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex bb7c7f5b1..5f2adb7e4 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -139,11 +139,14 @@ def training_function(config, args):\\n # Instantiate optimizer\\n optimizer = torch.optim.Adam(params=model.parameters(), lr=lr / 25)\\n \\n+ # Instantiate learning rate scheduler\\n+ lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=lr, epochs=num_epochs, steps_per_epoch=len(train_dataloader))\\n+\\n # Prepare everything\\n # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n # prepare method.\\n- model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(\\n- model, optimizer, train_dataloader, eval_dataloader\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n )\\n \\n # Instantiate learning rate scheduler after preparing the training dataloader as the prepare method\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 432d78ae8..8f0d25541 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -113,21 +113,20 @@ def collate_fn(examples):\\n # Instantiate optimizer\\n optimizer = AdamW(params=model.parameters(), lr=lr, correct_bias=correct_bias)\\n \\n- # Prepare everything\\n- # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n- # prepare method.\\n- model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(\\n- model, optimizer, train_dataloader, eval_dataloader\\n- )\\n-\\n- # Instantiate learning rate scheduler after preparing the training dataloader as the prepare method\\n- # may change its length.\\n+ # Instantiate scheduler\\n lr_scheduler = get_linear_schedule_with_warmup(\\n optimizer=optimizer,\\n num_warmup_steps=100,\\n num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n )\\n \\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler\\n+ )\\n+\\n # Now we train the model\\n for epoch in range(num_epochs):\\n model.train()\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex f52cf7ca8..67c981de3 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -27,6 +27,7 @@\\n from .data_loader import prepare_data_loader\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n+from .scheduler import AcceleratedScheduler\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n from .tracking import CometMLTracker, TensorBoardTracker, WandBTracker, get_available_trackers\\n from .utils import (\\n@@ -108,6 +109,9 @@ class Accelerator:\\n If set to `True`, the dataloader prepared by the Accelerator is only iterated through on the main process\\n and then the batches are split and broadcast to each process. Will default to `True` for `DataLoader` whose\\n underlying dataset is an `IterableDataset`, `False` otherwise.\\n+ step_scheduler_with_optimizer (`bool`, *optional`, defaults to `True`):\\n+ Set `True` if the learning rate scheduler is stepped at the same time as the optimizer, `False` if only\\n+ done under certain circumstances (at the end of each epoch, for instance).\\n kwargs_handlers (`List[KwargHandler]`, *optional*)\\n A list of `KwargHandler` to customize how the objects related to distributed training or mixed precision\\n are created. See [kwargs](kwargs) for more information.\\n@@ -130,6 +134,7 @@ def __init__(\\n log_with: Optional[List[Union[str, LoggerType]]] = None,\\n logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\",\\n dispatch_batches: Optional[bool] = None,\\n+ step_scheduler_with_optimizer: bool = True,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n if log_with is not None:\\n@@ -205,6 +210,7 @@ def __init__(\\n raise ImportError(\\n \\\"Using `DataLoaderDispatcher` requires PyTorch 1.8.0 minimum. You have {torch.__version__}.\\\"\\n )\\n+ self.step_scheduler_with_optimizer = step_scheduler_with_optimizer\\n \\n # Mixed precision attributes\\n self.scaler = None\\n@@ -227,6 +233,7 @@ def __init__(\\n # Internal references to the training objects\\n self._optimizers = []\\n self._models = []\\n+ self._schedulers = []\\n self._custom_objects = []\\n \\n # RNG Types\\n@@ -315,16 +322,22 @@ def print(self, *args, **kwargs):\\n if self.is_local_main_process:\\n print(*args, **kwargs)\\n \\n- def _prepare_one(self, obj):\\n- if isinstance(obj, torch.utils.data.DataLoader):\\n+ def _prepare_one(self, obj, first_pass=False):\\n+ # First pass of preparation: DataLoader, model, optimizer\\n+ if isinstance(obj, torch.utils.data.DataLoader) and first_pass:\\n return self.prepare_data_loader(obj)\\n- elif isinstance(obj, torch.nn.Module):\\n+ elif isinstance(obj, torch.nn.Module) and first_pass:\\n self._models.append(obj)\\n return self.prepare_model(obj)\\n- elif isinstance(obj, torch.optim.Optimizer):\\n+ elif isinstance(obj, torch.optim.Optimizer) and first_pass:\\n optimizer = self.prepare_optimizer(obj)\\n self._optimizers.append(optimizer)\\n return optimizer\\n+ # Second pass of preparation: LR scheduler (which need the full list of optimizers)\\n+ elif isinstance(obj, torch.optim.lr_scheduler._LRScheduler) and not first_pass:\\n+ scheduler = self.prepare_scheduler(obj)\\n+ self._schedulers.append(scheduler)\\n+ return scheduler\\n else:\\n return obj\\n \\n@@ -362,7 +375,8 @@ def prepare(self, *args):\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n result = self._prepare_deepspeed(*args)\\n else:\\n- result = tuple(self._prepare_one(obj) for obj in args)\\n+ result = tuple(self._prepare_one(obj, first_pass=True) for obj in args)\\n+ result = tuple(self._prepare_one(obj) for obj in result)\\n \\n if tpu_should_fix_optimizer:\\n # 2. grabbing new model parameters\\n@@ -492,6 +506,21 @@ def prepare_data_loader(self, data_loader):\\n def prepare_optimizer(self, optimizer):\\n return AcceleratedOptimizer(optimizer, device_placement=self.device_placement, scaler=self.scaler)\\n \\n+ def prepare_scheduler(self, scheduler):\\n+ # We try to find the optimizer associated with `scheduler`, the default is the full list.\\n+ optimizer = self._optimizers\\n+ for opt in self._optimizers:\\n+ if getattr(scheduler, \\\"optimizer\\\", None) == opt.optimizer:\\n+ optimizer = opt\\n+ break\\n+\\n+ return AcceleratedScheduler(\\n+ scheduler,\\n+ optimizer,\\n+ step_with_optimizer=self.step_scheduler_with_optimizer,\\n+ split_batches=self.split_batches,\\n+ )\\n+\\n def backward(self, loss, **kwargs):\\n \\\"\\\"\\\"\\n Use `accelerator.backward(loss)` in lieu of `loss.backward()`.\\n@@ -659,7 +688,7 @@ def save_state(self, output_dir: str):\\n logger.info(f\\\"Saving current state to {output_dir}\\\")\\n weights = [self.get_state_dict(m) for m in self._models]\\n save_location = save_accelerator_state(\\n- output_dir, weights, self._optimizers, self.state.process_index, self.scaler\\n+ output_dir, weights, self._optimizers, self._schedulers, self.state.process_index, self.scaler\\n )\\n for i, obj in enumerate(self._custom_objects):\\n save_custom_state(obj, output_dir, i)\\n@@ -678,7 +707,9 @@ def load_state(self, input_dir: str):\\n if not os.path.isdir(input_dir):\\n raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n logger.info(f\\\"Loading states from {input_dir}\\\")\\n- load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+ load_accelerator_state(\\n+ input_dir, self._models, self._optimizers, self._schedulers, self.state.process_index, self.scaler\\n+ )\\n custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n if len(custom_checkpoints) != len(self._custom_objects):\\n err = \\\"Warning! Number of found checkpoints does not match the number of registered objects:\\\"\\n@@ -695,6 +726,7 @@ def free_memory(self):\\n Will release all references to the internal objects stored and call the garbage collector. You should call this\\n method between two trainings with different models/optimizers.\\n \\\"\\\"\\\"\\n+ self._schedulers = []\\n self._optimizers = []\\n self._models = []\\n self.deepspeed_engine = None\\n@@ -795,6 +827,6 @@ def optimizer_step_was_skipped(self):\\n case the learning rate should not be changed.\\n \\\"\\\"\\\"\\n for optimizer in self._optimizers:\\n- if optimizer.is_overflow:\\n+ if optimizer.step_was_skipped:\\n return True\\n return False\\ndiff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nindex 99f18be43..b35bec237 100644\\n--- a/src/accelerate/checkpointing.py\\n+++ b/src/accelerate/checkpointing.py\\n@@ -22,7 +22,7 @@\\n from torch.cuda.amp import GradScaler\\n \\n from .state import is_tpu_available\\n-from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, get_pretty_name, save\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, SCHEDULER_NAME, get_pretty_name, save\\n \\n \\n if is_tpu_available():\\n@@ -35,7 +35,12 @@\\n \\n \\n def save_accelerator_state(\\n- output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+ output_dir: str,\\n+ model_states: List[dict],\\n+ optimizers: list,\\n+ schedulers: list,\\n+ process_index: int,\\n+ scaler: GradScaler = None,\\n ):\\n \\\"\\\"\\\"\\n Saves the current states of the models, optimizers, scaler, and RNG generators to a given directory.\\n@@ -47,6 +52,8 @@ def save_accelerator_state(\\n A list of model states\\n optimizers (`List[torch.optim.Optimizer]`):\\n A list of optimizer instances\\n+ schedulers (`List[torch.optim.lr_scheduler._LRScheduler]`):\\n+ A list of learning rate schedulers\\n process_index (`int`):\\n The current process index in the Accelerator state\\n scaler (`torch.cuda.amp.GradScaler`, *optional*):\\n@@ -65,6 +72,13 @@ def save_accelerator_state(\\n output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n save(state, output_optimizer_file)\\n logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # Scheduler states\\n+ for i, scheduler in enumerate(schedulers):\\n+ state = scheduler.state_dict()\\n+ scheduler_name = f\\\"{SCHEDULER_NAME}.bin\\\" if i == 0 else f\\\"{SCHEDULER_NAME}_{i}.bin\\\"\\n+ output_scheduler_file = os.path.join(output_dir, scheduler_name)\\n+ save(state, output_scheduler_file)\\n+ logger.info(f\\\"Scheduler state saved in {output_scheduler_file}\\\")\\n # GradScaler state\\n if scaler is not None:\\n state = scaler.state_dict()\\n@@ -87,7 +101,7 @@ def save_accelerator_state(\\n return output_dir\\n \\n \\n-def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=None):\\n+def load_accelerator_state(input_dir, models, optimizers, schedulers, process_index, scaler=None):\\n \\\"\\\"\\\"\\n Loads states of the models, optimizers, scaler, and RNG generators from a given directory.\\n \\n@@ -98,6 +112,8 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n A list of model instances\\n optimizers (`List[torch.optim.Optimizer]`):\\n A list of optimizer instances\\n+ schedulers (`List[torch.optim.lr_scheduler._LRScheduler]`):\\n+ A list of learning rate schedulers\\n process_index (`int`):\\n The current process index in the Accelerator state\\n scaler (`torch.cuda.amp.GradScaler`, *optional*):\\n@@ -117,6 +133,13 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n optimizers[i].load_state_dict(torch.load(input_optimizer_file, map_location=\\\"cpu\\\"))\\n logger.info(\\\"All optimizer states loaded successfully\\\")\\n \\n+ # Scheduler states\\n+ for i, scheduler in enumerate(schedulers):\\n+ scheduler_name = f\\\"{SCHEDULER_NAME}.bin\\\" if i == 0 else f\\\"{SCHEDULER_NAME}_{i}.bin\\\"\\n+ input_scheduler_file = os.path.join(input_dir, scheduler_name)\\n+ scheduler.load_state_dict(torch.load(input_scheduler_file))\\n+ logger.info(\\\"All scheduler states loaded successfully\\\")\\n+\\n # GradScaler state\\n if scaler is not None:\\n input_scaler_file = os.path.join(input_dir, SCALER_NAME)\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 4360c0c09..1bf37b7d5 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -13,6 +13,7 @@\\n # limitations under the License.\\n \\n import inspect\\n+import warnings\\n \\n import torch\\n \\n@@ -141,4 +142,14 @@ def _switch_parameters(self, parameters_map):\\n @property\\n def is_overflow(self):\\n \\\"\\\"\\\"Whether or not the optimizer step was done, or skipped because of gradient overflow.\\\"\\\"\\\"\\n+ warnings.warn(\\n+ \\\"The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use \\\"\\n+ \\\"`optimizer.step_was_skipped` instead.\\\",\\n+ FutureWarning,\\n+ )\\n+ return self._is_overflow\\n+\\n+ @property\\n+ def step_was_skipped(self):\\n+ \\\"\\\"\\\"Whether or not the optimizer step was skipped.\\\"\\\"\\\"\\n return self._is_overflow\\ndiff --git a/src/accelerate/scheduler.py b/src/accelerate/scheduler.py\\nnew file mode 100644\\nindex 000000000..8efce8dea\\n--- /dev/null\\n+++ b/src/accelerate/scheduler.py\\n@@ -0,0 +1,80 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from .state import AcceleratorState\\n+\\n+\\n+class AcceleratedScheduler:\\n+ \\\"\\\"\\\"\\n+ A wrapper around a learning rate scheduler that will only step when the optimizer(s) have a training step. Useful\\n+ to avoid making a scheduler step too fast when:\\n+\\n+ - gradients went overflow and there was no training step (in mixed precision training)\\n+ - step was skipped because of gradient accumulation\\n+\\n+ Args:\\n+ scheduler (`torch.optim.lr_scheduler._LRScheduler`):\\n+ The scheduler to wrap.\\n+ optimizers (one or a list of `torch.optim.Optimizer`):\\n+ The optimizers used.\\n+ step_with_optimizer (`bool`, *optional*, defaults to `True`):\\n+ Whether or not the scheduler should be stepped at each optimizer step.\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n+ Whether or not the dataloaders split one batch across the different processes (so batch size is the same\\n+ regardless of the number of processes) or create batches on each process (so batch size is the original\\n+ batch size multiplied by the number of processes).\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, scheduler, optimizers, step_with_optimizer: bool = True, split_batches: bool = False):\\n+ self.scheduler = scheduler\\n+ self.optimizers = optimizers if isinstance(optimizers, (list, tuple)) else [optimizers]\\n+ self.split_batches = split_batches\\n+ self.step_with_optimizer = step_with_optimizer\\n+\\n+ def step(self, *args, **kwargs):\\n+ if not self.step_with_optimizer:\\n+ # No link between scheduler and optimizer -> just step\\n+ self.scheduler.step(*args, **kwargs)\\n+ return\\n+\\n+ # Otherwise, first make sure the optimizer was stepped.\\n+ for opt in self.optimizers:\\n+ if opt.step_was_skipped:\\n+ return\\n+\\n+ if self.split_batches:\\n+ # Split batches -> the training dataloader batch size is not changed so one step per training step\\n+ self.scheduler.step(*args, **kwargs)\\n+ else:\\n+ # Otherwise the training dataloader batch size was multiplied by `num_processes`, so we need to do\\n+ # num_processes steps per training step\\n+ num_processes = AcceleratorState().num_processes\\n+ for _ in range(num_processes):\\n+ self.scheduler.step(*args, **kwargs)\\n+\\n+ # Passthroughs\\n+ def get_last_lr(self):\\n+ return self.scheduler.get_last_lr()\\n+\\n+ def state_dict(self):\\n+ return self.scheduler.state_dict()\\n+\\n+ def load_state_dict(self, state_dict):\\n+ self.scheduler.load_state_dict(state_dict)\\n+\\n+ def get_lr(self):\\n+ return self.scheduler.get_lr()\\n+\\n+ def print_lr(self, *args, **kwargs):\\n+ return self.scheduler.print_lr(*args, **kwargs)\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex c5a291ab8..9bcd87f5f 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -65,6 +65,7 @@ def is_sagemaker_available():\\n MODEL_NAME = \\\"pytorch_model\\\"\\n RNG_STATE_NAME = \\\"random_states\\\"\\n OPTIMIZER_NAME = \\\"optimizer\\\"\\n+SCHEDULER_NAME = \\\"scheduler\\\"\\n \\n \\n class EnumWithContains(EnumMeta):\\ndiff --git a/tests/test_scheduler.py b/tests/test_scheduler.py\\nnew file mode 100644\\nindex 000000000..8ae9e56ae\\n--- /dev/null\\n+++ b/tests/test_scheduler.py\\n@@ -0,0 +1,62 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+from functools import partial\\n+\\n+import torch\\n+\\n+from accelerate import Accelerator, debug_launcher\\n+\\n+\\n+def scheduler_test(num_processes=2, step_scheduler_with_optimizer=True, split_batches=False):\\n+ accelerator = Accelerator(step_scheduler_with_optimizer=step_scheduler_with_optimizer, split_batches=split_batches)\\n+ model = torch.nn.Linear(2, 4)\\n+ optimizer = torch.optim.AdamW(model.parameters(), lr=1.0)\\n+ scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda n: 1 - n / 10)\\n+\\n+ model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)\\n+\\n+ # Optimizer has stepped\\n+ optimizer._is_overflow = False\\n+ scheduler.step()\\n+ expected_lr = 1 - (num_processes if (step_scheduler_with_optimizer and not split_batches) else 1) / 10\\n+ assert (\\n+ scheduler.get_last_lr()[0] == expected_lr\\n+ ), f\\\"Wrong lr found at first step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}\\\"\\n+\\n+ # Optimizer has not stepped\\n+ optimizer._is_overflow = True\\n+ scheduler.step()\\n+ if not step_scheduler_with_optimizer:\\n+ expected_lr = 1 - 2 / 10\\n+ assert (\\n+ scheduler.get_last_lr()[0] == expected_lr\\n+ ), f\\\"Wrong lr found at second step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}\\\"\\n+\\n+\\n+class SchedulerTester(unittest.TestCase):\\n+ def test_scheduler_steps_with_optimizer_single_process(self):\\n+ debug_launcher(partial(scheduler_test, num_processes=1), num_processes=1)\\n+ debug_launcher(partial(scheduler_test, num_processes=1, split_batches=True), num_processes=1)\\n+\\n+ def test_scheduler_not_step_with_optimizer_single_process(self):\\n+ debug_launcher(partial(scheduler_test, num_processes=1, step_scheduler_with_optimizer=False), num_processes=1)\\n+\\n+ def test_scheduler_steps_with_optimizer_multiprocess(self):\\n+ debug_launcher(scheduler_test)\\n+ debug_launcher(partial(scheduler_test, num_processes=1, split_batches=True), num_processes=1)\\n+\\n+ def test_scheduler_not_step_with_optimizer_multiprocess(self):\\n+ debug_launcher(partial(scheduler_test, step_scheduler_with_optimizer=False))\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n Set `True` if the learning rate scheduler is stepped at the same time as the optimizer, `False` if only\\r\\n done under certain circumstances (at the end of each epoch, for instance).\\r\\n```\",\n \"diff_hunk\": \"@@ -92,6 +93,9 @@ class Accelerator:\\n If set to `True`, the dataloader prepared by the Accelerator is only iterated through on the main process\\n and then the batches are split and broadcast to each process. Will default to `True` for `DataLoader` whose\\n underlying dataset is an `IterableDataset`, `False` otherwise.\\n+ step_scheduler_with_optimizer (`bool`, *optional`, defaults to `True`):\\n+ Set `True` if you step your learning rate scheduler at the same time as the optimizer, `False` if you only\\n+ do it under certain circumstances (at the end of each epoch, for instance).\",\n \"from_author\": false\n },\n {\n \"body\": \"Clever! I had wondered how you'd do this π \",\n \"diff_hunk\": \"@@ -458,6 +472,21 @@ def prepare_data_loader(self, data_loader):\\n def prepare_optimizer(self, optimizer):\\n return AcceleratedOptimizer(optimizer, device_placement=self.device_placement, scaler=self.scaler)\\n \\n+ def prepare_scheduler(self, scheduler):\\n+ # We try to find the optimizer associated with `scheduler`, the default is the full list.\\n+ optimizer = self._optimizers\\n+ for opt in self._optimizers:\\n+ if getattr(scheduler, \\\"optimizer\\\", None) == opt.optimizer:\\n+ optimizer = opt\\n+ break\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n logger.info(f\\\"Scheduler state saved in {output_scheduler_file}\\\")\\r\\n```\",\n \"diff_hunk\": \"@@ -65,6 +72,13 @@ def save_accelerator_state(\\n output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n save(state, output_optimizer_file)\\n logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # Scheduler states\\n+ for i, scheduler in enumerate(schedulers):\\n+ state = scheduler.state_dict()\\n+ scheduler_name = f\\\"{SCHEDULER_NAME}.bin\\\" if i == 0 else f\\\"{SCHEDULER_NAME}_{i}.bin\\\"\\n+ output_scheduler_file = os.path.join(output_dir, scheduler_name)\\n+ save(state, output_scheduler_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_scheduler_file}\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n scheduler (`torch.optim.lr_scheduler._LRScheduler`): \\r\\n The scheduler to wrap.\\r\\n optimizers (one or a list of `torch.optim.Optimizer`): \\r\\n The optimizers used.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,78 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from .state import AcceleratorState\\n+\\n+\\n+class AcceleratedScheduler:\\n+ \\\"\\\"\\\"\\n+ A wrapper around a learning rate scheduler that will only step when the optimizer(s) have a training step. Useful\\n+ to avoid making a scheduler step too fast when:\\n+\\n+ - gradients went overflow and there was no training step (in mixed precision training)\\n+ - step was skipped because of gradient accumulation\\n+\\n+ Args:\\n+ scheduler (`torch.optim.lr_scheduler._LRScheduler`): The scheduler to wrap.\\n+ optimizers (one or a list of `torch.optim.Optimizer`): The optimizers used.\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/301\",\n \"pr_id\": 894856300\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex dd946c85d..0cbd66884 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -56,7 +56,6 @@ def launch_command_parser(subparsers=None):\\n )\\n parser.add_argument(\\n \\\"--mixed_precision\\\",\\n- default=\\\"no\\\",\\n type=str,\\n choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n help=\\\"Whether or not to use mixed precision training. \\\"\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/300\",\n \"pr_id\": 894724597\n },\n {\n \"diff\": \"diff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nindex 0636dffaa..99f18be43 100644\\n--- a/src/accelerate/checkpointing.py\\n+++ b/src/accelerate/checkpointing.py\\n@@ -107,14 +107,14 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n for i, model in enumerate(models):\\n weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n input_model_file = os.path.join(input_dir, weights_name)\\n- models[i].load_state_dict(torch.load(input_model_file))\\n+ models[i].load_state_dict(torch.load(input_model_file, map_location=\\\"cpu\\\"))\\n logger.info(\\\"All model weights loaded successfully\\\")\\n \\n # Optimizer states\\n for i, opt in enumerate(optimizers):\\n optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n input_optimizer_file = os.path.join(input_dir, optimizer_name)\\n- optimizers[i].load_state_dict(torch.load(input_optimizer_file))\\n+ optimizers[i].load_state_dict(torch.load(input_optimizer_file, map_location=\\\"cpu\\\"))\\n logger.info(\\\"All optimizer states loaded successfully\\\")\\n \\n # GradScaler state\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"LG2M! Nice catch! Looks like we might be able to link https://github.com/huggingface/accelerate/issues/296?\",\n \"from_author\": false\n },\n {\n \"body\": \"That's no linked per se since in this issue, the user was using `optimizer.load_state_dict` and not `accelerator.load_state`.\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/299\",\n \"pr_id\": 893350079\n },\n {\n \"diff\": \"diff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 2f869bd0f..432d78ae8 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -78,7 +78,7 @@ def tokenize_function(examples):\\n \\n # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\\n # transformers library\\n- tokenized_datasets.rename_column_(\\\"label\\\", \\\"labels\\\")\\n+ tokenized_datasets = tokenized_datasets.rename_column(\\\"label\\\", \\\"labels\\\")\\n \\n # If the batch size is too big we use gradient accumulation\\n gradient_accumulation_steps = 1\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/298\",\n \"pr_id\": 893343225\n },\n {\n \"diff\": \"diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml\\nindex aa04063d8..c213a9167 100644\\n--- a/.github/workflows/test.yml\\n+++ b/.github/workflows/test.yml\\n@@ -12,6 +12,6 @@ jobs:\\n with:\\n python-version: 3.6\\n - name: Install Python dependencies\\n- run: pip install -e .[test]\\n+ run: pip install setuptools==59.5.0; pip install -e .[test,test_trackers]\\n - name: Run Tests\\n run: make test\\n\\\\ No newline at end of file\\ndiff --git a/Makefile b/Makefile\\nindex 943191f62..e5b557f10 100644\\n--- a/Makefile\\n+++ b/Makefile\\n@@ -25,4 +25,4 @@ style:\\n \\t\\n # Run tests for the library\\n test:\\n-\\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/\\n+\\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/\\n\\\\ No newline at end of file\\ndiff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml\\nindex 8f266c600..0a6d45892 100644\\n--- a/docs/source/_toctree.yml\\n+++ b/docs/source/_toctree.yml\\n@@ -21,4 +21,6 @@\\n title: Internals\\n - local: checkpoint\\n title: Checkpointing\\n+ - local: tracking\\n+ title: Experiment Tracking\\n title: API Reference\\ndiff --git a/docs/source/internal.mdx b/docs/source/internal.mdx\\nindex 3acaaad87..bd6924990 100644\\n--- a/docs/source/internal.mdx\\n+++ b/docs/source/internal.mdx\\n@@ -44,6 +44,10 @@ The main work on your PyTorch `DataLoader` is done by the following function:\\n \\n [[autodoc]] state.DistributedType\\n \\n+## Tracking\\n+\\n+[[autodoc]] tracking.GeneralTracker\\n+\\n ## Utilities\\n \\n [[autodoc]] utils.extract_model_from_parallel\\ndiff --git a/docs/source/tracking.mdx b/docs/source/tracking.mdx\\nnew file mode 100644\\nindex 000000000..256e2848b\\n--- /dev/null\\n+++ b/docs/source/tracking.mdx\\n@@ -0,0 +1,148 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Tracking\\n+\\n+There are a large number of experiment tracking API's available, however getting them all to work with in a multi-processing environment can oftentimes be complex.\\n+Accelerate provides a general tracking API that can be used to log useful items during your script through [`~Accelerator.log`]\\n+\\n+## Integrated Trackers\\n+\\n+Currently `Accelerate` supports three trackers out-of-the-box:\\n+\\n+\\n+[[autodoc]] tracking.TensorBoardTracker\\n+\\n+[[autodoc]] tracking.WandBTracker\\n+\\n+[[autodoc]] tracking.CometMLTracker\\n+\\n+To use any of them, pass in the selected type(s) to the `log_with` parameter in [`Accelerate`]:\\n+```python\\n+from accelerate import Accelerate\\n+from accelerate.utils import LoggerType\\n+\\n+accelerator = Accelerate(log_with=\\\"all\\\") # For all available trackers in the environment\\n+accelerator = Accelerate(log_with=\\\"wandb\\\")\\n+accelerator = Accelerate(log_with=[\\\"wandb\\\", LoggerType.TENSORBOARD])\\n+```\\n+\\n+At the start of your experiment [`~Accelerator.init_trackers`] should be used to setup your project, and potentially add any experiment hyperparameters to be logged:\\n+```python\\n+hps = {\\\"num_iterations\\\": 5, \\\"learning_rate\\\": 1e-2}\\n+accelerator.init_trackers(\\\"my_project\\\", config=hps)\\n+```\\n+\\n+When you are ready to log any data, [`~Accelerator.log`] should be used.\\n+A `step` can also be passed in to correlate the data with a particular step in the training loop.\\n+```python\\n+accelerator.log({\\\"train_loss\\\": 1.12, \\\"valid_loss\\\": 0.8}, step=1)\\n+```\\n+\\n+Once you've finished training, make sure to run [`~Accelerator.end_training`] so that all the trackers can run their finish functionalities if they have any.\\n+```python\\n+accelerator.end_training()\\n+```\\n+\\n+\\n+A full example is below:\\n+```python\\n+from accelerate import Accelerator\\n+\\n+accelerator = Accelerator(log_with=\\\"all\\\")\\n+config = {\\n+ \\\"num_iterations\\\": 5,\\n+ \\\"learning_rate\\\": 1e-2,\\n+ \\\"loss_function\\\": str(my_loss_function),\\n+}\\n+\\n+accelerator.init_trackers(\\\"example_project\\\", config=config)\\n+\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+for iteration in config[\\\"num_iterations\\\"]:\\n+ for step, batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+ accelerator.log({\\\"training_loss\\\": loss}, step=step)\\n+accelerator.end_training()\\n+```\\n+\\n+\\n+## Implementing Custom Trackers\\n+\\n+To implement a new tracker to be used in `Accelerator`, a new one can be made through implementing the [`~GeneralTracker`] class.\\n+Every tracker must implement three functions:\\n+ - `__init__`: \\n+ - Should store a `run_name` and initialize the tracker API of the integrated library. \\n+ - If a tracker stores their data locally (such as TensorBoard), a `logging_dir` parameter can be added.\\n+ - `store_init_configuration`: \\n+ - Should take in a `values` dictionary and store them as a one-time experiment configuration\\n+ - `log`: \\n+ - Should take in a `values` dictionary and a `step`, and should log them to the run\\n+\\n+A brief example can be seen below with an integration with Weights and Biases, containing only the relevent information:\\n+```python\\n+from accelerate.tracking import GeneralTracker\\n+from typing import Optional\\n+\\n+import wandb\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ wandb.config(values)\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ wandb.log(values, step=step)\\n+```\\n+\\n+## When a wrapper cannot work\\n+\\n+If a library has an API that does not follow a strict `.log` with an overall dictionary such as Neptune.AI, logging can be done manually under an `if accelerator.is_main_process` statement:\\n+```diff\\n+from accelerate import Accelerator\\n++ import neptune.new as neptune\\n+\\n+accelerator = Accelerator()\\n++ run = neptune.init(...)\\n+\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+for iteration in config[\\\"num_iterations\\\"]:\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ total_loss += loss\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n++ if accelerator.is_main_process:\\n++ run[\\\"logs/training/batch/loss\\\"].log(loss)\\n+```\\ndiff --git a/setup.py b/setup.py\\nindex c898eb5a1..0ce1e5af4 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -20,8 +20,9 @@\\n extras[\\\"docs\\\"] = []\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n- \\\"pytest-xdist\\\",\\n+ \\\"pytest-xdist\\\"\\n ]\\n+extras[\\\"test_trackers\\\"] = [\\\"wandb\\\", \\\"comet-ml\\\", \\\"tensorflow\\\"]\\n extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\n \\n extras[\\\"sagemaker\\\"] = [\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 2b623db34..f52cf7ca8 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -28,14 +28,19 @@\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n+from .tracking import CometMLTracker, TensorBoardTracker, WandBTracker, get_available_trackers\\n from .utils import (\\n DeepSpeedPlugin,\\n+ LoggerType,\\n PrecisionType,\\n RNGType,\\n convert_outputs_to_fp32,\\n extract_model_from_parallel,\\n gather,\\n get_pretty_name,\\n+ is_comet_ml_available,\\n+ is_tensorboard_available,\\n+ is_wandb_available,\\n pad_across_processes,\\n save,\\n wait_for_everyone,\\n@@ -88,6 +93,17 @@ class Accelerator:\\n dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n Will default to `[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and `[\\\"generator\\\"]` for PyTorch versions >= 1.6.\\n+ log_with (list of `str` or [`~utils.LoggerType`], *optional*):\\n+ A list of loggers to be setup for experiment tracking. Should be one or several of:\\n+\\n+ - `\\\"all\\\"`\\n+ - `\\\"tensorboard\\\"`\\n+ - `\\\"wandb\\\"`\\n+ - `\\\"comet_ml\\\"`\\n+\\n+ If `\\\"all`\\\" is selected, will pick up all available trackers in the environment and intialize them.\\n+ logging_dir (`str`, `os.PathLike`, *optional*):\\n+ A path to a directory for storing logs of locally-compatible loggers.\\n dispatch_batches (`bool`, *optional*):\\n If set to `True`, the dataloader prepared by the Accelerator is only iterated through on the main process\\n and then the batches are split and broadcast to each process. Will default to `True` for `DataLoader` whose\\n@@ -111,9 +127,27 @@ def __init__(\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n+ log_with: Optional[List[Union[str, LoggerType]]] = None,\\n+ logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\",\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ if log_with is not None:\\n+ if not isinstance(log_with, list):\\n+ log_with = [log_with]\\n+ if \\\"all\\\" in log_with or LoggerType.ALL in log_with:\\n+ log_with = get_available_trackers()\\n+ else:\\n+ for i, log_type in enumerate(log_with):\\n+ if log_type not in LoggerType:\\n+ raise ValueError(\\n+ f\\\"Unsupported logging capability: {log_type}. Choose between {LoggerType.list()}\\\"\\n+ )\\n+ log_with[i] = LoggerType(log_type)\\n+ log_with = list(set(log_with))\\n+ self.log_with = log_with\\n+ self.logging_dir = logging_dir\\n+\\n if mixed_precision is not None:\\n mixed_precision = str(mixed_precision)\\n if mixed_precision not in PrecisionType:\\n@@ -556,6 +590,50 @@ def wait_for_everyone(self):\\n \\\"\\\"\\\"\\n wait_for_everyone()\\n \\n+ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n+ \\\"\\\"\\\"\\n+ Initializes a run for all trackers stored in `self.log_with`, potentially with starting configurations\\n+\\n+ Args:\\n+ project_name (`str`):\\n+ The name of the project. All trackers will save their data based on this\\n+ config (`dict`, *optional*):\\n+ Optional starting configuration to be logged.\\n+ \\\"\\\"\\\"\\n+ self.trackers = []\\n+ for tracker in self.log_with:\\n+ if str(tracker).lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n+ self.trackers.append(TensorBoardTracker(project_name, self.logging_dir))\\n+ elif str(tracker).lower() == \\\"wandb\\\" and is_wandb_available():\\n+ self.trackers.append(WandBTracker(project_name))\\n+ elif str(tracker).lower() == \\\"comet_ml\\\" and is_comet_ml_available():\\n+ self.trackers.append(CometMLTracker(project_name))\\n+ if config is not None:\\n+ for tracker in self.trackers:\\n+ tracker.store_init_configuration(config)\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to all stored trackers in `self.trackers`.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values should be a dictionary-like object containing only types `int`, `float`, or `str`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ if self.is_main_process:\\n+ for tracker in self.trackers:\\n+ tracker.log(values, step=step)\\n+\\n+ def end_training(self):\\n+ \\\"\\\"\\\"\\n+ Runs any special end training behaviors, such as stopping trackers\\n+ \\\"\\\"\\\"\\n+ if self.is_main_process:\\n+ for tracker in self.trackers:\\n+ tracker.finish()\\n+\\n def save(self, obj, f):\\n \\\"\\\"\\\"\\n Save the object passed to disk once per machine. Use in place of `torch.save`.\\ndiff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex 507f16eb8..cce7347f6 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -19,7 +19,7 @@\\n import torch\\n \\n from ..state import AcceleratorState, is_tpu_available\\n-from ..utils import gather\\n+from ..utils import gather, is_tensorflow_available\\n \\n \\n def are_the_same_tensors(tensor):\\n@@ -64,6 +64,17 @@ def require_multi_gpu(test_case):\\n return test_case\\n \\n \\n+def require_tensorflow(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires TensorFlow installed. These tests are skipped when TensorFlow isn't\\n+ installed\\n+ \\\"\\\"\\\"\\n+ if not is_tensorflow_available():\\n+ return unittest.skip(\\\"test requires TensorFlow\\\")(test_case)\\n+ else:\\n+ return test_case\\n+\\n+\\n class _RunOutput:\\n def __init__(self, returncode, stdout, stderr):\\n self.returncode = returncode\\ndiff --git a/src/accelerate/tracking.py b/src/accelerate/tracking.py\\nnew file mode 100644\\nindex 000000000..65a5caec2\\n--- /dev/null\\n+++ b/src/accelerate/tracking.py\\n@@ -0,0 +1,245 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+import os\\n+from abc import ABCMeta, abstractmethod\\n+from typing import Optional, Union\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Implementations should use the experiment configuration\\n+ functionality of a tracking API.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values: dict, step: Optional[int]):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run. Base `log` implementations of a tracking API should go in here, along with\\n+ special behavior for the `step parameter.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ pass\\n+\\n+ def finish(self):\\n+ \\\"\\\"\\\"\\n+ Should run any finalizing functions within the tracking API. If the API should not have one, just don't\\n+ overwrite that method.\\n+ \\\"\\\"\\\"\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run\\n+ logging_dir (`str`, `os.PathLike`):\\n+ Location for TensorBoard logs to be stored.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, run_name: str, logging_dir: Optional[Union[str, os.PathLike]] = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.logging_dir = os.path.join(logging_dir, run_name)\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} logging to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+ def finish(self):\\n+ \\\"\\\"\\\"\\n+ Closes `TensorBoard` writer\\n+ \\\"\\\"\\\"\\n+ self.writer.close()\\n+ logger.info(\\\"TensorBoard writer closed\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.run = wandb.init(self.run_name)\\n+ logger.info(f\\\"Initialized WandB project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ wandb.config.update(values)\\n+ logger.info(\\\"Stored initial configuration hyperparameters to WandB\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ self.run.log(values, step=step)\\n+ logger.info(\\\"Successfully logged to WandB\\\")\\n+\\n+ def finish(self):\\n+ \\\"\\\"\\\"\\n+ Closes `wandb` writer\\n+ \\\"\\\"\\\"\\n+ self.run.finish()\\n+ logger.info(\\\"WandB run closed\\\")\\n+\\n+\\n+class CometMLTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `comet_ml`. Should be initialized at the start of your script.\\n+\\n+ API keys must be stored in a Comet config file.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.writer = Experiment(project_name=run_name)\\n+ logger.info(f\\\"Initialized CometML project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.log_parameters(values)\\n+ logger.info(\\\"Stored initial configuration hyperparameters to CometML\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ if step is not None:\\n+ self.writer.set_step(step)\\n+ self.writer.log_others(values)\\n+ logger.info(\\\"Successfully logged to CometML\\\")\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex af9299a4f..c5a291ab8 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -34,6 +34,22 @@\\n import torch_xla.core.xla_model as xm\\n \\n \\n+def is_tensorflow_available():\\n+ return importlib.util.find_spec(\\\"tensorflow\\\") is not None\\n+\\n+\\n+def is_tensorboard_available():\\n+ return importlib.util.find_spec(\\\"tensorboard\\\") is not None or importlib.util.find_spec(\\\"tensorboardX\\\") is not None\\n+\\n+\\n+def is_wandb_available():\\n+ return importlib.util.find_spec(\\\"wandb\\\") is not None\\n+\\n+\\n+def is_comet_ml_available():\\n+ return importlib.util.find_spec(\\\"comet_ml\\\") is not None\\n+\\n+\\n def is_boto3_available():\\n return importlib.util.find_spec(\\\"boto3\\\") is not None\\n \\n@@ -74,6 +90,13 @@ def list(cls):\\n return list(map(lambda item: str(item), cls))\\n \\n \\n+class LoggerType(BaseEnum):\\n+ ALL = \\\"all\\\"\\n+ TENSORBOARD = \\\"tensorboard\\\"\\n+ WANDB = \\\"wandb\\\"\\n+ COMETML = \\\"comet_ml\\\"\\n+\\n+\\n class PrecisionType(BaseEnum):\\n NO = \\\"no\\\"\\n FP16 = \\\"fp16\\\"\\ndiff --git a/tests/test_tracking.py b/tests/test_tracking.py\\nnew file mode 100644\\nindex 000000000..8d5ebc6bc\\n--- /dev/null\\n+++ b/tests/test_tracking.py\\n@@ -0,0 +1,176 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import os\\n+import re\\n+import shutil\\n+import tempfile\\n+import unittest\\n+from pathlib import Path\\n+from unittest import mock\\n+\\n+# We use TF to parse the logs\\n+from accelerate import Accelerator\\n+from accelerate.test_utils.testing import require_tensorflow\\n+from accelerate.utils import is_tensorflow_available\\n+\\n+\\n+if is_tensorflow_available():\\n+ import tensorflow as tf\\n+ from tensorboard.plugins.hparams import plugin_data_pb2\\n+ from tensorflow.core.util import event_pb2\\n+ from tensorflow.python.summary.summary_iterator import summary_iterator\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class TensorBoardTrackingTest(unittest.TestCase):\\n+ @require_tensorflow\\n+ def test_init_trackers(self):\\n+ hps = None\\n+ project_name = \\\"test_project_with_config\\\"\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ oldpwd = os.getcwd()\\n+ os.chdir(dirpath)\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(project_name, config)\\n+ accelerator.end_training()\\n+ for child in Path(project_name).glob(\\\"*/**\\\"):\\n+ log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n+ # The config log is stored one layer deeper in the logged directory\\n+ # And names are randomly generated each time\\n+ si = summary_iterator(str(log))\\n+ # Pull HPS through careful parsing\\n+ for event in si:\\n+ for value in event.summary.value:\\n+ proto_bytes = value.metadata.plugin_data.content\\n+ plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n+ if plugin_data.HasField(\\\"session_start_info\\\"):\\n+ hps = dict(plugin_data.session_start_info.hparams)\\n+ os.chdir(oldpwd)\\n+\\n+ self.assertTrue(isinstance(hps, dict))\\n+ keys = list(hps.keys())\\n+ keys.sort()\\n+ self.assertEqual(keys, [\\\"learning_rate\\\", \\\"num_iterations\\\", \\\"some_boolean\\\", \\\"some_string\\\"])\\n+ self.assertEqual(hps[\\\"num_iterations\\\"].number_value, 12)\\n+ self.assertEqual(hps[\\\"learning_rate\\\"].number_value, 0.01)\\n+ self.assertEqual(hps[\\\"some_boolean\\\"].bool_value, False)\\n+ self.assertEqual(hps[\\\"some_string\\\"].string_value, \\\"some_value\\\")\\n+\\n+ @require_tensorflow\\n+ def test_log(self):\\n+ step = None\\n+ project_name = \\\"test_project_with_log\\\"\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ oldpwd = os.getcwd()\\n+ os.chdir(dirpath)\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator.init_trackers(project_name)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ accelerator.end_training()\\n+ # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord\\n+ # Names are randomly generated each time\\n+ log = list(filter(lambda x: x.is_file(), Path(project_name).iterdir()))[0]\\n+ serialized_examples = tf.data.TFRecordDataset(log)\\n+ for e in serialized_examples:\\n+ event = event_pb2.Event.FromString(e.numpy())\\n+ if step is None:\\n+ step = event.step\\n+ for value in event.summary.value:\\n+ if value.tag == \\\"total_loss\\\":\\n+ total_loss = value.simple_value\\n+ elif value.tag == \\\"iteration\\\":\\n+ iteration = value.simple_value\\n+ elif value.tag == \\\"my_text/text_summary\\\": # Append /text_summary to the key\\n+ my_text = value.tensor.string_val[0].decode()\\n+ os.chdir(oldpwd)\\n+ self.assertAlmostEqual(total_loss, values[\\\"total_loss\\\"])\\n+ self.assertEqual(iteration, values[\\\"iteration\\\"])\\n+ self.assertEqual(my_text, values[\\\"my_text\\\"])\\n+\\n+\\n+@mock.patch.dict(os.environ, {\\\"WANDB_MODE\\\": \\\"offline\\\"})\\n+class WandBTrackingTest(unittest.TestCase):\\n+ @staticmethod\\n+ def get_value_from_log(key: str, log: str, key_occurance: int = 0):\\n+ \\\"\\\"\\\"\\n+ Parses wandb log for `key` and returns the value.\\n+ If parsing through multiple calls to .log, pass in a `key_occurance`\\n+ \\\"\\\"\\\"\\n+ res = re.findall(rf\\\"(?<={key} )[^\\\\s]+\\\", log)[key_occurance]\\n+ if '\\\"' in res:\\n+ return re.findall(r'\\\"([^\\\"]*)\\\"', res)[0]\\n+ else:\\n+ return res\\n+\\n+ def test_init_trackers(self):\\n+ project_name = \\\"test_project_with_config\\\"\\n+ accelerator = Accelerator(log_with=\\\"wandb\\\")\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(project_name, config)\\n+ accelerator.end_training()\\n+ # The latest offline log is stored at wandb/latest-run/*.wandb\\n+ for child in Path(\\\"wandb/latest-run\\\").glob(\\\"*\\\"):\\n+ logger.info(child)\\n+ if child.is_file() and child.suffix == \\\".wandb\\\":\\n+ with open(child, \\\"rb\\\") as f:\\n+ content = f.read()\\n+ break\\n+\\n+ # Check HPS through careful parsing and cleaning\\n+ cleaned_log = re.sub(r\\\"[\\\\x00-\\\\x1f]+\\\", \\\" \\\", content.decode(\\\"utf8\\\", \\\"ignore\\\"))\\n+ self.assertEqual(self.get_value_from_log(\\\"num_iterations\\\", cleaned_log), \\\"12\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"learning_rate\\\", cleaned_log), \\\"0.01\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"some_boolean\\\", cleaned_log), \\\"false\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"some_string\\\", cleaned_log), \\\"some_value\\\")\\n+\\n+ def test_log(self):\\n+ project_name = \\\"test_project_with_log\\\"\\n+ accelerator = Accelerator(log_with=\\\"wandb\\\")\\n+ accelerator.init_trackers(project_name)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ accelerator.end_training()\\n+ # The latest offline log is stored at wandb/latest-run/*.wandb\\n+ for child in Path(\\\"wandb/latest-run\\\").glob(\\\"*\\\"):\\n+ if child.is_file() and child.suffix == \\\".wandb\\\":\\n+ with open(child, \\\"rb\\\") as f:\\n+ content = f.read()\\n+ break\\n+ # Check HPS through careful parsing and cleaning\\n+ cleaned_log = re.sub(r\\\"[\\\\x00-\\\\x1f]+\\\", \\\" \\\", content.decode(\\\"utf8\\\", \\\"ignore\\\"))\\n+ self.assertEqual(self.get_value_from_log(\\\"total_loss\\\", cleaned_log), \\\"0.1\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"iteration\\\", cleaned_log), \\\"1\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"my_text\\\", cleaned_log), \\\"some_value\\\")\\n+ self.assertEqual(self.get_value_from_log(\\\"_step\\\", cleaned_log), \\\"0\\\")\\n+\\n+ def setUp(self):\\n+ os.mkdir(\\\".wandb_tests\\\")\\n+ os.chdir(\\\".wandb_tests\\\")\\n+\\n+ def tearDown(self):\\n+ if os.getcwd().endswith(\\\".wandb_tests\\\"):\\n+ os.chdir(\\\"..\\\")\\n+ if os.path.exists(\\\".wandb_tests\\\"):\\n+ shutil.rmtree(\\\".wandb_tests\\\")\\n+\\n+ @classmethod\\n+ def setUpClass(cls):\\n+ if os.path.exists(\\\".wandb_tests\\\"):\\n+ shutil.rmtree(\\\".wandb_tests\\\")\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\nfrom .tracking import TensorBoardTracker\\r\\n```\\r\\n:scream: \",\n \"diff_hunk\": \"@@ -17,10 +17,12 @@\\n import sys\\n import warnings\\n from contextlib import contextmanager\\n+from pathlib import Path\\n from typing import List, Optional, Union\\n \\n import torch\\n \\n+from accelerate.accelerate.src.accelerate.tracking import TensorBoardTracker\",\n \"from_author\": false\n },\n {\n \"body\": \"The `\\\"all\\\"` should be dealt with around here too.\",\n \"diff_hunk\": \"@@ -111,9 +115,17 @@ def __init__(\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n+ log_with: Optional[List[Union[LoggerType, str]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ if log_with is not None:\\n+ if not isinstance(log_with, list):\",\n \"from_author\": false\n },\n {\n \"body\": \"Nice!\",\n \"diff_hunk\": \"@@ -556,6 +568,30 @@ def wait_for_everyone(self):\\n \\\"\\\"\\\"\\n wait_for_everyone()\\n \\n+ def init_trackers(self, project_name: str, config: dict = None):\\n+ \\\"\\\"\\\"\\n+ Initializes a run for all trackers stored in `self.log_with`, potentially with starting configurations\\n+\\n+ Args:\\n+ project_name (`str`):\\n+ \\\"\\\"\\\"\\n+ project_location = Path(project_name)\\n+ self.trackers = []\\n+ for tracker in self.log_with:\\n+ if tracker.lower() == \\\"tensorboard\\\" and is_tensorboard_available():\\n+ self.trackers.append(TensorBoardTracker(project_location))\\n+ if config is not None:\\n+ for tracker in self.trackers:\\n+ tracker.store_init_configuration(config)\",\n \"from_author\": false\n },\n {\n \"body\": \"Should be inside an `is_tensorboard_available` flag.\",\n \"diff_hunk\": \"@@ -0,0 +1,72 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+\\n+from torch.utils import tensorboard\",\n \"from_author\": false\n },\n {\n \"body\": \"Accelerate has no idea about the global step though. We could add it in an optional argument to `log`? Or add something that keeps track of the number of time the `optimizer.step` is called internally.\",\n \"diff_hunk\": \"@@ -0,0 +1,72 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+\\n+from torch.utils import tensorboard\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ log_directory = \\\"tensorboard\\\"\\n+\\n+ def __init__(self, run_name=\\\"\\\"):\\n+ self.run_name = Path(run_name)\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values):\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ # add_scalar has the option for `global_step`, should we include this?\",\n \"from_author\": false\n },\n {\n \"body\": \"That's more or less what my thinking is, having it be an optional argument. I don't think there's a need for us to keep track of `optimizer.step` calls internally for this yet, but we'll see what changes as this develops\",\n \"diff_hunk\": \"@@ -0,0 +1,72 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+\\n+from torch.utils import tensorboard\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ log_directory = \\\"tensorboard\\\"\\n+\\n+ def __init__(self, run_name=\\\"\\\"):\\n+ self.run_name = Path(run_name)\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values):\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ # add_scalar has the option for `global_step`, should we include this?\",\n \"from_author\": true\n },\n {\n \"body\": \"*That is what we call VSCode not being friendly and me missing it!*\",\n \"diff_hunk\": \"@@ -17,10 +17,12 @@\\n import sys\\n import warnings\\n from contextlib import contextmanager\\n+from pathlib import Path\\n from typing import List, Optional, Union\\n \\n import torch\\n \\n+from accelerate.accelerate.src.accelerate.tracking import TensorBoardTracker\",\n \"from_author\": true\n },\n {\n \"body\": \"Decided to make it an optional argument. If folks seem to find it annoying then we can go ahead and track `optimizer.step` next\",\n \"diff_hunk\": \"@@ -0,0 +1,72 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+\\n+from torch.utils import tensorboard\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ log_directory = \\\"tensorboard\\\"\\n+\\n+ def __init__(self, run_name=\\\"\\\"):\\n+ self.run_name = Path(run_name)\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values):\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ # add_scalar has the option for `global_step`, should we include this?\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\r\\n Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`, `str`,\\r\\n `float`, `int`, or `None`.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\",\n \"from_author\": false\n },\n {\n \"body\": \"Seems to be optional and has a default ;-)\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n step (`int`, *optional*):\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs. Value be of type `int`, `float`, or `str`.\\n+ step (`int`, Optional):\",\n \"from_author\": false\n },\n {\n \"body\": \"Same comment as above for the `run_name` of Tensorboard.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs. Value be of type `int`, `float`, or `str`.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\",\n \"from_author\": false\n },\n {\n \"body\": \"Same comments as above.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs. Value be of type `int`, `float`, or `str`.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+ logger.info(f\\\"Initialized WandB project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\",\n \"from_author\": false\n },\n {\n \"body\": \"And here too ;-)\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs. Value be of type `int`, `float`, or `str`.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+ logger.info(f\\\"Initialized WandB project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ wandb.config(values)\\n+ logger.info(\\\"Stored initial configuration hyperparameters to WandB\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\",\n \"from_author\": false\n },\n {\n \"body\": \"Same comments on the docstrings.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs. Value be of type `int`, `float`, or `str`.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\\n+\\n+ def __init__(self, run_name: str = \\\"\\\"):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+ logger.info(f\\\"Initialized WandB project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. Value be of type `bool`, `str`,\\n+ `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ wandb.config(values)\\n+ logger.info(\\\"Stored initial configuration hyperparameters to WandB\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (`dict`):\\n+ Values to be logged as key-value pairs.\\n+ step (`int`, Optional):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ wandb.log(values, step=step)\\n+ logger.info(\\\"Successfully logged to WandB\\\")\\n+\\n+\\n+class CometMLTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"You'll need to add the `tracking.` prefix to each for the links to work.\",\n \"diff_hunk\": \"@@ -0,0 +1,142 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Tracking\\n+\\n+There are a large number of experiment tracking API's available, however getting them all to work with in a multi-processing environment can oftentimes be complex.\\n+Accelerate provides a general tracking API that can be used to log useful items during your script through [`~Accelerator.log`]\\n+\\n+## Integrated Trackers\\n+\\n+Currently `Accelerate` supports three trackers out-of-the-box:\\n+- [`~TensorBoardTracker`]\\n+- [`~WandBTracker`]\\n+- [`~CometMLTracker`]\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n+ run[\\\"logs/training/batch/loss\\\"].log(loss)\\r\\n```\\r\\n4 spaces please :-)\",\n \"diff_hunk\": \"@@ -0,0 +1,142 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Tracking\\n+\\n+There are a large number of experiment tracking API's available, however getting them all to work with in a multi-processing environment can oftentimes be complex.\\n+Accelerate provides a general tracking API that can be used to log useful items during your script through [`~Accelerator.log`]\\n+\\n+## Integrated Trackers\\n+\\n+Currently `Accelerate` supports three trackers out-of-the-box:\\n+- [`~TensorBoardTracker`]\\n+- [`~WandBTracker`]\\n+- [`~CometMLTracker`]\\n+\\n+To use any of them, pass in the selected type(s) to the `log_with` parameter in [`~Accelerate.__init__`]:\\n+```python\\n+from accelerate import Accelerate\\n+from accelerate.utils import LoggerType\\n+\\n+accelerator = Accelerate(log_with=\\\"all\\\") # For all available trackers in the environment\\n+accelerator = Accelerate(log_with=\\\"wandb\\\")\\n+accelerator = Accelerate(log_with=[\\\"wandb\\\", LoggerType.TENSORBOARD])\\n+```\\n+\\n+At the start of your experiment [`~Accelerator.init_tracker`] should be used to setup your project, and potentially add any experiment hyperparameters to be logged:\\n+```python\\n+hps = {\\\"num_iterations\\\": 5, \\\"learning_rate\\\": 1e-2}\\n+accelerator.init_trackers(\\\"my_project\\\", config=hps)\\n+```\\n+\\n+When you are ready to log any data, [`~Accelerator.log`] should be used.\\n+A `step` can also be passed in to correlate the data with a particular step in the training loop.\\n+```python\\n+accelerator.log({\\\"train_loss\\\": 1.12, \\\"valid_loss\\\": 0.8}, step=1)\\n+```\\n+\\n+A full example is below:\\n+```python\\n+from accelerate import Accelerator\\n+\\n+accelerator = Accelerator(log_with=\\\"all\\\")\\n+config = {\\n+ \\\"num_iterations\\\": 5,\\n+ \\\"learning_rate\\\": 1e-2,\\n+ \\\"loss_function\\\": str(my_loss_function),\\n+}\\n+\\n+accelerator.init_trackers(\\\"example_project\\\", config=config)\\n+\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+for iteration in config[\\\"num_iterations\\\"]:\\n+ for step, batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+ accelerator.log({\\\"training_loss\\\": loss}, step=step)\\n+```\\n+\\n+[[autodoc]] tracking.TensorBoardTracker\\n+\\n+[[autodoc]] tracking.WandBTracker\\n+\\n+[[autodoc]] tracking.CometMLTracker\\n+\\n+\\n+## Implementing Custom Trackers\\n+\\n+To implement a new tracker to be used in `Accelerator`, a new one can be made through implementing the [`~GeneralTracker`] class.\\n+Every tracker must implement three functions:\\n+ - `__init__`: Should store a `run_name` and initialize the tracker API of the integrated library\\n+ - `store_init_configuration`: Should take in a `values` dictionary and store them as a one-time experiment configuration\\n+ - `log`: Should take in a `values` dictionary and a `step`, and should log them to the run\\n+As well as contain a `log_directory` attribute. If the integrated library does not store anything locally, should be set to `None`.\\n+\\n+A brief example can be seen below with an integration with Weights and Biases, containing only the relevent information:\\n+```python\\n+from accelerate.tracking import GeneralTracker\\n+from typing import Optional\\n+\\n+import wandb\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ log_directory = None\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ wandb.config(values)\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ wandb.log(values, step=step)\\n+```\\n+\\n+## When a wrapper cannot work\\n+\\n+If a library has an API that does not follow a strict `.log` with an overall dictionary such as Neptune.AI, logging can be done manually under an `if accelerator.is_main_process` statement:\\n+```diff\\n+from accelerate import Accelerator\\n++ import neptune.new as neptune\\n+\\n+accelerator = Accelerator()\\n++ run = neptune.init(...)\\n+\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+for iteration in config[\\\"num_iterations\\\"]:\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ total_loss += loss\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n++ if accelerator.is_main_process:\\n++ run[\\\"logs/training/batch/loss\\\"].log(loss)\",\n \"from_author\": false\n },\n {\n \"body\": \"This call should be done at the Tracker level.\",\n \"diff_hunk\": \"@@ -556,6 +585,39 @@ def wait_for_everyone(self):\\n \\\"\\\"\\\"\\n wait_for_everyone()\\n \\n+ def init_trackers(self, project_name: str, config: Optional[dict] = None):\\n+ \\\"\\\"\\\"\\n+ Initializes a run for all trackers stored in `self.log_with`, potentially with starting configurations\\n+\\n+ Args:\\n+ project_name (`str`):\\n+ The name of the project. All trackers will save their data based on this\\n+ config (`dict`, *optional*):\\n+ Optional starting configuration to be logged.\\n+ \\\"\\\"\\\"\\n+ project_location = Path(project_name)\",\n \"from_author\": false\n },\n {\n \"body\": \"The logging_dir should also be something that could be customized and default to the usual PyTorch default.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\",\n \"from_author\": false\n },\n {\n \"body\": \"This variable doesn't seem used.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"This doesn't seem used either.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\\n+ logger.info(f\\\"Initialized TensorBoard project {self.run_name} writing to {self.logging_dir}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ self.writer.add_hparams(values, metric_dict={})\\n+ self.writer.flush()\\n+ logger.info(\\\"Stored initial configuration hyperparameters to TensorBoard\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ for k, v in values.items():\\n+ if isinstance(v, (int, float)):\\n+ self.writer.add_scalar(k, v, global_step=step)\\n+ elif isinstance(v, str):\\n+ self.writer.add_text(k, v, global_step=step)\\n+ self.writer.flush()\\n+ logger.info(\\\"Successfully logged to TensorBoard\\\")\\n+\\n+\\n+class WandBTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `wandb`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ wandb.init(self.run_name)\\n+ logger.info(f\\\"Initialized WandB project {self.run_name}\\\")\\n+ logger.info(\\n+ \\\"Make sure to log any initial configurations with `self.store_init_configuration` before training!\\\"\\n+ )\\n+\\n+ def store_init_configuration(self, values: dict):\\n+ \\\"\\\"\\\"\\n+ Logs `values` as hyperparameters for the run. Should be run at the beginning of your experiment.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `bool`, `str`, `float` or `int`):\\n+ Values to be stored as initial hyperparameters as key-value pairs. The values need to have type `bool`,\\n+ `str`, `float`, `int`, or `None`.\\n+ \\\"\\\"\\\"\\n+ wandb.config(values)\\n+ logger.info(\\\"Stored initial configuration hyperparameters to WandB\\\")\\n+\\n+ def log(self, values: dict, step: Optional[int] = None):\\n+ \\\"\\\"\\\"\\n+ Logs `values` to the current run.\\n+\\n+ Args:\\n+ values (Dictionary `str` to `str`, `float`, or `int`):\\n+ Values to be logged as key-value pairs. The values need to have type `str`, `float`, or `int`.\\n+ step (`int`, *optional*):\\n+ The run step. If included, the log will be affiliated with this step.\\n+ \\\"\\\"\\\"\\n+ wandb.log(values, step=step)\\n+ logger.info(\\\"Successfully logged to WandB\\\")\\n+\\n+\\n+class CometMLTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `comet_ml`. Should be initialized at the start of your script.\\n+\\n+ API keys must be stored in a Comet config file.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = None\",\n \"from_author\": false\n },\n {\n \"body\": \"We should remove this from the abtract class as it's not required for all of the trackers.\",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\",\n \"from_author\": false\n },\n {\n \"body\": \"`logging_dir` and `run_name` are actually the same when it comes to `tensorboard`, and we can't have both. So something like this won't work: \\r\\n```python\\r\\nwriterC = SummaryWriter(\\\"Testme\\\", comment=\\\"LR_0.1_BATCH_16\\\")\\r\\n```\\r\\nSo we can just remove this completely. \",\n \"diff_hunk\": \"@@ -0,0 +1,210 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+# Expectation:\\n+# Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}\\n+\\n+import logging\\n+from abc import ABCMeta, abstractmethod\\n+from pathlib import Path\\n+from typing import Optional\\n+\\n+from .utils import LoggerType, is_comet_ml_available, is_tensorboard_available, is_wandb_available\\n+\\n+\\n+_available_trackers = []\\n+\\n+if is_tensorboard_available():\\n+ from torch.utils import tensorboard\\n+\\n+ _available_trackers.append(LoggerType.TENSORBOARD)\\n+\\n+if is_wandb_available():\\n+ import wandb\\n+\\n+ _available_trackers.append(LoggerType.WANDB)\\n+\\n+if is_comet_ml_available():\\n+ from comet_ml import Experiment\\n+\\n+ _available_trackers.append(LoggerType.COMETML)\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def get_available_trackers():\\n+ \\\"Returns a list of all supported available trackers in the system\\\"\\n+ return _available_trackers\\n+\\n+\\n+class GeneralTracker(object, metaclass=ABCMeta):\\n+ \\\"\\\"\\\"\\n+ A base Tracker class to be used for all logging integration implementations.\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory: str\\n+\\n+ @abstractmethod\\n+ def store_init_configuration(self, values):\\n+ pass\\n+\\n+ @abstractmethod\\n+ def log(self, values, step: Optional[int]):\\n+ pass\\n+\\n+\\n+class TensorBoardTracker(GeneralTracker):\\n+ \\\"\\\"\\\"\\n+ A `Tracker` class that supports `tensorboard`. Should be initialized at the start of your script.\\n+\\n+ Args:\\n+ run_name (`str`):\\n+ The name of the experiment run. Logs are then stored in `tensorboard/{run_name}`\\n+ \\\"\\\"\\\"\\n+\\n+ log_directory = Path(\\\"tensorboard\\\")\\n+\\n+ def __init__(self, run_name: str):\\n+ self.run_name = run_name\\n+ self.writer = tensorboard.SummaryWriter(self.logging_dir / self.run_name)\",\n \"from_author\": true\n },\n {\n \"body\": \"Not following why we have to add TensoFlow here. Can't it be just `tensorboard`?\",\n \"diff_hunk\": \"@@ -21,6 +21,8 @@\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n \\\"pytest-xdist\\\",\\n+ \\\"tensorflow\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"It would probably be best to use a temporary directory here, to avoid users running the tests locally getting this folder.\",\n \"diff_hunk\": \"@@ -0,0 +1,89 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import shutil\\n+import unittest\\n+from pathlib import Path\\n+\\n+# We use TF to parse the logs\\n+import tensorflow as tf\\n+from accelerate import Accelerator\\n+from tensorboard.plugins.hparams import plugin_data_pb2\\n+from tensorflow.core.util import event_pb2\\n+from tensorflow.python.summary.summary_iterator import summary_iterator\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class TensorBoardTrackingTest(unittest.TestCase):\\n+ @classmethod\\n+ def teardown_class(cls):\\n+ shutil.rmtree(\\\"test_project_with_config\\\")\\n+ shutil.rmtree(\\\"test_project_with_log\\\")\\n+\\n+ def test_init_trackers(self):\\n+ hps = None\\n+ project_name = \\\"test_project_with_config\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -0,0 +1,89 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import shutil\\n+import unittest\\n+from pathlib import Path\\n+\\n+# We use TF to parse the logs\\n+import tensorflow as tf\\n+from accelerate import Accelerator\\n+from tensorboard.plugins.hparams import plugin_data_pb2\\n+from tensorflow.core.util import event_pb2\\n+from tensorflow.python.summary.summary_iterator import summary_iterator\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class TensorBoardTrackingTest(unittest.TestCase):\\n+ @classmethod\\n+ def teardown_class(cls):\\n+ shutil.rmtree(\\\"test_project_with_config\\\")\\n+ shutil.rmtree(\\\"test_project_with_log\\\")\\n+\\n+ def test_init_trackers(self):\\n+ hps = None\\n+ project_name = \\\"test_project_with_config\\\"\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(project_name, config)\\n+ for child in Path(project_name).glob(\\\"*/**\\\"):\\n+ log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n+ # The config log is stored one layer deeper in the logged directory\\n+ # And names are randomly generated each time\\n+ si = summary_iterator(str(log))\\n+ # Pull HPS through careful parsing\\n+ for event in si:\\n+ for value in event.summary.value:\\n+ proto_bytes = value.metadata.plugin_data.content\\n+ plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n+ if plugin_data.HasField(\\\"session_start_info\\\"):\\n+ hps = dict(plugin_data.session_start_info.hparams)\\n+\\n+ self.assertTrue(isinstance(hps, dict))\\n+ keys = list(hps.keys())\\n+ keys.sort()\\n+ self.assertEqual(keys, [\\\"learning_rate\\\", \\\"num_iterations\\\", \\\"some_boolean\\\", \\\"some_string\\\"])\\n+ self.assertEqual(hps[\\\"num_iterations\\\"].number_value, 12)\\n+ self.assertEqual(hps[\\\"learning_rate\\\"].number_value, 0.01)\\n+ self.assertEqual(hps[\\\"some_boolean\\\"].bool_value, False)\\n+ self.assertEqual(hps[\\\"some_string\\\"].string_value, \\\"some_value\\\")\\n+\\n+ def test_log(self):\\n+ step = None\\n+ project_name = \\\"test_project_with_log\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Is it why the TF dep is necessary? There is really no other way to load a TensorBoard log?\",\n \"diff_hunk\": \"@@ -0,0 +1,89 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import shutil\\n+import unittest\\n+from pathlib import Path\\n+\\n+# We use TF to parse the logs\\n+import tensorflow as tf\\n+from accelerate import Accelerator\\n+from tensorboard.plugins.hparams import plugin_data_pb2\\n+from tensorflow.core.util import event_pb2\\n+from tensorflow.python.summary.summary_iterator import summary_iterator\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class TensorBoardTrackingTest(unittest.TestCase):\\n+ @classmethod\\n+ def teardown_class(cls):\\n+ shutil.rmtree(\\\"test_project_with_config\\\")\\n+ shutil.rmtree(\\\"test_project_with_log\\\")\\n+\\n+ def test_init_trackers(self):\\n+ hps = None\\n+ project_name = \\\"test_project_with_config\\\"\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(project_name, config)\\n+ for child in Path(project_name).glob(\\\"*/**\\\"):\\n+ log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n+ # The config log is stored one layer deeper in the logged directory\\n+ # And names are randomly generated each time\\n+ si = summary_iterator(str(log))\\n+ # Pull HPS through careful parsing\\n+ for event in si:\\n+ for value in event.summary.value:\\n+ proto_bytes = value.metadata.plugin_data.content\\n+ plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n+ if plugin_data.HasField(\\\"session_start_info\\\"):\\n+ hps = dict(plugin_data.session_start_info.hparams)\\n+\\n+ self.assertTrue(isinstance(hps, dict))\\n+ keys = list(hps.keys())\\n+ keys.sort()\\n+ self.assertEqual(keys, [\\\"learning_rate\\\", \\\"num_iterations\\\", \\\"some_boolean\\\", \\\"some_string\\\"])\\n+ self.assertEqual(hps[\\\"num_iterations\\\"].number_value, 12)\\n+ self.assertEqual(hps[\\\"learning_rate\\\"].number_value, 0.01)\\n+ self.assertEqual(hps[\\\"some_boolean\\\"].bool_value, False)\\n+ self.assertEqual(hps[\\\"some_string\\\"].string_value, \\\"some_value\\\")\\n+\\n+ def test_log(self):\\n+ step = None\\n+ project_name = \\\"test_project_with_log\\\"\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator.init_trackers(project_name)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord\\n+ # Names are randomly generated each time\\n+ log = list(filter(lambda x: x.is_file(), Path(project_name).iterdir()))[0]\\n+ serialized_examples = tf.data.TFRecordDataset(log)\",\n \"from_author\": false\n },\n {\n \"body\": \"Yup, sadly: https://github.com/tensorflow/tensorboard#how-can-i-export-data-from-tensorboard\\r\\n\\r\\nWe have to use `tf` to parse it back in. \",\n \"diff_hunk\": \"@@ -0,0 +1,89 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import shutil\\n+import unittest\\n+from pathlib import Path\\n+\\n+# We use TF to parse the logs\\n+import tensorflow as tf\\n+from accelerate import Accelerator\\n+from tensorboard.plugins.hparams import plugin_data_pb2\\n+from tensorflow.core.util import event_pb2\\n+from tensorflow.python.summary.summary_iterator import summary_iterator\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+class TensorBoardTrackingTest(unittest.TestCase):\\n+ @classmethod\\n+ def teardown_class(cls):\\n+ shutil.rmtree(\\\"test_project_with_config\\\")\\n+ shutil.rmtree(\\\"test_project_with_log\\\")\\n+\\n+ def test_init_trackers(self):\\n+ hps = None\\n+ project_name = \\\"test_project_with_config\\\"\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n+ accelerator.init_trackers(project_name, config)\\n+ for child in Path(project_name).glob(\\\"*/**\\\"):\\n+ log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n+ # The config log is stored one layer deeper in the logged directory\\n+ # And names are randomly generated each time\\n+ si = summary_iterator(str(log))\\n+ # Pull HPS through careful parsing\\n+ for event in si:\\n+ for value in event.summary.value:\\n+ proto_bytes = value.metadata.plugin_data.content\\n+ plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n+ if plugin_data.HasField(\\\"session_start_info\\\"):\\n+ hps = dict(plugin_data.session_start_info.hparams)\\n+\\n+ self.assertTrue(isinstance(hps, dict))\\n+ keys = list(hps.keys())\\n+ keys.sort()\\n+ self.assertEqual(keys, [\\\"learning_rate\\\", \\\"num_iterations\\\", \\\"some_boolean\\\", \\\"some_string\\\"])\\n+ self.assertEqual(hps[\\\"num_iterations\\\"].number_value, 12)\\n+ self.assertEqual(hps[\\\"learning_rate\\\"].number_value, 0.01)\\n+ self.assertEqual(hps[\\\"some_boolean\\\"].bool_value, False)\\n+ self.assertEqual(hps[\\\"some_string\\\"].string_value, \\\"some_value\\\")\\n+\\n+ def test_log(self):\\n+ step = None\\n+ project_name = \\\"test_project_with_log\\\"\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator.init_trackers(project_name)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord\\n+ # Names are randomly generated each time\\n+ log = list(filter(lambda x: x.is_file(), Path(project_name).iterdir()))[0]\\n+ serialized_examples = tf.data.TFRecordDataset(log)\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n Should run any finalizing functions within the tracking API. If the API should not have one, just don't overwrite that method.\\r\\n```\",\n \"diff_hunk\": \"@@ -80,6 +80,16 @@ def log(self, values: dict, step: Optional[int]):\\n \\\"\\\"\\\"\\n pass\\n \\n+ @abstractmethod\\n+ def finish(self):\\n+ \\\"\\\"\\\"\\n+ Should run any finalizing functions within the tracking API. If the API should not have one, just return:\\n+ ```python\\n+ super().finish()\\n+ ```\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n```\\r\\nNo need to write something as calling the super method is then the default ;-)\",\n \"diff_hunk\": \"@@ -218,3 +242,7 @@ def log(self, values: dict, step: Optional[int] = None):\\n self.writer.set_step(step)\\n self.writer.log_others(values)\\n logger.info(\\\"Successfully logged to CometML\\\")\\n+\\n+ def finish(self):\\n+ \\\"\\\"\\\"Do nothing\\\"\\\"\\\"\\n+ super().finish()\",\n \"from_author\": false\n },\n {\n \"body\": \"I'd like to avoid this. The API should accept any logging dir for TensorBoard at least, no?\",\n \"diff_hunk\": \"@@ -29,29 +32,29 @@\\n \\n \\n class TensorBoardTrackingTest(unittest.TestCase):\\n- @classmethod\\n- def teardown_class(cls):\\n- shutil.rmtree(\\\"test_project_with_config\\\")\\n- shutil.rmtree(\\\"test_project_with_log\\\")\\n-\\n def test_init_trackers(self):\\n hps = None\\n project_name = \\\"test_project_with_config\\\"\\n- accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n- config = {\\\"num_iterations\\\": 12, \\\"learning_rate\\\": 1e-2, \\\"some_boolean\\\": False, \\\"some_string\\\": \\\"some_value\\\"}\\n- accelerator.init_trackers(project_name, config)\\n- for child in Path(project_name).glob(\\\"*/**\\\"):\\n- log = list(filter(lambda x: x.is_file(), child.iterdir()))[0]\\n- # The config log is stored one layer deeper in the logged directory\\n- # And names are randomly generated each time\\n- si = summary_iterator(str(log))\\n- # Pull HPS through careful parsing\\n- for event in si:\\n- for value in event.summary.value:\\n- proto_bytes = value.metadata.plugin_data.content\\n- plugin_data = plugin_data_pb2.HParamsPluginData.FromString(proto_bytes)\\n- if plugin_data.HasField(\\\"session_start_info\\\"):\\n- hps = dict(plugin_data.session_start_info.hparams)\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ oldpwd = os.getcwd()\\n+ os.chdir(dirpath)\",\n \"from_author\": false\n },\n {\n \"body\": \"Would be nice to have a `logging_dir` argument in the `Accelerator` I realize.\",\n \"diff_hunk\": \"@@ -64,26 +67,90 @@ def test_init_trackers(self):\\n \\n def test_log(self):\\n step = None\\n+ project_name = \\\"test_project_with_log\\\"\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ oldpwd = os.getcwd()\\n+ os.chdir(dirpath)\\n+ accelerator = Accelerator(log_with=\\\"tensorboard\\\")\\n+ accelerator.init_trackers(project_name)\\n+ values = {\\\"total_loss\\\": 0.1, \\\"iteration\\\": 1, \\\"my_text\\\": \\\"some_value\\\"}\\n+ accelerator.log(values, step=0)\\n+ accelerator.end_training()\\n+ # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord\\n+ # Names are randomly generated each time\\n+ log = list(filter(lambda x: x.is_file(), Path(project_name).iterdir()))[0]\\n+ serialized_examples = tf.data.TFRecordDataset(log)\\n+ for e in serialized_examples:\\n+ event = event_pb2.Event.FromString(e.numpy())\\n+ if step is None:\\n+ step = event.step\\n+ for value in event.summary.value:\\n+ if value.tag == \\\"total_loss\\\":\\n+ total_loss = value.simple_value\\n+ elif value.tag == \\\"iteration\\\":\\n+ iteration = value.simple_value\\n+ elif value.tag == \\\"my_text/text_summary\\\": # Append /text_summary to the key\\n+ my_text = value.tensor.string_val[0].decode()\\n+ os.chdir(oldpwd)\\n+ self.assertAlmostEqual(total_loss, values[\\\"total_loss\\\"])\\n+ self.assertEqual(iteration, values[\\\"iteration\\\"])\\n+ self.assertEqual(my_text, values[\\\"my_text\\\"])\\n+\\n+\\n+@mock.patch.dict(os.environ, {\\\"WANDB_MODE\\\": \\\"offline\\\"})\\n+class WandBTrackingTest(unittest.TestCase):\\n+ @staticmethod\\n+ def get_value_from_log(key: str, log: str, key_occurance: int = 0):\\n+ \\\"\\\"\\\"\\n+ Parses wandb log for `key` and returns the value.\\n+ If parsing through multiple calls to .log, pass in a `key_occurance`\\n+ \\\"\\\"\\\"\\n+ res = re.findall(rf\\\"(?<={key} )[^\\\\s]+\\\", log)[key_occurance]\\n+ if '\\\"' in res:\\n+ return re.findall(r'\\\"([^\\\"]*)\\\"', res)[0]\\n+ else:\\n+ return res\\n+\\n+ def test_init_trackers(self):\\n+ project_name = \\\"test_project_with_config\\\"\\n+ with tempfile.TemporaryDirectory() as dirpath:\\n+ oldpwd = os.getcwd()\\n+ os.chdir(dirpath)\",\n \"from_author\": false\n },\n {\n \"body\": \"No need to do a separate job, they can all go in the same one!\",\n \"diff_hunk\": \"@@ -12,6 +12,19 @@ jobs:\\n with:\\n python-version: 3.6\\n - name: Install Python dependencies\\n- run: pip install -e .[test]\\n+ run: pip install -e .[test,trackers]\\n - name: Run Tests\\n- run: make test\\n\\\\ No newline at end of file\\n+ run: make test\\n+\\n+ test-tf:\",\n \"from_author\": false\n },\n {\n \"body\": \"We should mention the train end method in this example, since it's relevant for trackers.\",\n \"diff_hunk\": \"@@ -0,0 +1,137 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Tracking\\n+\\n+There are a large number of experiment tracking API's available, however getting them all to work with in a multi-processing environment can oftentimes be complex.\\n+Accelerate provides a general tracking API that can be used to log useful items during your script through [`~Accelerator.log`]\\n+\\n+## Integrated Trackers\\n+\\n+Currently `Accelerate` supports three trackers out-of-the-box:\\n+\\n+\\n+[[autodoc]] tracking.TensorBoardTracker\\n+\\n+[[autodoc]] tracking.WandBTracker\\n+\\n+[[autodoc]] tracking.CometMLTracker\\n+\\n+To use any of them, pass in the selected type(s) to the `log_with` parameter in [`~Accelerate.__init__`]:\\n+```python\\n+from accelerate import Accelerate\\n+from accelerate.utils import LoggerType\\n+\\n+accelerator = Accelerate(log_with=\\\"all\\\") # For all available trackers in the environment\\n+accelerator = Accelerate(log_with=\\\"wandb\\\")\\n+accelerator = Accelerate(log_with=[\\\"wandb\\\", LoggerType.TENSORBOARD])\\n+```\\n+\\n+At the start of your experiment [`~Accelerator.init_tracker`] should be used to setup your project, and potentially add any experiment hyperparameters to be logged:\\n+```python\\n+hps = {\\\"num_iterations\\\": 5, \\\"learning_rate\\\": 1e-2}\\n+accelerator.init_trackers(\\\"my_project\\\", config=hps)\\n+```\\n+\\n+When you are ready to log any data, [`~Accelerator.log`] should be used.\\n+A `step` can also be passed in to correlate the data with a particular step in the training loop.\\n+```python\\n+accelerator.log({\\\"train_loss\\\": 1.12, \\\"valid_loss\\\": 0.8}, step=1)\\n+```\\n+\\n+A full example is below:\\n+```python\\n+from accelerate import Accelerator\\n+\\n+accelerator = Accelerator(log_with=\\\"all\\\")\\n+config = {\\n+ \\\"num_iterations\\\": 5,\\n+ \\\"learning_rate\\\": 1e-2,\\n+ \\\"loss_function\\\": str(my_loss_function),\\n+}\\n+\\n+accelerator.init_trackers(\\\"example_project\\\", config=config)\\n+\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+for iteration in config[\\\"num_iterations\\\"]:\\n+ for step, batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+ accelerator.log({\\\"training_loss\\\": loss}, step=step)\\n+```\",\n \"from_author\": false\n },\n {\n \"body\": \"I would group those together.\",\n \"diff_hunk\": \"@@ -20,9 +20,11 @@\\n extras[\\\"docs\\\"] = []\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n- \\\"pytest-xdist\\\",\\n+ \\\"pytest-xdist\\\"\\n ]\\n-extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\n+extras[\\\"trackers\\\"] = [\\\"wandb\\\", \\\"comet-ml\\\"]\\n+extras[\\\"test_trackers\\\"] = [\\\"tensorflow\\\"]\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nextras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\r\\n```\\r\\nPlease let's not include all the trackers in dev ;-)\",\n \"diff_hunk\": \"@@ -20,9 +20,11 @@\\n extras[\\\"docs\\\"] = []\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n- \\\"pytest-xdist\\\",\\n+ \\\"pytest-xdist\\\"\\n ]\\n-extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\n+extras[\\\"trackers\\\"] = [\\\"wandb\\\", \\\"comet-ml\\\"]\\n+extras[\\\"test_trackers\\\"] = [\\\"tensorflow\\\"]\\n+extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"] + extras[\\\"trackers\\\"]\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"Given https://github.com/huggingface/accelerate/issues/291#issuecomment-1080771134, this PR is feature-complete. Only thing missing is tests for TensorBoard and potential mocking, and other documentation. But otherwise it's ready for a review\",\n \"from_author\": true\n },\n {\n \"body\": \"Last review, this time for the docs! π π \",\n \"from_author\": true\n },\n {\n \"body\": \"There's a weird issue when doing `pip install tensorflow` where it will just install a higher `setuptools`, and that setuptools will break importing pytorch. pinning it in the dev requirements \\\"fixes\\\" it. Need to play with it more, but a test is there. Once that's solved we probably should mimic something like this for the TF tests as well, since this goes through and looks at the actual values stored\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/293\",\n \"pr_id\": 888735312\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 4f2a79bcd..2b623db34 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -30,6 +30,7 @@\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n from .utils import (\\n DeepSpeedPlugin,\\n+ PrecisionType,\\n RNGType,\\n convert_outputs_to_fp32,\\n extract_model_from_parallel,\\n@@ -106,19 +107,18 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n- mixed_precision: str = None,\\n+ mixed_precision: Union[PrecisionType, str] = None,\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n-\\n if mixed_precision is not None:\\n- mixed_precision = mixed_precision.lower()\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ mixed_precision = str(mixed_precision)\\n+ if mixed_precision not in PrecisionType:\\n raise ValueError(\\n- f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+ f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between {PrecisionType.list()}\\\"\\n )\\n \\n if fp16:\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex ff1b148f4..dd946c85d 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -27,7 +27,7 @@\\n from accelerate.commands.config import default_config_file, load_config_from_file\\n from accelerate.commands.config.config_args import SageMakerConfig\\n from accelerate.state import ComputeEnvironment, DistributedType\\n-from accelerate.utils import PrepareForLaunch, is_sagemaker_available\\n+from accelerate.utils import PrecisionType, PrepareForLaunch, is_sagemaker_available\\n \\n \\n def launch_command_parser(subparsers=None):\\n@@ -163,10 +163,12 @@ def simple_launcher(args):\\n \\n current_env = os.environ.copy()\\n current_env[\\\"USE_CPU\\\"] = str(args.cpu)\\n-\\n- mixed_precision = args.mixed_precision.lower()\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n- raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+ try:\\n+ mixed_precision = PrecisionType(args.mixed_precision.lower())\\n+ except ValueError:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.\\\"\\n+ )\\n \\n if args.fp16:\\n warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n@@ -212,10 +214,12 @@ def multi_gpu_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- mixed_precision = args.mixed_precision.lower()\\n-\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n- raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+ try:\\n+ mixed_precision = PrecisionType(args.mixed_precision.lower())\\n+ except ValueError:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.\\\"\\n+ )\\n \\n if args.fp16:\\n warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n@@ -259,10 +263,12 @@ def deepspeed_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- mixed_precision = args.mixed_precision.lower()\\n-\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n- raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+ try:\\n+ mixed_precision = PrecisionType(args.mixed_precision.lower())\\n+ except ValueError:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.\\\"\\n+ )\\n \\n if args.fp16:\\n warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n@@ -388,10 +394,12 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n print(\\\"Converting Arguments to Hyperparameters\\\")\\n hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n \\n- mixed_precision = args.mixed_precision.lower()\\n-\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n- raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+ try:\\n+ mixed_precision = PrecisionType(args.mixed_precision.lower())\\n+ except ValueError:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.\\\"\\n+ )\\n \\n if args.fp16:\\n warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\ndiff --git a/src/accelerate/launchers.py b/src/accelerate/launchers.py\\nindex 48c4404dd..cfd8929d9 100644\\n--- a/src/accelerate/launchers.py\\n+++ b/src/accelerate/launchers.py\\n@@ -22,7 +22,7 @@\\n from packaging import version\\n \\n from .state import AcceleratorState\\n-from .utils import PrepareForLaunch, patch_environment\\n+from .utils import PrecisionType, PrepareForLaunch, patch_environment\\n \\n \\n def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mixed_precision=\\\"no\\\", use_port=\\\"29500\\\"):\\n@@ -107,10 +107,11 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mix\\n \\\"function.\\\"\\n )\\n \\n- mixed_precision = mixed_precision.lower()\\n- if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ try:\\n+ mixed_precision = PrecisionType(mixed_precision.lower())\\n+ except ValueError:\\n raise ValueError(\\n- f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+ f\\\"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.\\\"\\n )\\n \\n if use_fp16:\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 5b94d7fff..af9299a4f 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -18,7 +18,7 @@\\n from collections.abc import Mapping\\n from contextlib import contextmanager\\n from dataclasses import dataclass, field\\n-from enum import Enum\\n+from enum import Enum, EnumMeta\\n from functools import update_wrapper\\n from typing import Any, List, Optional, Union\\n \\n@@ -51,7 +51,36 @@ def is_sagemaker_available():\\n OPTIMIZER_NAME = \\\"optimizer\\\"\\n \\n \\n-class RNGType(Enum):\\n+class EnumWithContains(EnumMeta):\\n+ \\\"A metaclass that adds the ability to check if `self` contains an item with the `in` operator\\\"\\n+\\n+ def __contains__(cls, item):\\n+ try:\\n+ cls(item)\\n+ except ValueError:\\n+ return False\\n+ return True\\n+\\n+\\n+class BaseEnum(Enum, metaclass=EnumWithContains):\\n+ \\\"An enum class that can get the value of an item with `str(Enum.key)`\\\"\\n+\\n+ def __str__(self):\\n+ return self.value\\n+\\n+ @classmethod\\n+ def list(cls):\\n+ \\\"Method to list all the possible items in `cls`\\\"\\n+ return list(map(lambda item: str(item), cls))\\n+\\n+\\n+class PrecisionType(BaseEnum):\\n+ NO = \\\"no\\\"\\n+ FP16 = \\\"fp16\\\"\\n+ BF16 = \\\"bf16\\\"\\n+\\n+\\n+class RNGType(BaseEnum):\\n TORCH = \\\"torch\\\"\\n CUDA = \\\"cuda\\\"\\n XLA = \\\"xla\\\"\\n\",\n \"code_comments\": [\n {\n \"body\": \"Here I think you might need to convert this in a list for `choices` to work the proper way.\",\n \"diff_hunk\": \"@@ -58,7 +58,7 @@ def launch_command_parser(subparsers=None):\\n \\\"--mixed_precision\\\",\\n default=\\\"no\\\",\\n type=str,\\n- choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ choices=PrecisionType,\",\n \"from_author\": false\n },\n {\n \"body\": \"A small docstring here on what this adds to a regular `Enum` would be great :-)\",\n \"diff_hunk\": \"@@ -51,7 +51,26 @@ def is_sagemaker_available():\\n OPTIMIZER_NAME = \\\"optimizer\\\"\\n \\n \\n-class RNGType(Enum):\\n+class MetaEnum(EnumMeta):\\n+ def __contains__(cls, item):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nclass EnumWithContains(EnumMeta):\\r\\n```\\r\\nnit: the name is not very descriptive on what the metaclass does, would switch to this.\",\n \"diff_hunk\": \"@@ -51,7 +51,36 @@ def is_sagemaker_available():\\n OPTIMIZER_NAME = \\\"optimizer\\\"\\n \\n \\n-class RNGType(Enum):\\n+class MetaEnum(EnumMeta):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nclass BaseEnum(Enum, metaclass=EnumWithContains):\\r\\n```\\r\\nTo go with the suggestion above.\",\n \"diff_hunk\": \"@@ -51,7 +51,36 @@ def is_sagemaker_available():\\n OPTIMIZER_NAME = \\\"optimizer\\\"\\n \\n \\n-class RNGType(Enum):\\n+class MetaEnum(EnumMeta):\\n+ \\\"A metaclass that adds the ability to check if `self` contains an item with the `in` operator\\\"\\n+\\n+ def __contains__(cls, item):\\n+ try:\\n+ cls(item)\\n+ except ValueError:\\n+ return False\\n+ return True\\n+\\n+\\n+class BaseEnum(Enum, metaclass=MetaEnum):\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/292\",\n \"pr_id\": 888471361\n },\n {\n \"diff\": \"diff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml\\nindex 20f963aae..8f266c600 100644\\n--- a/docs/source/_toctree.yml\\n+++ b/docs/source/_toctree.yml\\n@@ -19,4 +19,6 @@\\n title: Kwargs Handlers\\n - local: internal\\n title: Internals\\n+ - local: checkpoint\\n+ title: Checkpointing\\n title: API Reference\\ndiff --git a/docs/source/checkpoint.mdx b/docs/source/checkpoint.mdx\\nnew file mode 100644\\nindex 000000000..26ef21150\\n--- /dev/null\\n+++ b/docs/source/checkpoint.mdx\\n@@ -0,0 +1,60 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Checkpointing\\n+\\n+When training a PyTorch model with Accelerate, you may often want to save and continue a state of training. Doing so requires\\n+saving and loading the model, optimizer, RNG generators, and the GradScaler. Inside Accelerate are two convience functions to achieve this quickly:\\n+- Use [`~Accelerator.save_state`] for saving everything mentioned above to a folder location\\n+- Use [`~Accelerator.load_state`] for loading everything stored from an earlier `save_state`\\n+\\n+It should be noted that the expectation is that those states come from the same training script, they should not be from two separate scripts.\\n+\\n+- By using [`~Accelerator.register_for_checkpointing`], you can register custom objects to be automatically stored or loaded from the two prior functions,\\n+so long as the object has a `state_dict` **and** a `load_state_dict` functionality. This could include objects such as a learning rate scheduler. \\n+\\n+Below is a brief example using checkpointing to save and reload a state during training:\\n+\\n+```python\\n+from accelerate import Accelerator\\n+import torch\\n+\\n+accelerator = Accelerator()\\n+\\n+my_scheduler = torch.optim.lr_scheduler.StepLR(my_optimizer, step_size=1, gamma=0.99)\\n+my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)\\n+\\n+# Register the LR scheduler\\n+accelerate.register_for_checkpointing(my_scheduler)\\n+\\n+# Save the starting state\\n+accelerate.save_state(\\\"my/save/path\\\")\\n+\\n+device = accelerator.device\\n+my_model.to(device)\\n+\\n+# Perform training\\n+for epoch in range(num_epochs):\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+ my_scheduler.step()\\n+\\n+# Restore previous state\\n+accelerate.load_state(\\\"my/save/path\\\")\\n+```\\n\\\\ No newline at end of file\\ndiff --git a/docs/source/quicktour.mdx b/docs/source/quicktour.mdx\\nindex f16047925..b6f539fd0 100644\\n--- a/docs/source/quicktour.mdx\\n+++ b/docs/source/quicktour.mdx\\n@@ -340,6 +340,16 @@ unwrapped_model.load_state_dict(torch.load(filename))\\n \\n Note that since all the model parameters are references to tensors, this will load your weights inside `model`.\\n \\n+## Saving/loading entire states\\n+\\n+When training your model, you may want to save the current state of the model, optimizer, random generators, and potentially LR schedulers to be restored in the _same script_.\\n+You can use `accelerator.save_state` and `accelerator.load_state` respectively to do so, just by simply passing in a save location. \\n+If you have registered any other stateful items to be stored through `accelerator.register_for_checkpointing` they will also be saved and/or loaded.\\n+<Tip>\\n+ Every object passed to `register_for_checkpointing` must have a `load_state_dict` and `save_dict` function to be stored\\n+</Tip>\\n+\\n+\\n ### Gradient clipping\\n \\n If you are using gradient clipping in your script, you should replace the calls to\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\nIt should be noted that the expectation is that those states come from the same training script, they should not be from two separate scripts.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,25 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Checkpointing\\n+\\n+When training a PyTorch model with Accelerate, you may often want to save and continue a state of training. Doing so requires\\n+saving and loading the model, optimizer, RNG generators, and the GradScaler. Inside Accelerate are two convience functions to achieve this quickly:\\n+- Use [`~Accelerator.save_state`] for saving everything mentioned above to a folder location\\n+- Use [`~Accelerator.load_state`] for loading everything stored from an earlier `save_state`\\n+\\n+It should be noted that these states _must_ be from the same contiguous training script, they should not be from two seperate runs or scripts. \",\n \"from_author\": false\n },\n {\n \"body\": \"There is no object in the lib called `Checkpointing`, so this won't work. this is where you should show a full example.\",\n \"diff_hunk\": \"@@ -0,0 +1,25 @@\\n+<!--Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Checkpointing\\n+\\n+When training a PyTorch model with Accelerate, you may often want to save and continue a state of training. Doing so requires\\n+saving and loading the model, optimizer, RNG generators, and the GradScaler. Inside Accelerate are two convience functions to achieve this quickly:\\n+- Use [`~Accelerator.save_state`] for saving everything mentioned above to a folder location\\n+- Use [`~Accelerator.load_state`] for loading everything stored from an earlier `save_state`\\n+\\n+It should be noted that these states _must_ be from the same contiguous training script, they should not be from two seperate runs or scripts. \\n+\\n+- By using [`~Accelerator.register_for_checkpointing`], you can register custom objects to be automatically stored or loaded from the two prior functions,\\n+so long as the object has a `state_dict` **and** a `load_state_dict` functionality. This could include objects such as a learning rate scheduler. \\n+\\n+[[autodoc]] Checkpointing\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/290\",\n \"pr_id\": 886428060\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex fabd3e9fc..f01d06b98 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -14,6 +14,7 @@\\n \\n import gc\\n import os\\n+import sys\\n import warnings\\n from contextlib import contextmanager\\n from typing import List, Optional, Union\\n@@ -705,7 +706,7 @@ def autocast(self):\\n \\n autocast_context.__enter__()\\n yield\\n- autocast_context.__exit__()\\n+ autocast_context.__exit__(*sys.exc_info())\\n else:\\n yield\\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/284\",\n \"pr_id\": 881527884\n },\n {\n \"diff\": \"diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md\\nindex 66b0a8538..3073b3381 100644\\n--- a/CONTRIBUTING.md\\n+++ b/CONTRIBUTING.md\\n@@ -26,7 +26,7 @@ on the awesome projects it made possible, shout out on Twitter every time it has\\n helped you, or simply star the repo to say \\\"thank you\\\".\\n \\n Whichever way you choose to contribute, please be mindful to respect our\\n-[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/main/CODE_OF_CONDUCT.md).\\n \\n ## You can contribute in so many ways!\\n \\n@@ -118,7 +118,7 @@ Follow these steps to start contributing:\\n $ git checkout -b a-descriptive-name-for-my-changes\\n ```\\n \\n- **Do not** work on the `master` branch.\\n+ **Do not** work on the `main` branch.\\n \\n 4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:\\n \\n@@ -184,7 +184,7 @@ Follow these steps to start contributing:\\n \\n ```bash\\n $ git fetch upstream\\n- $ git rebase upstream/master\\n+ $ git rebase upstream/main\\n ```\\n \\n Push the changes to your account using:\\n@@ -220,7 +220,7 @@ See an example of a good PR here: https://github.com/huggingface/accelerate/pull\\n ### Tests\\n \\n An extensive test suite is included to test the library behavior and several examples. Library tests can be found in\\n-the [tests folder](https://github.com/huggingface/accelerate/tree/master/tests).\\n+the [tests folder](https://github.com/huggingface/accelerate/tree/main/tests).\\n \\n We use `pytest` in order to run the tests. From the root of the\\n repository, here's how to run tests with `pytest` for the library:\\ndiff --git a/README.md b/README.md\\nindex c27131808..3e21a3ae1 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -26,7 +26,7 @@ limitations under the License.\\n <img alt=\\\"Build\\\" src=\\\"https://img.shields.io/circleci/build/github/huggingface/transformers/master\\\">\\n </a>\\n -->\\n- <a href=\\\"https://github.com/huggingface/accelerate/blob/master/LICENSE\\\">\\n+ <a href=\\\"https://github.com/huggingface/accelerate/blob/main/LICENSE\\\">\\n <img alt=\\\"License\\\" src=\\\"https://img.shields.io/github/license/huggingface/accelerate.svg?color=blue\\\">\\n </a>\\n <a href=\\\"https://huggingface.co/docs/accelerate/index.html\\\">\\n@@ -35,7 +35,7 @@ limitations under the License.\\n <a href=\\\"https://github.com/huggingface/accelerate/releases\\\">\\n <img alt=\\\"GitHub release\\\" src=\\\"https://img.shields.io/github/release/huggingface/accelerate.svg\\\">\\n </a>\\n- <a href=\\\"https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md\\\">\\n+ <a href=\\\"https://github.com/huggingface/accelerate/blob/main/CODE_OF_CONDUCT.md\\\">\\n <img alt=\\\"Contributor Covenant\\\" src=\\\"https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg\\\">\\n </a>\\n </p>\\ndiff --git a/docs/source/installation.mdx b/docs/source/installation.mdx\\nindex 4564ba00c..be8394af7 100644\\n--- a/docs/source/installation.mdx\\n+++ b/docs/source/installation.mdx\\n@@ -55,9 +55,9 @@ Here is how to quickly install `accelerate` from source:\\n pip install git+https://github.com/huggingface/accelerate\\n ```\\n \\n-Note that this will install not the latest released version, but the bleeding edge `master` version, which you may want to use in case a bug has been fixed since the last official release and a new release hasn't been yet rolled out.\\n+Note that this will install not the latest released version, but the bleeding edge `main` version, which you may want to use in case a bug has been fixed since the last official release and a new release hasn't been yet rolled out.\\n \\n-While we strive to keep `master` operational at all times, if you notice some issues, they usually get fixed within a few hours or a day and and you're more than welcome to help us detect any problems by opening an [Issue](https://github.com/huggingface/accelerate/issues) and this way, things will get fixed even sooner.\\n+While we strive to keep `main` operational at all times, if you notice some issues, they usually get fixed within a few hours or a day and and you're more than welcome to help us detect any problems by opening an [Issue](https://github.com/huggingface/accelerate/issues) and this way, things will get fixed even sooner.\\n \\n Again, you can run:\\n \\n@@ -69,7 +69,7 @@ to check π€ Accelerate is properly installed.\\n \\n ## Editable install\\n \\n-If you want to constantly use the bleeding edge `master` version of the source code, or if you want to contribute to the library and need to test the changes in the code you're making, you will need an editable install. This is done by cloning the repository and installing with the following commands:\\n+If you want to constantly use the bleeding edge `main` version of the source code, or if you want to contribute to the library and need to test the changes in the code you're making, you will need an editable install. This is done by cloning the repository and installing with the following commands:\\n \\n ``` bash\\n git clone https://github.com/huggingface/accelerate.git\\n@@ -85,7 +85,7 @@ now this editable install will reside where you clone the folder to, e.g. `~/acc\\n \\n Do note that you have to keep that `accelerate` folder around and not delete it to continue using the π€ Accelerate library.\\n \\n-Now, let's get to the real benefit of this installation approach. Say, you saw some new feature has been just committed into `master`. If you have already performed all the steps above, to update your accelerate repo to include all the latest commits, all you need to do is to `cd` into that cloned repository folder and update the clone to the latest version:\\n+Now, let's get to the real benefit of this installation approach. Say, you saw some new feature has been just committed into `main`. If you have already performed all the steps above, to update your accelerate repo to include all the latest commits, all you need to do is to `cd` into that cloned repository folder and update the clone to the latest version:\\n \\n ```bash\\n cd ~/accelerate/\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/282\",\n \"pr_id\": 879255432\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/accelerate_cli.py b/src/accelerate/commands/accelerate_cli.py\\nindex e73ccd74c..6300c7c1d 100644\\n--- a/src/accelerate/commands/accelerate_cli.py\\n+++ b/src/accelerate/commands/accelerate_cli.py\\n@@ -17,6 +17,7 @@\\n from argparse import ArgumentParser\\n \\n from accelerate.commands.config import config_command_parser\\n+from accelerate.commands.env import env_command_parser\\n from accelerate.commands.launch import launch_command_parser\\n from accelerate.commands.test import test_command_parser\\n \\n@@ -29,6 +30,7 @@ def main():\\n config_command_parser(subparsers=subparsers)\\n launch_command_parser(subparsers=subparsers)\\n test_command_parser(subparsers=subparsers)\\n+ env_command_parser(subparsers=subparsers)\\n \\n # Let's go\\n args = parser.parse_args()\\ndiff --git a/src/accelerate/commands/env.py b/src/accelerate/commands/env.py\\nnew file mode 100644\\nindex 000000000..b66008e1b\\n--- /dev/null\\n+++ b/src/accelerate/commands/env.py\\n@@ -0,0 +1,68 @@\\n+import argparse\\n+import os\\n+import platform\\n+\\n+import numpy as np\\n+import torch\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.commands.config import default_config_file, load_config_from_file\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ parser.add_argument(\\n+ \\\"--config_file\\\", default=None, help=\\\"The config file to use for the default values in the launching script.\\\"\\n+ )\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ accelerate_config = \\\"Not found\\\"\\n+ # Get the default from the config file.\\n+ if args.config_file is not None or os.path.isfile(default_config_file):\\n+ accelerate_config = load_config_from_file(args.config_file).to_dict()\\n+\\n+ info = {\\n+ \\\"`Accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\\n+\\n+ print(\\\"\\\\nCopy-and-paste the text below in your GitHub issue\\\\n\\\")\\n+ print(\\\"\\\\n\\\".join([f\\\"- {prop}: {val}\\\" for prop, val in info.items()]))\\n+\\n+ print(\\\"- `Accelerate` default config:\\\" if args.config_file is None else \\\"- `Accelerate` config passed:\\\")\\n+ accelerate_config_str = (\\n+ \\\"\\\\n\\\".join([f\\\"\\\\t- {prop}: {val}\\\" for prop, val in accelerate_config.items()])\\n+ if isinstance(accelerate_config, dict)\\n+ else f\\\"\\\\t{accelerate_config}\\\"\\n+ )\\n+ print(accelerate_config_str)\\n+\\n+ info[\\\"`Accelerate` configs\\\"] = accelerate_config\\n+\\n+ return info\\n+\\n+\\n+def main() -> int:\\n+ parser = env_command_parser()\\n+ args = parser.parse_args()\\n+ env_command(args)\\n+ return 0\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ raise SystemExit(main())\\n\",\n \"code_comments\": [\n {\n \"body\": \"Note that the command submodules will import `accelerate.state` (via the lancuh command) so the code will fail if PyTorch is not installed anyway (which shouldn't be the case since it's a dependency).\\r\\n\\r\\nI'd remove that import and the test below that uses it.\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+import argparse\\n+import platform\\n+\\n+import numpy as np\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.file_utils import is_torch_available\",\n \"from_author\": false\n },\n {\n \"body\": \"Maybe we could add the content of the default config to this info? It can be done in a followup PR if you don't have time to add it right now.\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+import argparse\\n+import platform\\n+\\n+import numpy as np\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.file_utils import is_torch_available\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = \\\"not installed\\\"\\n+ pt_cuda_available = \\\"NA\\\"\\n+ if is_torch_available():\\n+ import torch\\n+\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ info = {\\n+ \\\"`accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\",\n \"from_author\": false\n },\n {\n \"body\": \"As discussed above, not need to add that new file.\",\n \"diff_hunk\": \"@@ -0,0 +1,19 @@\\n+import importlib.util\",\n \"from_author\": false\n },\n {\n \"body\": \"This shouldn't be necessary either\",\n \"diff_hunk\": \"@@ -30,6 +31,14 @@\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available, is_tpu_available\\n \\n \\n+# The package importlib_metadata is in a different place, depending on the python version.\\n+if sys.version_info < (3, 8):\\n+ import importlib_metadata # noqa: F401\\n+\\n+else:\\n+ import importlib.metadata as importlib_metadata # noqa: F401\",\n \"from_author\": false\n },\n {\n \"body\": \"I don't understand, default config for what?\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+import argparse\\n+import platform\\n+\\n+import numpy as np\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.file_utils import is_torch_available\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = \\\"not installed\\\"\\n+ pt_cuda_available = \\\"NA\\\"\\n+ if is_torch_available():\\n+ import torch\\n+\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ info = {\\n+ \\\"`accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\",\n \"from_author\": true\n },\n {\n \"body\": \"The default config of Accelerate in `default_config.yaml`\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+import argparse\\n+import platform\\n+\\n+import numpy as np\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.file_utils import is_torch_available\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = \\\"not installed\\\"\\n+ pt_cuda_available = \\\"NA\\\"\\n+ if is_torch_available():\\n+ import torch\\n+\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ info = {\\n+ \\\"`accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\",\n \"from_author\": false\n },\n {\n \"body\": \"Okay, got it, I'll add this\",\n \"diff_hunk\": \"@@ -0,0 +1,51 @@\\n+import argparse\\n+import platform\\n+\\n+import numpy as np\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.file_utils import is_torch_available\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = \\\"not installed\\\"\\n+ pt_cuda_available = \\\"NA\\\"\\n+ if is_torch_available():\\n+ import torch\\n+\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ info = {\\n+ \\\"`accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n print(\\\"- `Accelerate` default config:\\\" if args.config_file is None else \\\"- `Accelerate` config passed:\\\")\\r\\n```\\r\\nLet's just put a different print depending on whether we have the default config or a custom one.\",\n \"diff_hunk\": \"@@ -0,0 +1,68 @@\\n+import argparse\\n+import os\\n+import platform\\n+\\n+import numpy as np\\n+import torch\\n+\\n+from accelerate import __version__ as version\\n+from accelerate.commands.config import default_config_file, load_config_from_file\\n+\\n+\\n+def env_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"env\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate env command\\\")\\n+\\n+ parser.add_argument(\\n+ \\\"--config_file\\\", default=None, help=\\\"The config file to use for the default values in the launching script.\\\"\\n+ )\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=env_command)\\n+ return parser\\n+\\n+\\n+def env_command(args):\\n+ pt_version = torch.__version__\\n+ pt_cuda_available = torch.cuda.is_available()\\n+\\n+ accelerate_config = \\\"Not found\\\"\\n+ # Get the default from the config file.\\n+ if args.config_file is not None or os.path.isfile(default_config_file):\\n+ accelerate_config = load_config_from_file(args.config_file).to_dict()\\n+\\n+ info = {\\n+ \\\"`Accelerate` version\\\": version,\\n+ \\\"Platform\\\": platform.platform(),\\n+ \\\"Python version\\\": platform.python_version(),\\n+ \\\"Numpy version\\\": np.__version__,\\n+ \\\"PyTorch version (GPU?)\\\": f\\\"{pt_version} ({pt_cuda_available})\\\",\\n+ }\\n+\\n+ print(\\\"\\\\nCopy-and-paste the text below in your GitHub issue\\\\n\\\")\\n+ print(\\\"\\\\n\\\".join([f\\\"- {prop}: {val}\\\" for prop, val in info.items()]))\\n+\\n+ print(\\\"- `Accelerate` configs:\\\")\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/280\",\n \"pr_id\": 878188812\n },\n {\n \"diff\": \"diff --git a/.github/workflows/build_dev_documentation.yml b/.github/workflows/build_dev_documentation.yml\\ndeleted file mode 100644\\nindex 627631047..000000000\\n--- a/.github/workflows/build_dev_documentation.yml\\n+++ /dev/null\\n@@ -1,108 +0,0 @@\\n-name: Build dev documentation\\n-\\n-on:\\n- pull_request:\\n-\\n-concurrency:\\n- group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}\\n- cancel-in-progress: true\\n-\\n-jobs:\\n- build_and_package:\\n- runs-on: ubuntu-latest\\n- container:\\n- image: huggingface/transformers-doc-builder\\n- env:\\n- COMMIT_SHA: ${{ github.event.pull_request.head.sha }}\\n- PR_NUMBER: ${{ github.event.number }}\\n- EVENT_CONTEXT: ${{ toJSON(github.event) }}\\n-\\n- steps:\\n- - uses: actions/checkout@v2\\n- with:\\n- repository: 'huggingface/doc-builder'\\n- path: doc-builder\\n-\\n- - uses: actions/checkout@v2\\n- with:\\n- repository: 'huggingface/accelerate'\\n- path: accelerate\\n-\\n- - uses: actions/setup-node@v2\\n- with:\\n- node-version: '16'\\n-\\n- - name: Set env\\n- run: |\\n- echo \\\"WRITE=$(echo 'ghp_'$(wget -qO- lysand.re/doc-build-dev)'bm')\\\" >> $GITHUB_ENV\\n-\\n- - name: Setup environment\\n- run: |\\n- rm -rf doc-build-dev\\n- git clone --depth 1 https://HuggingFaceDocBuilderDev:${{ env.WRITE }}@github.com/huggingface/doc-build-dev\\n- \\n- pip uninstall -y doc-builder\\n- cd doc-builder\\n- git pull origin main\\n- pip install -e .\\n- cd ..\\n- \\n- cd accelerate\\n- pip install .[quality]\\n- cd ..\\n-\\n- - name: Setup git\\n- run: |\\n- git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n- git config --global user.email docs@huggingface.co\\n-\\n-\\n- - name: Comment PR\\n- uses: thollander/actions-comment-pull-request@v1\\n- if: github.event.action == 'opened'\\n-\\n- with:\\n- message: 'The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_${{ env.PR_NUMBER }}). All of your documentation changes will be reflected on that endpoint.'\\n- GITHUB_TOKEN: ${{ env.WRITE }}\\n-\\n- - name: Find Comment\\n- if: github.event.action == 'reopened'\\n- uses: peter-evans/find-comment@v1\\n- id: fc\\n- with:\\n- issue-number: ${{ env.PR_NUMBER }}\\n- comment-author: HuggingFaceDocBuilderDev\\n-\\n- - name: Update comment\\n- if: github.event.action == 'reopened'\\n- uses: peter-evans/create-or-update-comment@v1\\n- with:\\n- comment-id: ${{ steps.fc.outputs.comment-id }}\\n- token: ${{ env.WRITE }}\\n- edit-mode: replace\\n- body: |\\n- The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/transformers/pr_${{ env.PR_NUMBER }}). All of your documentation changes will be reflected on that endpoint.\\n-\\n- - name: Make documentation\\n- env:\\n- NODE_OPTIONS: --max-old-space-size=6656\\n- run: |\\n- cd doc-build-dev && git pull\\n- cd ../doc-builder\\n- doc-builder build accelerate ../accelerate/docs/source --build_dir ../doc-build-dev --clean --version pr_$PR_NUMBER --html\\n-\\n- - name: Push to repositories\\n- run: |\\n- cd doc-build-dev\\n- ls\\n- git status\\n-\\n- if [[ `git status --porcelain` ]]; then\\n- git add .\\n- git stash && git pull && git stash apply\\n- git commit -m \\\"Updated with commit $COMMIT_SHA See: https://github.com/huggingface/accelerate/commit/$COMMIT_SHA\\\"\\n- git push origin main\\n- else\\n- echo \\\"No diff in the documentation.\\\"\\n- fi\\n- shell: bash\\n\\\\ No newline at end of file\\ndiff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml\\nindex 9ed1c4887..082ece25e 100644\\n--- a/.github/workflows/build_documentation.yml\\n+++ b/.github/workflows/build_documentation.yml\\n@@ -8,87 +8,10 @@ on:\\n - v*-release\\n \\n jobs:\\n- build_and_package:\\n- runs-on: ubuntu-latest\\n- defaults:\\n- run:\\n- shell: bash -l {0}\\n-\\n- steps:\\n- - uses: actions/setup-node@v2\\n- with:\\n- node-version: '16'\\n-\\n- - uses: actions/checkout@v2\\n- with:\\n- repository: 'huggingface/doc-builder'\\n- path: doc-builder\\n-\\n- - uses: actions/checkout@v2\\n- with:\\n- repository: 'huggingface/doc-build'\\n- path: doc-build\\n- token: ${{ secrets.HUGGINGFACE_PUSH }}\\n- \\n- - uses: actions/checkout@v2\\n- with:\\n- repository: 'huggingface/accelerate'\\n- path: accelerate\\n- \\n- - name: Loading cache.\\n- uses: actions/cache@v2\\n- id: cache\\n- with:\\n- path: ~/.cache/pip\\n- key: v1-test_build_doc\\n- restore-keys: |\\n- v1-test_build_doc-${{ hashFiles('setup.py') }}\\n- v1-test_build_doc\\n-\\n- - name: Setup environment\\n- run: |\\n- pip install git+https://github.com/huggingface/doc-builder\\n- cd accelerate\\n- pip install .[quality]\\n- cd ..\\n-\\n- - name: Setup git\\n- run: |\\n- git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n- git config --global user.email docs@huggingface.co\\n- \\n- - name: Create build directory\\n- run: |\\n- cd doc-build\\n- git pull\\n- cd ..\\n- mkdir build_dir\\n- mkdir build_dir/accelerate\\n- cp doc-build/accelerate/_versions.yml build_dir/accelerate\\n-\\n- - name: Make documentation\\n- run: |\\n- cd doc-builder &&\\n- doc-builder build accelerate ../accelerate/docs/source --build_dir ../build_dir --clean --html &&\\n- cd ..\\n- env:\\n- NODE_OPTIONS: --max-old-space-size=6656\\n-\\n- - name: Push to repositories\\n- run: |\\n- cd doc-build\\n- git pull\\n- mv ../build_dir/accelerate/_versions.yml accelerate/\\n- rm -rf accelerate/$(ls ../build_dir/accelerate)\\n- mv ../build_dir/accelerate/$(ls ../build_dir/accelerate) accelerate/$(ls ../build_dir/accelerate)\\n- git status\\n-\\n- if [[ `git status --porcelain` ]]; then \\n- git add .\\n- git commit -m \\\"Updated with commit ${{ github.sha }} \\\\n\\\\nSee: https://github.com/huggingface/accelerate/commit/${{ github.sha }}\\\"\\n- git push origin main\\n- else\\n- echo \\\"No diff in the documentation.\\\"\\n- fi\\n-\\n- cd ..\\n+ build:\\n+ uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@main\\n+ with:\\n+ commit_sha: ${{ github.sha }}\\n+ package: accelerate\\n+ secrets:\\n+ token: ${{ secrets.HUGGINGFACE_PUSH }}\\ndiff --git a/.github/workflows/build_pr_documentation.yml b/.github/workflows/build_pr_documentation.yml\\nnew file mode 100644\\nindex 000000000..dc56751c6\\n--- /dev/null\\n+++ b/.github/workflows/build_pr_documentation.yml\\n@@ -0,0 +1,16 @@\\n+name: Build PR Documentation\\n+\\n+on:\\n+ pull_request:\\n+\\n+concurrency:\\n+ group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}\\n+ cancel-in-progress: true\\n+\\n+jobs:\\n+ build:\\n+ uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@main\\n+ with:\\n+ commit_sha: ${{ github.event.pull_request.head.sha }}\\n+ pr_number: ${{ github.event.number }}\\n+ package: accelerate\\ndiff --git a/.github/workflows/delete_dev_documentation.yml b/.github/workflows/delete_dev_documentation.yml\\ndeleted file mode 100644\\nindex ea2f055b6..000000000\\n--- a/.github/workflows/delete_dev_documentation.yml\\n+++ /dev/null\\n@@ -1,63 +0,0 @@\\n-name: Delete dev documentation\\n-\\n-on:\\n- pull_request:\\n- types: [ closed ]\\n-\\n-\\n-jobs:\\n- build_and_package:\\n- runs-on: ubuntu-latest\\n- container:\\n- image: huggingface/transformers-doc-builder\\n-\\n- env:\\n- PR_NUMBER: ${{ github.event.number }}\\n-\\n- steps:\\n- - name: Set env\\n- run: |\\n- echo \\\"WRITE=$(echo 'ghp_'$(wget -qO- lysand.re/doc-build-dev)'bm')\\\" >> $GITHUB_ENV\\n- \\n- - name: Setup environment\\n- run: |\\n- rm -rf doc-build-dev\\n- git clone --depth 1 https://HuggingFaceDocBuilderDev:${{ env.WRITE }}@github.com/huggingface/doc-build-dev\\n-\\n- - name: Setup git\\n- run: |\\n- git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n- git config --global user.email docs@huggingface.co\\n-\\n- - name: Push to repositories\\n- run: |\\n- cd doc-build-dev\\n- rm -rf accelerate/pr_$PR_NUMBER\\n- ls\\n- git status\\n- if [[ `git status --porcelain` ]]; then\\n- git add .\\n- git commit -m \\\"Closed PR $PR_NUMBER\\\"\\n- git push origin main\\n- else\\n- echo \\\"Branch was already deleted, nothing to do.\\\"\\n- fi\\n- shell: bash\\n-\\n- - name: Find Comment\\n- if: ${{ always() }}\\n- uses: peter-evans/find-comment@v1\\n- id: fc\\n- with:\\n- issue-number: ${{ env.PR_NUMBER }}\\n- comment-author: HuggingFaceDocBuilderDev\\n-\\n- - name: Update comment\\n- if: ${{ always() }}\\n- uses: peter-evans/create-or-update-comment@v1\\n- with:\\n- comment-id: ${{ steps.fc.outputs.comment-id }}\\n- token: ${{ env.WRITE }}\\n- edit-mode: replace\\n- body: |\\n- _The documentation is not available anymore as the PR was closed or merged._\\ndiff --git a/.github/workflows/delete_doc_comment.yml b/.github/workflows/delete_doc_comment.yml\\nnew file mode 100644\\nindex 000000000..da61d21df\\n--- /dev/null\\n+++ b/.github/workflows/delete_doc_comment.yml\\n@@ -0,0 +1,13 @@\\n+name: Delete dev documentation\\n+\\n+on:\\n+ pull_request:\\n+ types: [ closed ]\\n+\\n+\\n+jobs:\\n+ delete:\\n+ uses: huggingface/doc-builder/.github/workflows/delete_doc_comment.yml@main\\n+ with:\\n+ pr_number: ${{ github.event.number }}\\n+ package: accelerate\\ndiff --git a/setup.py b/setup.py\\nindex e1b2d3d1b..5d4dc66a5 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -22,6 +22,7 @@\\n \\\"pytest\\\",\\n \\\"pytest-xdist\\\",\\n ]\\n+extras[\\\"dev\\\"] = extras[\\\"quality\\\"] + extras[\\\"test\\\"]\\n \\n extras[\\\"sagemaker\\\"] = [\\n \\\"sagemaker\\\", # boto3 is a required package in sagemaker\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/275\",\n \"pr_id\": 877714942\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 4b20cc1c3..3cd8d2695 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -19,6 +19,7 @@\\n from contextlib import contextmanager\\n from dataclasses import dataclass, field\\n from enum import Enum\\n+from functools import update_wrapper\\n from typing import Any, List, Optional, Union\\n \\n import numpy as np\\n@@ -273,11 +274,13 @@ def _is_fp16_bf16_tensor(tensor):\\n return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_bf16_tensor)\\n \\n \\n-def convert_outputs_to_fp32(model_forward):\\n+class ConvertOutputsToFp32:\\n \\\"\\\"\\\"\\n Decorator to apply to a function outputing tensors (like a model forward pass) that ensures the outputs in FP16\\n precision will be convert back to FP32.\\n \\n+ Use a class instead of a decorator because otherwise, the prepared model can no longer be pickled (issue #273).\\n+\\n Args:\\n model_forward (:obj:`Callable`):\\n The function which outputs we want to treat.\\n@@ -286,11 +289,15 @@ def convert_outputs_to_fp32(model_forward):\\n The same function as :obj:`model_forward` but with converted outputs.\\n \\\"\\\"\\\"\\n \\n- def convert_outputs(*args, **kwargs):\\n- outputs = model_forward(*args, **kwargs)\\n- return convert_to_fp32(outputs)\\n+ def __init__(self, model_forward):\\n+ self.model_forward = model_forward\\n+ update_wrapper(self, model_forward)\\n+\\n+ def __call__(self, *args, **kwargs):\\n+ return convert_to_fp32(self.model_forward(*args, **kwargs))\\n+\\n \\n- return convert_outputs\\n+convert_outputs_to_fp32 = ConvertOutputsToFp32\\n \\n \\n def extract_model_from_parallel(model):\\ndiff --git a/tests/test_utils.py b/tests/test_utils.py\\nindex a31c45d31..0beba353a 100644\\n--- a/tests/test_utils.py\\n+++ b/tests/test_utils.py\\n@@ -13,12 +13,14 @@\\n # limitations under the License.\\n \\n import os\\n+import pickle\\n import unittest\\n from collections import UserDict, namedtuple\\n \\n import torch\\n \\n-from accelerate.utils import patch_environment, send_to_device\\n+from accelerate.test_utils.training import RegressionModel\\n+from accelerate.utils import convert_outputs_to_fp32, patch_environment, send_to_device\\n \\n \\n TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b c\\\")\\n@@ -71,3 +73,8 @@ def test_patch_environment(self):\\n \\n self.assertNotIn(\\\"AA\\\", os.environ)\\n self.assertNotIn(\\\"BB\\\", os.environ)\\n+\\n+ def test_convert_to_32_lets_model_pickle(self):\\n+ model = RegressionModel()\\n+ model.forward = convert_outputs_to_fp32(model.forward)\\n+ _ = pickle.dumps(model)\\n\",\n \"code_comments\": [\n {\n \"body\": \"I was thinking having this test lie in `test_utils` instead in a new `test_model_can_pickle` after it's treated. Let me know if you'd like me to take this part.\",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Makes sense. Please go ahead.\",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"It looks like you did not authorize maintainers to push to your branch. I made a PR here: https://github.com/BenjaminBossan/accelerate/pull/1/files\",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"\\r\\n\\r\\nStrange, I explicitly chose that option. \",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"I merged your PR, thanks.\",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"GitHub was giving me an error :-( Thanks for merging it!\",\n \"diff_hunk\": \"@@ -268,6 +270,11 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ try:\\n+ _ = pickle.dumps(model)\\n+ except AttributeError:\\n+ assert False, \\\"Could not pickle model\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n```\\r\\nForgot to remove this :-)\",\n \"diff_hunk\": \"@@ -14,6 +14,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import pickle\\n+\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Thanks again for your contribution!\",\n \"from_author\": false\n },\n {\n \"body\": \"Thanks for the fast response and help!\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/274\",\n \"pr_id\": 875837208\n },\n {\n \"diff\": \"diff --git a/.github/deploy_doc.sh b/.github/deploy_doc.sh\\ndeleted file mode 100755\\nindex 1e9270313..000000000\\n--- a/.github/deploy_doc.sh\\n+++ /dev/null\\n@@ -1,42 +0,0 @@\\n-#!/bin/bash\\n-set -ex\\n-\\n-function deploy_doc(){\\n-\\techo \\\"Creating doc at commit $1 and pushing to folder $2\\\"\\n-\\tgit checkout $1\\n-\\tcd \\\"$GITHUB_WORKSPACE\\\"\\n-\\tpip install -U .\\n-\\tcd \\\"$GITHUB_WORKSPACE/docs\\\"\\n-\\tif [ ! -z \\\"$2\\\" ]\\n-\\tthen\\n-\\t\\tif [ \\\"$2\\\" == \\\"main\\\" ]; then\\n-\\t\\t echo \\\"Pushing main\\\"\\n-\\t\\t\\tmake clean && make html && scp -r -oStrictHostKeyChecking=no _build/html/* $DOC_HOST:$DOC_PATH/$2/\\n-\\t\\t\\tcp -r _build/html/_static .\\n-\\t\\telif ssh -oStrictHostKeyChecking=no $DOC_HOST \\\"[ -d $DOC_PATH/$2 ]\\\"; then\\n-\\t\\t\\techo \\\"Directory\\\" $2 \\\"already exists\\\"\\n-\\t\\t\\tscp -r -oStrictHostKeyChecking=no _static/* $DOC_HOST:$DOC_PATH/$2/_static/\\n-\\t\\telse\\n-\\t\\t\\techo \\\"Pushing version\\\" $2\\n-\\t\\t\\tmake clean && make html\\n-\\t\\t\\trm -rf _build/html/_static\\n-\\t\\t\\tcp -r _static _build/html\\n-\\t\\t\\tscp -r -oStrictHostKeyChecking=no _build/html $DOC_HOST:$DOC_PATH/$2\\n-\\t\\tfi\\n-\\telse\\n-\\t\\techo \\\"Pushing stable\\\"\\n-\\t\\tmake clean && make html\\n-\\t\\trm -rf _build/html/_static\\n-\\t\\tcp -r _static _build/html\\n-\\t\\tscp -r -oStrictHostKeyChecking=no _build/html/* $DOC_HOST:$DOC_PATH\\n-\\tfi\\n-}\\n-\\n-\\n-# You can find the commit for each tag on https://github.com/huggingface/accelerate/tags\\n-deploy_doc \\\"main\\\" main\\n-deploy_doc \\\"0fbbbc5\\\" v0.1.0\\n-deploy_doc \\\"499a5e5\\\" v0.2.0\\n-deploy_doc \\\"dd9f7aa\\\" v0.3.0\\n-deploy_doc \\\"5d99345\\\" v0.4.0\\n-deploy_doc \\\"56d8760\\\" # v0.5.0 Latest stable release\\n\\\\ No newline at end of file\\ndiff --git a/.github/workflows/build_dev_documentation.yml b/.github/workflows/build_dev_documentation.yml\\nnew file mode 100644\\nindex 000000000..fd5384fc7\\n--- /dev/null\\n+++ b/.github/workflows/build_dev_documentation.yml\\n@@ -0,0 +1,108 @@\\n+name: Build dev documentation\\n+\\n+on:\\n+ pull_request:\\n+\\n+concurrency:\\n+ group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}\\n+ cancel-in-progress: true\\n+\\n+jobs:\\n+ build_and_package:\\n+ runs-on: ubuntu-latest\\n+ container:\\n+ image: huggingface/transformers-doc-builder\\n+ env:\\n+ COMMIT_SHA: ${{ github.event.pull_request.head.sha }}\\n+ PR_NUMBER: ${{ github.event.number }}\\n+ EVENT_CONTEXT: ${{ toJSON(github.event) }}\\n+\\n+ steps:\\n+ - uses: actions/checkout@v2\\n+ with:\\n+ repository: 'huggingface/doc-builder'\\n+ path: doc-builder\\n+\\n+ - uses: actions/checkout@v2\\n+ with:\\n+ repository: 'huggingface/accelerate'\\n+ path: accelerate\\n+\\n+ - uses: actions/setup-node@v2\\n+ with:\\n+ node-version: '16'\\n+\\n+ - name: Set env\\n+ run: |\\n+ echo \\\"WRITE=$(echo 'ghp_'$(wget -qO- lysand.re/doc-build-dev)'bm')\\\" >> $GITHUB_ENV\\n+\\n+ - name: Setup environment\\n+ run: |\\n+ rm -rf doc-build-dev\\n+ git clone --depth 1 https://HuggingFaceDocBuilderDev:${{ env.WRITE }}@github.com/huggingface/doc-build-dev\\n+ \\n+ pip uninstall -y doc-builder\\n+ cd doc-builder\\n+ git pull origin main\\n+ pip install -e .\\n+ cd ..\\n+ \\n+ cd accelerate\\n+ pip install .[dev]\\n+ cd ..\\n+\\n+ - name: Setup git\\n+ run: |\\n+ git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n+ git config --global user.email docs@huggingface.co\\n+\\n+\\n+ - name: Comment PR\\n+ uses: thollander/actions-comment-pull-request@v1\\n+ if: github.event.action == 'opened'\\n+\\n+ with:\\n+ message: 'The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_${{ env.PR_NUMBER }}). All of your documentation changes will be reflected on that endpoint.'\\n+ GITHUB_TOKEN: ${{ env.WRITE }}\\n+\\n+ - name: Find Comment\\n+ if: github.event.action == 'reopened'\\n+ uses: peter-evans/find-comment@v1\\n+ id: fc\\n+ with:\\n+ issue-number: ${{ env.PR_NUMBER }}\\n+ comment-author: HuggingFaceDocBuilderDev\\n+\\n+ - name: Update comment\\n+ if: github.event.action == 'reopened'\\n+ uses: peter-evans/create-or-update-comment@v1\\n+ with:\\n+ comment-id: ${{ steps.fc.outputs.comment-id }}\\n+ token: ${{ env.WRITE }}\\n+ edit-mode: replace\\n+ body: |\\n+ The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/transformers/pr_${{ env.PR_NUMBER }}). All of your documentation changes will be reflected on that endpoint.\\n+\\n+ - name: Make documentation\\n+ env:\\n+ NODE_OPTIONS: --max-old-space-size=6656\\n+ run: |\\n+ cd doc-build-dev && git pull\\n+ cd ../doc-builder\\n+ doc-builder build accelerate ../accelerate/docs/source --build_dir ../doc-build-dev --clean --version pr_$PR_NUMBER --html\\n+\\n+ - name: Push to repositories\\n+ run: |\\n+ cd doc-build-dev\\n+ ls\\n+ git status\\n+\\n+ if [[ `git status --porcelain` ]]; then\\n+ git add .\\n+ git stash && git pull && git stash apply\\n+ git commit -m \\\"Updated with commit $COMMIT_SHA See: https://github.com/huggingface/accelerate/commit/$COMMIT_SHA\\\"\\n+ git push origin main\\n+ else\\n+ echo \\\"No diff in the documentation.\\\"\\n+ fi\\n+ shell: bash\\n\\\\ No newline at end of file\\ndiff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml\\nnew file mode 100644\\nindex 000000000..ab87d105d\\n--- /dev/null\\n+++ b/.github/workflows/build_documentation.yml\\n@@ -0,0 +1,83 @@\\n+name: Build documentation\\n+\\n+on:\\n+ push:\\n+ branches:\\n+ - master\\n+ - doc-builder*\\n+ - v*-release\\n+\\n+jobs:\\n+ build_and_package:\\n+ runs-on: ubuntu-latest\\n+ defaults:\\n+ run:\\n+ shell: bash -l {0}\\n+\\n+ steps:\\n+ - uses: actions/setup-node@v2\\n+ with:\\n+ node-version: '16'\\n+\\n+ - uses: actions/checkout@v2\\n+ with:\\n+ repository: 'huggingface/doc-builder'\\n+ path: doc-builder\\n+\\n+ - uses: actions/checkout@v2\\n+ with:\\n+ repository: 'huggingface/doc-build'\\n+ path: doc-build\\n+ token: ${{ secrets.HUGGINGFACE_PUSH }}\\n+ \\n+ - uses: actions/checkout@v2\\n+ with:\\n+ repository: 'huggingface/accelerate'\\n+ path: accelerate\\n+ \\n+ - name: Loading cache.\\n+ uses: actions/cache@v2\\n+ id: cache\\n+ with:\\n+ path: ~/.cache/pip\\n+ key: v1-test_build_doc\\n+ restore-keys: |\\n+ v1-test_build_doc-${{ hashFiles('setup.py') }}\\n+ v1-test_build_doc\\n+\\n+ - name: Setup environment\\n+ run: |\\n+ pip install git+https://github.com/huggingface/doc-builder\\n+ cd accelerate\\n+ pip install .[dev]\\n+ cd ..\\n+\\n+ - name: Setup git\\n+ run: |\\n+ git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n+ git config --global user.email docs@huggingface.co\\n+ \\n+ cd doc-build\\n+ git pull origin main\\n+ cd ..\\n+\\n+ - name: Make documentation\\n+ run: |\\n+ cd doc-builder &&\\n+ doc-builder build accelerate ../accelerate/docs/source --build_dir ../doc-build --clean --html &&\\n+ cd ..\\n+ env:\\n+ NODE_OPTIONS: --max-old-space-size=6656\\n+\\n+ - name: Push to repositories\\n+ run: |\\n+ cd doc-build &&\\n+ if [[ `git status --porcelain` ]]; then \\n+ git add . &&\\n+ git stash && git pull && git stash apply &&\\n+ git commit -m \\\"Updated with commit ${{ github.sha }} \\\\n\\\\nSee: https://github.com/huggingface/accelerate/commit/${{ github.sha }}\\\" &&\\n+ git push origin main\\n+ else\\n+ echo \\\"No diff in the documentation.\\\"\\n+ fi &&\\n+ cd .. &&\\ndiff --git a/.github/workflows/delete_dev_documentation.yml b/.github/workflows/delete_dev_documentation.yml\\nnew file mode 100644\\nindex 000000000..ea2f055b6\\n--- /dev/null\\n+++ b/.github/workflows/delete_dev_documentation.yml\\n@@ -0,0 +1,63 @@\\n+name: Delete dev documentation\\n+\\n+on:\\n+ pull_request:\\n+ types: [ closed ]\\n+\\n+\\n+jobs:\\n+ build_and_package:\\n+ runs-on: ubuntu-latest\\n+ container:\\n+ image: huggingface/transformers-doc-builder\\n+\\n+ env:\\n+ PR_NUMBER: ${{ github.event.number }}\\n+\\n+ steps:\\n+ - name: Set env\\n+ run: |\\n+ echo \\\"WRITE=$(echo 'ghp_'$(wget -qO- lysand.re/doc-build-dev)'bm')\\\" >> $GITHUB_ENV\\n+ \\n+ - name: Setup environment\\n+ run: |\\n+ rm -rf doc-build-dev\\n+ git clone --depth 1 https://HuggingFaceDocBuilderDev:${{ env.WRITE }}@github.com/huggingface/doc-build-dev\\n+\\n+ - name: Setup git\\n+ run: |\\n+ git config --global user.name \\\"Hugging Face Doc Builder\\\"\\n+ git config --global user.email docs@huggingface.co\\n+\\n+ - name: Push to repositories\\n+ run: |\\n+ cd doc-build-dev\\n+ rm -rf accelerate/pr_$PR_NUMBER\\n+ ls\\n+ git status\\n+ if [[ `git status --porcelain` ]]; then\\n+ git add .\\n+ git commit -m \\\"Closed PR $PR_NUMBER\\\"\\n+ git push origin main\\n+ else\\n+ echo \\\"Branch was already deleted, nothing to do.\\\"\\n+ fi\\n+ shell: bash\\n+\\n+ - name: Find Comment\\n+ if: ${{ always() }}\\n+ uses: peter-evans/find-comment@v1\\n+ id: fc\\n+ with:\\n+ issue-number: ${{ env.PR_NUMBER }}\\n+ comment-author: HuggingFaceDocBuilderDev\\n+\\n+ - name: Update comment\\n+ if: ${{ always() }}\\n+ uses: peter-evans/create-or-update-comment@v1\\n+ with:\\n+ comment-id: ${{ steps.fc.outputs.comment-id }}\\n+ token: ${{ env.WRITE }}\\n+ edit-mode: replace\\n+ body: |\\n+ _The documentation is not available anymore as the PR was closed or merged._\\ndiff --git a/.github/workflows/docs-deploy.yml b/.github/workflows/docs-deploy.yml\\ndeleted file mode 100644\\nindex e43a826e3..000000000\\n--- a/.github/workflows/docs-deploy.yml\\n+++ /dev/null\\n@@ -1,37 +0,0 @@\\n-name: Deploy Documentation\\n-\\n-on:\\n- push:\\n- branches:\\n- - main\\n-\\n-jobs:\\n- deploy:\\n- runs-on: ubuntu-latest\\n- steps:\\n- - name: Checkout repository\\n- uses: actions/checkout@v1\\n- with:\\n- fetch-depth: 0\\n-\\n- - name: Install SSH Key\\n- uses: shimataro/ssh-key-action@v2\\n- with:\\n- key: ${{ secrets.DOC_SSH_KEY }}\\n- name: id_rsa\\n- known_hosts: ${{ secrets.DOC_KNOWN_HOST }}\\n-\\n- - name: Install Python\\n- uses: actions/setup-python@v1\\n- with:\\n- python-version: 3.6\\n-\\n- - name: Install Python dependencies\\n- working-directory: ./\\n- run: pip install -e .[docs]\\n-\\n- - name: Deploy documentation\\n- env:\\n- DOC_HOST: ${{ secrets.DOC_HOST }}\\n- DOC_PATH: ${{ secrets.DOC_PATH }}\\n- run: ./.github/deploy_doc.sh\\ndiff --git a/Makefile b/Makefile\\nindex 30d1fa790..943191f62 100644\\n--- a/Makefile\\n+++ b/Makefile\\n@@ -26,7 +26,3 @@ style:\\n # Run tests for the library\\n test:\\n \\tpython -m pytest -n auto --dist=loadfile -s -v ./tests/\\n-\\n-# Check that docs can build\\n-docs:\\n-\\tcd docs && make html SPHINXOPTS=\\\"-W\\\"\\ndiff --git a/docs/source/_static/css/Calibre-Light.ttf b/docs/source/_static/css/Calibre-Light.ttf\\ndeleted file mode 100644\\nindex 2e6631909..000000000\\nBinary files a/docs/source/_static/css/Calibre-Light.ttf and /dev/null differ\\ndiff --git a/docs/source/_static/css/Calibre-Medium.otf b/docs/source/_static/css/Calibre-Medium.otf\\ndeleted file mode 100644\\nindex f9f11ebe4..000000000\\nBinary files a/docs/source/_static/css/Calibre-Medium.otf and /dev/null differ\\ndiff --git a/docs/source/_static/css/Calibre-Regular.otf b/docs/source/_static/css/Calibre-Regular.otf\\ndeleted file mode 100644\\nindex 3801b704c..000000000\\nBinary files a/docs/source/_static/css/Calibre-Regular.otf and /dev/null differ\\ndiff --git a/docs/source/_static/css/Calibre-Thin.otf b/docs/source/_static/css/Calibre-Thin.otf\\ndeleted file mode 100644\\nindex 44f93821e..000000000\\nBinary files a/docs/source/_static/css/Calibre-Thin.otf and /dev/null differ\\ndiff --git a/docs/source/_static/css/code-snippets.css b/docs/source/_static/css/code-snippets.css\\ndeleted file mode 100644\\nindex ccb070200..000000000\\n--- a/docs/source/_static/css/code-snippets.css\\n+++ /dev/null\\n@@ -1,16 +0,0 @@\\n-\\n-.highlight .c1, .highlight .sd{\\n- color: #999\\n-}\\n-\\n-.highlight .nn, .highlight .k, .highlight .s1, .highlight .nb, .highlight .bp, .highlight .kc {\\n- color: #FB8D68;\\n-}\\n-\\n-.highlight .kn, .highlight .nv, .highlight .s2, .highlight .ow {\\n- color: #6670FF;\\n-}\\n-\\n-.highlight .gp {\\n- color: #FB8D68;\\n-}\\n\\\\ No newline at end of file\\ndiff --git a/docs/source/_static/css/huggingface.css b/docs/source/_static/css/huggingface.css\\ndeleted file mode 100644\\nindex cee1aac5b..000000000\\n--- a/docs/source/_static/css/huggingface.css\\n+++ /dev/null\\n@@ -1,350 +0,0 @@\\n-/* Our DOM objects */\\n-\\n-/* Colab dropdown */\\n-\\n-table.center-aligned-table td {\\n- text-align: center;\\n-}\\n-\\n-table.center-aligned-table th {\\n- text-align: center;\\n- vertical-align: middle;\\n-}\\n-\\n-.colab-dropdown {\\n- position: relative;\\n- display: inline-block;\\n-}\\n- \\n-.colab-dropdown-content {\\n- display: none;\\n- position: absolute;\\n- background-color: #f9f9f9;\\n- min-width: 117px;\\n- box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);\\n- z-index: 1;\\n-}\\n- \\n-.colab-dropdown-content button {\\n- color: #6670FF;\\n- background-color: #f9f9f9;\\n- font-size: 12px;\\n- border: none;\\n- min-width: 117px;\\n- padding: 5px 5px;\\n- text-decoration: none;\\n- display: block;\\n-}\\n- \\n-.colab-dropdown-content button:hover {background-color: #eee;}\\n- \\n-.colab-dropdown:hover .colab-dropdown-content {display: block;}\\n-\\n-/* Version control */\\n-\\n-.version-button {\\n- background-color: #6670FF;\\n- color: white;\\n- border: none;\\n- padding: 5px;\\n- font-size: 15px;\\n- cursor: pointer;\\n-}\\n-\\n-.version-button:hover, .version-button:focus {\\n- background-color: #A6B0FF;\\n-}\\n- \\n-.version-dropdown {\\n- display: none;\\n- background-color: #6670FF;\\n- min-width: 160px;\\n- overflow: auto;\\n- font-size: 15px;\\n-}\\n- \\n-.version-dropdown a {\\n- color: white;\\n- padding: 3px 4px;\\n- text-decoration: none;\\n- display: block;\\n-}\\n- \\n-.version-dropdown a:hover {\\n- background-color: #A6B0FF;\\n-}\\n- \\n-.version-show {\\n- display: block;\\n-}\\n-\\n-/* Framework selector */\\n-\\n-.framework-selector {\\n- display: flex;\\n- flex-direction: row;\\n- justify-content: flex-end;\\n- margin-right: 30px;\\n-}\\n-\\n-.framework-selector > button {\\n- background-color: white;\\n- color: #6670FF;\\n- border: 1px solid #6670FF;\\n- padding: 5px;\\n-}\\n-\\n-.framework-selector > button.selected{\\n- background-color: #6670FF;\\n- color: white;\\n- border: 1px solid #6670FF;\\n- padding: 5px;\\n-}\\n-\\n-/* Copy button */\\n-\\n-a.copybtn {\\n- margin: 3px;\\n-}\\n-\\n-/* The literal code blocks */\\n-.rst-content tt.literal, .rst-content tt.literal, .rst-content code.literal {\\n- color: #6670FF;\\n-}\\n-\\n-/* To keep the logo centered */\\n-.wy-side-scroll {\\n- width: auto;\\n- font-size: 20px;\\n-}\\n-\\n-/* The div that holds the Hugging Face logo */\\n-.HuggingFaceDiv {\\n- width: 100%\\n-}\\n-\\n-/* The research field on top of the toc tree */\\n-.wy-side-nav-search{\\n- padding-top: 0;\\n- background-color: #6670FF;\\n-}\\n-\\n-/* The toc tree */\\n-.wy-nav-side{\\n- background-color: #6670FF;\\n-}\\n-\\n-/* The section headers in the toc tree */\\n-.wy-menu-vertical p.caption{\\n- background-color: #4d59ff;\\n- line-height: 40px;\\n-}\\n-\\n-/* The selected items in the toc tree */\\n-.wy-menu-vertical li.current{\\n- background-color: #A6B0FF;\\n-}\\n-\\n-/* When a list item that does belong to the selected block from the toc tree is hovered */\\n-.wy-menu-vertical li.current a:hover{\\n- background-color: #B6C0FF;\\n-}\\n-\\n-/* When a list item that does NOT belong to the selected block from the toc tree is hovered. */\\n-.wy-menu-vertical li a:hover{\\n- background-color: #A7AFFB;\\n-}\\n-\\n-/* The text items on the toc tree */\\n-.wy-menu-vertical a {\\n- color: #FFFFDD;\\n- font-family: Calibre-Light, sans-serif;\\n-}\\n-.wy-menu-vertical header, .wy-menu-vertical p.caption{\\n- color: white;\\n- font-family: Calibre-Light, sans-serif;\\n-}\\n-\\n-/* The color inside the selected toc tree block */\\n-.wy-menu-vertical li.toctree-l2 a, .wy-menu-vertical li.toctree-l3 a, .wy-menu-vertical li.toctree-l4 a {\\n- color: black;\\n-}\\n-\\n-/* Inside the depth-2 selected toc tree block */\\n-.wy-menu-vertical li.toctree-l2.current>a {\\n- background-color: #B6C0FF\\n-}\\n-.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a {\\n- background-color: #C6D0FF\\n-}\\n-\\n-/* Inside the depth-3 selected toc tree block */\\n-.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{\\n- background-color: #D6E0FF\\n-}\\n-\\n-/* Inside code snippets */\\n-.rst-content dl:not(.docutils) dt{\\n- font-size: 15px;\\n-}\\n-\\n-/* Links */\\n-a {\\n- color: #6670FF;\\n-}\\n-\\n-/* Content bars */\\n-.rst-content dl:not(.docutils) dt {\\n- background-color: rgba(251, 141, 104, 0.1);\\n- border-right: solid 2px #FB8D68;\\n- border-left: solid 2px #FB8D68;\\n- color: #FB8D68;\\n- font-family: Calibre-Light, sans-serif;\\n- border-top: none;\\n- font-style: normal !important;\\n-}\\n-\\n-/* Expand button */\\n-.wy-menu-vertical li.toctree-l2 span.toctree-expand,\\n-.wy-menu-vertical li.on a span.toctree-expand, .wy-menu-vertical li.current>a span.toctree-expand,\\n-.wy-menu-vertical li.toctree-l3 span.toctree-expand{\\n- color: black;\\n-}\\n-\\n-/* Max window size */\\n-.wy-nav-content{\\n- max-width: 1200px;\\n-}\\n-\\n-/* Mobile header */\\n-.wy-nav-top{\\n- background-color: #6670FF;\\n-}\\n-\\n-\\n-/* Source spans */\\n-.rst-content .viewcode-link, .rst-content .viewcode-back{\\n- color: #6670FF;\\n- font-size: 110%;\\n- letter-spacing: 2px;\\n- text-transform: uppercase;\\n-}\\n-\\n-/* It would be better for table to be visible without horizontal scrolling */\\n-.wy-table-responsive table td, .wy-table-responsive table th{\\n- white-space: normal;\\n-}\\n-\\n-.footer {\\n- margin-top: 20px;\\n-}\\n-\\n-.footer__Social {\\n- display: flex;\\n- flex-direction: row;\\n-}\\n-\\n-.footer__CustomImage {\\n- margin: 2px 5px 0 0;\\n-}\\n-\\n-/* class and method names in doc */\\n-.rst-content dl:not(.docutils) tt.descname, .rst-content dl:not(.docutils) tt.descclassname, .rst-content dl:not(.docutils) tt.descname, .rst-content dl:not(.docutils) code.descname, .rst-content dl:not(.docutils) tt.descclassname, .rst-content dl:not(.docutils) code.descclassname{\\n- font-family: Calibre, sans-serif;\\n- font-size: 20px !important;\\n-}\\n-\\n-/* class name in doc*/\\n-.rst-content dl:not(.docutils) tt.descname, .rst-content dl:not(.docutils) tt.descname, .rst-content dl:not(.docutils) code.descname{\\n- margin-right: 10px;\\n- font-family: Calibre-Medium, sans-serif;\\n-}\\n-\\n-/* Method and class parameters */\\n-.sig-param{\\n- line-height: 23px;\\n-}\\n-\\n-/* Class introduction \\\"class\\\" string at beginning */\\n-.rst-content dl:not(.docutils) .property{\\n- font-size: 18px;\\n- color: black;\\n-}\\n-\\n-\\n-/* FONTS */\\n-body{\\n- font-family: Calibre, sans-serif;\\n- font-size: 16px;\\n-}\\n-\\n-h1 {\\n- font-family: Calibre-Thin, sans-serif;\\n- font-size: 70px;\\n-}\\n-\\n-h2, .rst-content .toctree-wrapper p.caption, h3, h4, h5, h6, legend{\\n- font-family: Calibre-Medium, sans-serif;\\n-}\\n-\\n-@font-face {\\n- font-family: Calibre-Medium;\\n- src: url(./Calibre-Medium.otf);\\n- font-weight:400;\\n-}\\n-\\n-@font-face {\\n- font-family: Calibre;\\n- src: url(./Calibre-Regular.otf);\\n- font-weight:400;\\n-}\\n-\\n-@font-face {\\n- font-family: Calibre-Light;\\n- src: url(./Calibre-Light.ttf);\\n- font-weight:400;\\n-}\\n-\\n-@font-face {\\n- font-family: Calibre-Thin;\\n- src: url(./Calibre-Thin.otf);\\n- font-weight:400;\\n-}\\n-\\n-\\n-/**\\n- * Nav Links to other parts of huggingface.co\\n- */\\n- div.menu {\\n- position: absolute;\\n- top: 0;\\n- right: 0;\\n- padding-top: 20px;\\n- padding-right: 20px;\\n- z-index: 1000;\\n-}\\n-div.menu a {\\n- font-size: 14px;\\n- letter-spacing: 0.3px;\\n- text-transform: uppercase;\\n- color: white;\\n- -webkit-font-smoothing: antialiased;\\n- background: linear-gradient(0deg, #6671ffb8, #9a66ffb8 50%);\\n- padding: 10px 16px 6px 16px;\\n- border-radius: 3px;\\n- margin-left: 12px;\\n- position: relative;\\n-}\\n-div.menu a:active {\\n- top: 1px;\\n-}\\n-@media (min-width: 768px) and (max-width: 1750px) {\\n- .wy-breadcrumbs {\\n- margin-top: 32px;\\n- }\\n-}\\n-@media (max-width: 768px) {\\n- div.menu {\\n- display: none;\\n- }\\n-}\\ndiff --git a/docs/source/_static/js/custom.js b/docs/source/_static/js/custom.js\\ndeleted file mode 100644\\nindex a3841bcc2..000000000\\n--- a/docs/source/_static/js/custom.js\\n+++ /dev/null\\n@@ -1,167 +0,0 @@\\n-// These two things need to be updated at each release for the version selector.\\n-// Last stable version\\n-const stableVersion = \\\"v0.5.1\\\"\\n-// Dictionary doc folder to label. The last stable version should have an empty key.\\n-const versionMapping = {\\n- \\\"main\\\": \\\"main\\\",\\n- \\\"\\\": \\\"v0.5.0/v0.5.1 (stable)\\\",\\n- \\\"v0.4.0\\\": \\\"v0.4.0\\\",\\n- \\\"v0.3.0\\\": \\\"v0.3.0\\\",\\n- \\\"v0.2.0\\\": \\\"v0.2.0/v0.2.1\\\",\\n- \\\"v0.1.0\\\": \\\"v0.1.0\\\",\\n-}\\n-\\n-function addIcon() {\\n- const huggingFaceLogo = \\\"https://huggingface.co/landing/assets/transformers-docs/huggingface_logo.svg\\\";\\n- const image = document.createElement(\\\"img\\\");\\n- image.setAttribute(\\\"src\\\", huggingFaceLogo);\\n-\\n- const div = document.createElement(\\\"div\\\");\\n- div.appendChild(image);\\n- div.style.textAlign = 'center';\\n- div.style.paddingTop = '30px';\\n- div.style.backgroundColor = '#6670FF';\\n-\\n- const scrollDiv = document.querySelector(\\\".wy-side-scroll\\\");\\n- scrollDiv.prepend(div);\\n-}\\n-\\n-function addCustomFooter() {\\n- const customFooter = document.createElement(\\\"div\\\");\\n- const questionOrIssue = document.createElement(\\\"div\\\");\\n- questionOrIssue.innerHTML = \\\"Stuck? Read our <a href='https://medium.com/huggingface'>Blog posts</a> or <a href='https://github.com/huggingface/transformers'>Create an issue</a>\\\";\\n- customFooter.appendChild(questionOrIssue);\\n- customFooter.classList.add(\\\"footer\\\");\\n-\\n- const social = document.createElement(\\\"div\\\");\\n- social.classList.add(\\\"footer__Social\\\");\\n-\\n- const imageDetails = [\\n- { link: \\\"https://huggingface.co\\\", imageLink: \\\"https://huggingface.co/landing/assets/transformers-docs/website.svg\\\" },\\n- { link: \\\"https://twitter.com/huggingface\\\", imageLink: \\\"https://huggingface.co/landing/assets/transformers-docs/twitter.svg\\\" },\\n- { link: \\\"https://github.com/huggingface\\\", imageLink: \\\"https://huggingface.co/landing/assets/transformers-docs/github.svg\\\" },\\n- { link: \\\"https://www.linkedin.com/company/huggingface/\\\", imageLink: \\\"https://huggingface.co/landing/assets/transformers-docs/linkedin.svg\\\" }\\n- ];\\n-\\n- imageDetails.forEach(imageLinks => {\\n- const link = document.createElement(\\\"a\\\");\\n- const image = document.createElement(\\\"img\\\");\\n- image.src = imageLinks.imageLink;\\n- link.href = imageLinks.link;\\n- image.style.width = \\\"30px\\\";\\n- image.classList.add(\\\"footer__CustomImage\\\");\\n- link.appendChild(image);\\n- social.appendChild(link);\\n- });\\n-\\n- customFooter.appendChild(social);\\n- document.querySelector(\\\"footer\\\").appendChild(customFooter);\\n-}\\n-\\n-function addGithubButton() {\\n- const div = `\\n- <div class=\\\"github-repo\\\">\\n- <a \\n- class=\\\"github-button\\\"\\n- href=\\\"https://github.com/huggingface/accelerate\\\" data-size=\\\"large\\\" data-show-count=\\\"true\\\" aria-label=\\\"Star huggingface/accelerate on GitHub\\\">\\n- Star\\n- </a>\\n- </div>\\n- `;\\n- document.querySelector(\\\".wy-side-nav-search .icon-home\\\").insertAdjacentHTML('afterend', div);\\n-}\\n-\\n-function addVersionControl() {\\n- // To grab the version currently in view, we parse the url\\n- const parts = location.toString().split('/');\\n- let versionIndex = parts.length - 2;\\n- // Index page may not have a last part with filename.html so we need to go up\\n- if (parts[parts.length - 1] != \\\"\\\" && ! parts[parts.length - 1].match(/\\\\.html$|^search.html?/)) {\\n- versionIndex = parts.length - 1;\\n- }\\n- // Main classes and models are nested so we need to go deeper\\n- else if (parts[versionIndex] == \\\"main_classes\\\" || parts[versionIndex] == \\\"model_doc\\\") {\\n- versionIndex = versionIndex - 1;\\n- } \\n- const version = parts[versionIndex];\\n-\\n- // Menu with all the links,\\n- const versionMenu = document.createElement(\\\"div\\\");\\n-\\n- const htmlLines = [];\\n- for (const [key, value] of Object.entries(versionMapping)) {\\n- let baseUrlIndex = (version == \\\"accelerate\\\") ? versionIndex + 1: versionIndex;\\n- var urlParts = parts.slice(0, baseUrlIndex);\\n- if (key != \\\"\\\") {\\n- urlParts = urlParts.concat([key]);\\n- }\\n- urlParts = urlParts.concat(parts.slice(versionIndex+1));\\n- htmlLines.push(`<a href=\\\"${urlParts.join('/')}\\\">${value}</a>`);\\n- }\\n-\\n- versionMenu.classList.add(\\\"version-dropdown\\\");\\n- versionMenu.innerHTML = htmlLines.join('\\\\n');\\n- \\n- // Button for version selection\\n- const versionButton = document.createElement(\\\"div\\\");\\n- versionButton.classList.add(\\\"version-button\\\");\\n- let label = (version == \\\"accelerate\\\") ? stableVersion : version\\n- versionButton.innerText = label.concat(\\\" βΌ\\\");\\n-\\n- // Toggle the menu when we click on the button\\n- versionButton.addEventListener(\\\"click\\\", () => {\\n- versionMenu.classList.toggle(\\\"version-show\\\");\\n- });\\n-\\n- // Hide the menu when we click elsewhere\\n- window.addEventListener(\\\"click\\\", (event) => {\\n- if (event.target != versionButton){\\n- versionMenu.classList.remove('version-show');\\n- }\\n- });\\n-\\n- // Container\\n- const div = document.createElement(\\\"div\\\");\\n- div.appendChild(versionButton);\\n- div.appendChild(versionMenu);\\n- div.style.paddingTop = '25px';\\n- div.style.backgroundColor = '#6670FF';\\n- div.style.display = 'block';\\n- div.style.textAlign = 'center';\\n-\\n- const scrollDiv = document.querySelector(\\\".wy-side-scroll\\\");\\n- scrollDiv.insertBefore(div, scrollDiv.children[1]);\\n-}\\n-\\n-function addHfMenu() {\\n- const div = `\\n- <div class=\\\"menu\\\">\\n- <a href=\\\"/welcome\\\">π₯ Sign in</a>\\n- <a href=\\\"/models\\\">π Models</a>\\n- <a href=\\\"http://discuss.huggingface.co\\\">π¬ Forum</a>\\n- </div>\\n- `;\\n- document.body.insertAdjacentHTML('afterbegin', div);\\n-}\\n-\\n-/*!\\n- * github-buttons v2.2.10\\n- * (c) 2019 γͺγ€γ\\n- * @license BSD-2-Clause\\n- */\\n-/**\\n- * modified to run programmatically\\n- */\\n-function parseGithubButtons (){\\\"use strict\\\";var e=window.document,t=e.location,o=window.encodeURIComponent,r=window.decodeURIComponent,n=window.Math,a=window.HTMLElement,i=window.XMLHttpRequest,l=\\\"https://unpkg.com/github-buttons@2.2.10/dist/buttons.html\\\",c=i&&i.prototype&&\\\"withCredentials\\\"in i.prototype,d=c&&a&&a.prototype.attachShadow&&!a.prototype.attachShadow.prototype,s=function(e,t,o){e.addEventListener?e.addEventListener(t,o):e.attachEvent(\\\"on\\\"+t,o)},u=function(e,t,o){e.removeEventListener?e.removeEventListener(t,o):e.detachEvent(\\\"on\\\"+t,o)},h=function(e,t,o){var r=function(n){return u(e,t,r),o(n)};s(e,t,r)},f=function(e,t,o){var r=function(n){if(t.test(e.readyState))return u(e,\\\"readystatechange\\\",r),o(n)};s(e,\\\"readystatechange\\\",r)},p=function(e){return function(t,o,r){var n=e.createElement(t);if(o)for(var a in o){var i=o[a];null!=i&&(null!=n[a]?n[a]=i:n.setAttribute(a,i))}if(r)for(var l=0,c=r.length;l<c;l++){var d=r[l];n.appendChild(\\\"string\\\"==typeof d?e.createTextNode(d):d)}return n}},g=p(e),b=function(e){var t;return function(){t||(t=1,e.apply(this,arguments))}},m=\\\"body{margin:0}a{color:#24292e;text-decoration:none;outline:0}.octicon{display:inline-block;vertical-align:text-top;fill:currentColor}.widget{ display:inline-block;overflow:hidden;font-family:-apple-system, BlinkMacSystemFont, \\\\\\\"Segoe UI\\\\\\\", Helvetica, Arial, sans-serif;font-size:0;white-space:nowrap;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.btn,.social-count{display:inline-block;height:14px;padding:2px 5px;font-size:11px;font-weight:600;line-height:14px;vertical-align:bottom;cursor:pointer;border:1px solid #c5c9cc;border-radius:0.25em}.btn{background-color:#eff3f6;background-image:-webkit-linear-gradient(top, #fafbfc, #eff3f6 90%);background-image:-moz-linear-gradient(top, #fafbfc, #eff3f6 90%);background-image:linear-gradient(180deg, #fafbfc, #eff3f6 90%);background-position:-1px -1px;background-repeat:repeat-x;background-size:110% 110%;border-color:rgba(27,31,35,0.2);-ms-filter:\\\\\\\"progid:DXImageTransform.Microsoft.Gradient(startColorstr='#FFFAFBFC', endColorstr='#FFEEF2F5')\\\\\\\";*filter:progid:DXImageTransform.Microsoft.Gradient(startColorstr='#FFFAFBFC', endColorstr='#FFEEF2F5')}.btn:active{background-color:#e9ecef;background-image:none;border-color:#a5a9ac;border-color:rgba(27,31,35,0.35);box-shadow:inset 0 0.15em 0.3em rgba(27,31,35,0.15)}.btn:focus,.btn:hover{background-color:#e6ebf1;background-image:-webkit-linear-gradient(top, #f0f3f6, #e6ebf1 90%);background-image:-moz-linear-gradient(top, #f0f3f6, #e6ebf1 90%);background-image:linear-gradient(180deg, #f0f3f6, #e6ebf1 90%);border-color:#a5a9ac;border-color:rgba(27,31,35,0.35);-ms-filter:\\\\\\\"progid:DXImageTransform.Microsoft.Gradient(startColorstr='#FFF0F3F6', endColorstr='#FFE5EAF0')\\\\\\\";*filter:progid:DXImageTransform.Microsoft.Gradient(startColorstr='#FFF0F3F6', endColorstr='#FFE5EAF0')}.social-count{position:relative;margin-left:5px;background-color:#fff}.social-count:focus,.social-count:hover{color:#0366d6}.social-count b,.social-count i{position:absolute;top:50%;left:0;display:block;width:0;height:0;margin:-4px 0 0 -4px;border:solid transparent;border-width:4px 4px 4px 0;_line-height:0;_border-top-color:red !important;_border-bottom-color:red !important;_border-left-color:red !important;_filter:chroma(color=red)}.social-count b{border-right-color:#c5c9cc}.social-count i{margin-left:-3px;border-right-color:#fff}.lg .btn,.lg .social-count{height:16px;padding:5px 10px;font-size:12px;line-height:16px}.lg .social-count{margin-left:6px}.lg .social-count b,.lg .social-count i{margin:-5px 0 0 -5px;border-width:5px 5px 5px 0}.lg .social-count i{margin-left:-4px}\\\\n\\\",v={\\\"mark-github\\\":{width:16,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z\\\"/>'},eye:{width:16,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M8.06 2C3 2 0 8 0 8s3 6 8.06 6C13 14 16 8 16 8s-3-6-7.94-6zM8 12c-2.2 0-4-1.78-4-4 0-2.2 1.8-4 4-4 2.22 0 4 1.8 4 4 0 2.22-1.78 4-4 4zm2-4c0 1.11-.89 2-2 2-1.11 0-2-.89-2-2 0-1.11.89-2 2-2 1.11 0 2 .89 2 2z\\\"/>'},star:{width:14,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M14 6l-4.9-.64L7 1 4.9 5.36 0 6l3.6 3.26L2.67 14 7 11.67 11.33 14l-.93-4.74L14 6z\\\"/>'},\\\"repo-forked\\\":{width:10,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M8 1a1.993 1.993 0 0 0-1 3.72V6L5 8 3 6V4.72A1.993 1.993 0 0 0 2 1a1.993 1.993 0 0 0-1 3.72V6.5l3 3v1.78A1.993 1.993 0 0 0 5 15a1.993 1.993 0 0 0 1-3.72V9.5l3-3V4.72A1.993 1.993 0 0 0 8 1zM2 4.2C1.34 4.2.8 3.65.8 3c0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3 10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2zm3-10c-.66 0-1.2-.55-1.2-1.2 0-.65.55-1.2 1.2-1.2.65 0 1.2.55 1.2 1.2 0 .65-.55 1.2-1.2 1.2z\\\"/>'},\\\"issue-opened\\\":{width:14,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M7 2.3c3.14 0 5.7 2.56 5.7 5.7s-2.56 5.7-5.7 5.7A5.71 5.71 0 0 1 1.3 8c0-3.14 2.56-5.7 5.7-5.7zM7 1C3.14 1 0 4.14 0 8s3.14 7 7 7 7-3.14 7-7-3.14-7-7-7zm1 3H6v5h2V4zm0 6H6v2h2v-2z\\\"/>'},\\\"cloud-download\\\":{width:16,height:16,path:'<path fill-rule=\\\"evenodd\\\" d=\\\"M9 12h2l-3 3-3-3h2V7h2v5zm3-8c0-.44-.91-3-4.5-3C5.08 1 3 2.92 3 5 1.02 5 0 6.52 0 8c0 1.53 1 3 3 3h3V9.7H3C1.38 9.7 1.3 8.28 1.3 8c0-.17.05-1.7 1.7-1.7h1.3V5c0-1.39 1.56-2.7 3.2-2.7 2.55 0 3.13 1.55 3.2 1.8v1.2H12c.81 0 2.7.22 2.7 2.2 0 2.09-2.25 2.2-2.7 2.2h-2V11h2c2.08 0 4-1.16 4-3.5C16 5.06 14.08 4 12 4z\\\"/>'}},w={},x=function(e,t,o){var r=p(e.ownerDocument),n=e.appendChild(r(\\\"style\\\",{type:\\\"text/css\\\"}));n.styleSheet?n.styleSheet.cssText=m:n.appendChild(e.ownerDocument.createTextNode(m));var a,l,d=r(\\\"a\\\",{className:\\\"btn\\\",href:t.href,target:\\\"_blank\\\",innerHTML:(a=t[\\\"data-icon\\\"],l=/^large$/i.test(t[\\\"data-size\\\"])?16:14,a=(\\\"\\\"+a).toLowerCase().replace(/^octicon-/,\\\"\\\"),{}.hasOwnProperty.call(v,a)||(a=\\\"mark-github\\\"),'<svg version=\\\"1.1\\\" width=\\\"'+l*v[a].width/v[a].height+'\\\" height=\\\"'+l+'\\\" viewBox=\\\"0 0 '+v[a].width+\\\" \\\"+v[a].height+'\\\" class=\\\"octicon octicon-'+a+'\\\" aria-hidden=\\\"true\\\">'+v[a].path+\\\"</svg>\\\"),\\\"aria-label\\\":t[\\\"aria-label\\\"]||void 0},[\\\" \\\",r(\\\"span\\\",{},[t[\\\"data-text\\\"]||\\\"\\\"])]);/\\\\.github\\\\.com$/.test(\\\".\\\"+d.hostname)?/^https?:\\\\/\\\\/((gist\\\\.)?github\\\\.com\\\\/[^\\\\/?#]+\\\\/[^\\\\/?#]+\\\\/archive\\\\/|github\\\\.com\\\\/[^\\\\/?#]+\\\\/[^\\\\/?#]+\\\\/releases\\\\/download\\\\/|codeload\\\\.github\\\\.com\\\\/)/.test(d.href)&&(d.target=\\\"_top\\\"):(d.href=\\\"#\\\",d.target=\\\"_self\\\");var u,h,g,x,y=e.appendChild(r(\\\"div\\\",{className:\\\"widget\\\"+(/^large$/i.test(t[\\\"data-size\\\"])?\\\" lg\\\":\\\"\\\")},[d]));/^(true|1)$/i.test(t[\\\"data-show-count\\\"])&&\\\"github.com\\\"===d.hostname&&(u=d.pathname.replace(/^(?!\\\\/)/,\\\"/\\\").match(/^\\\\/([^\\\\/?#]+)(?:\\\\/([^\\\\/?#]+)(?:\\\\/(?:(subscription)|(fork)|(issues)|([^\\\\/?#]+)))?)?(?:[\\\\/?#]|$)/))&&!u[6]?(u[2]?(h=\\\"/repos/\\\"+u[1]+\\\"/\\\"+u[2],u[3]?(x=\\\"subscribers_count\\\",g=\\\"watchers\\\"):u[4]?(x=\\\"forks_count\\\",g=\\\"network\\\"):u[5]?(x=\\\"open_issues_count\\\",g=\\\"issues\\\"):(x=\\\"stargazers_count\\\",g=\\\"stargazers\\\")):(h=\\\"/users/\\\"+u[1],g=x=\\\"followers\\\"),function(e,t){var o=w[e]||(w[e]=[]);if(!(o.push(t)>1)){var r=b(function(){for(delete w[e];t=o.shift();)t.apply(null,arguments)});if(c){var n=new i;s(n,\\\"abort\\\",r),s(n,\\\"error\\\",r),s(n,\\\"load\\\",function(){var e;try{e=JSON.parse(n.responseText)}catch(e){return void r(e)}r(200!==n.status,e)}),n.open(\\\"GET\\\",e),n.send()}else{var a=this||window;a._=function(e){a._=null,r(200!==e.meta.status,e.data)};var l=p(a.document)(\\\"script\\\",{async:!0,src:e+(/\\\\?/.test(e)?\\\"&\\\":\\\"?\\\")+\\\"callback=_\\\"}),d=function(){a._&&a._({meta:{}})};s(l,\\\"load\\\",d),s(l,\\\"error\\\",d),l.readyState&&f(l,/de|m/,d),a.document.getElementsByTagName(\\\"head\\\")[0].appendChild(l)}}}.call(this,\\\"https://api.github.com\\\"+h,function(e,t){if(!e){var n=t[x];y.appendChild(r(\\\"a\\\",{className:\\\"social-count\\\",href:t.html_url+\\\"/\\\"+g,target:\\\"_blank\\\",\\\"aria-label\\\":n+\\\" \\\"+x.replace(/_count$/,\\\"\\\").replace(\\\"_\\\",\\\" \\\").slice(0,n<2?-1:void 0)+\\\" on GitHub\\\"},[r(\\\"b\\\"),r(\\\"i\\\"),r(\\\"span\\\",{},[(\\\"\\\"+n).replace(/\\\\B(?=(\\\\d{3})+(?!\\\\d))/g,\\\",\\\")])]))}o&&o(y)})):o&&o(y)},y=window.devicePixelRatio||1,C=function(e){return(y>1?n.ceil(n.round(e*y)/y*2)/2:n.ceil(e))||0},F=function(e,t){e.style.width=t[0]+\\\"px\\\",e.style.height=t[1]+\\\"px\\\"},k=function(t,r){if(null!=t&&null!=r)if(t.getAttribute&&(t=function(e){for(var t={href:e.href,title:e.title,\\\"aria-label\\\":e.getAttribute(\\\"aria-label\\\")},o=[\\\"icon\\\",\\\"text\\\",\\\"size\\\",\\\"show-count\\\"],r=0,n=o.length;r<n;r++){var a=\\\"data-\\\"+o[r];t[a]=e.getAttribute(a)}return null==t[\\\"data-text\\\"]&&(t[\\\"data-text\\\"]=e.textContent||e.innerText),t}(t)),d){var a=g(\\\"span\\\",{title:t.title||void 0});x(a.attachShadow({mode:\\\"closed\\\"}),t,function(){r(a)})}else{var i=g(\\\"iframe\\\",{src:\\\"javascript:0\\\",title:t.title||void 0,allowtransparency:!0,scrolling:\\\"no\\\",frameBorder:0});F(i,[0,0]),i.style.border=\\\"none\\\";var c=function(){var a,d=i.contentWindow;try{a=d.document.body}catch(t){return void e.body.appendChild(i.parentNode.removeChild(i))}u(i,\\\"load\\\",c),x.call(d,a,t,function(e){var a=function(e){var t=e.offsetWidth,o=e.offsetHeight;if(e.getBoundingClientRect){var r=e.getBoundingClientRect();t=n.max(t,C(r.width)),o=n.max(o,C(r.height))}return[t,o]}(e);i.parentNode.removeChild(i),h(i,\\\"load\\\",function(){F(i,a)}),i.src=l+\\\"#\\\"+(i.name=function(e){var t=[];for(var r in e){var n=e[r];null!=n&&t.push(o(r)+\\\"=\\\"+o(n))}return t.join(\\\"&\\\")}(t)),r(i)})};s(i,\\\"load\\\",c),e.body.appendChild(i)}};t.protocol+\\\"//\\\"+t.host+t.pathname===l?x(e.body,function(e){for(var t={},o=e.split(\\\"&\\\"),n=0,a=o.length;n<a;n++){var i=o[n];if(\\\"\\\"!==i){var l=i.split(\\\"=\\\");t[r(l[0])]=null!=l[1]?r(l.slice(1).join(\\\"=\\\")):void 0}}return t}(window.name||t.hash.replace(/^#/,\\\"\\\"))):function(t){if(/m/.test(e.readyState)||!/g/.test(e.readyState)&&!e.documentElement.doScroll)setTimeout(t);else if(e.addEventListener){var o=b(t);h(e,\\\"DOMContentLoaded\\\",o),h(window,\\\"load\\\",o)}else f(e,/m/,t)}(function(){for(var t=e.querySelectorAll?e.querySelectorAll(\\\"a.github-button\\\"):function(){for(var t=[],o=e.getElementsByTagName(\\\"a\\\"),r=0,n=o.length;r<n;r++)~(\\\" \\\"+o[r].className+\\\" \\\").replace(/[ \\\\t\\\\n\\\\f\\\\r]+/g,\\\" \\\").indexOf(\\\" github-button \\\")&&t.push(o[r]);return t}(),o=0,r=t.length;o<r;o++)!function(e){k(e,function(t){e.parentNode.replaceChild(t,e)})}(t[o])})};\\n-\\n-\\n-function onLoad() {\\n- addIcon();\\n- addVersionControl();\\n- addCustomFooter();\\n- addGithubButton();\\n- parseGithubButtons();\\n- addHfMenu();\\n-}\\n-\\n-window.addEventListener(\\\"load\\\", onLoad);\\ndiff --git a/docs/source/_static/js/huggingface_logo.svg b/docs/source/_static/js/huggingface_logo.svg\\ndeleted file mode 100644\\nindex 79a9e5d8a..000000000\\n--- a/docs/source/_static/js/huggingface_logo.svg\\n+++ /dev/null\\n@@ -1 +0,0 @@\\n-<svg clip-rule=\\\"evenodd\\\" fill-rule=\\\"evenodd\\\" stroke-linejoin=\\\"round\\\" stroke-miterlimit=\\\"2\\\" viewBox=\\\"0 0 127 118\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\" xmlns:xlink=\\\"http://www.w3.org/1999/xlink\\\"><clipPath id=\\\"a\\\"><path clip-rule=\\\"nonzero\\\" d=\\\"m62 75.052c13.105 0 17.333-11.684 17.333-17.684 0-3.118-2.096-2.136-5.453-.474-3.103 1.536-7.282 3.653-11.88 3.653-9.573 0-17.333-9.179-17.333-3.179s4.228 17.684 17.333 17.684z\\\"/></clipPath><path d=\\\"m125.057 93.44c1 2.88.76 5.947-.573 8.613-.96 1.947-2.333 3.454-4.013 4.8-2.027 1.6-4.547 2.96-7.587 4.267-3.627 1.547-8.053 3-10.08 3.533-5.187 1.347-10.173 2.2-15.227 2.24-7.226.067-13.453-1.64-17.88-6-2.293.28-4.613.44-6.946.44-2.214 0-4.4-.133-6.574-.4-4.44 4.334-10.64 6.027-17.84 5.96-5.053-.04-10.04-.893-15.24-2.24-2.013-.533-6.44-1.986-10.066-3.533-3.04-1.307-5.56-2.667-7.574-4.267-1.693-1.346-3.066-2.853-4.026-4.8-1.32-2.666-1.574-5.733-.56-8.613-.934-2.2-1.174-4.72-.44-7.507.333-1.266.88-2.44 1.573-3.48-.147-.546-.267-1.106-.347-1.72-.506-3.653.76-6.986 3.147-9.573 1.173-1.293 2.44-2.187 3.76-2.76-.973-4.133-1.48-8.387-1.48-12.733 0-30.747 24.92-55.667 55.667-55.667 10.56 0 20.44 2.933 28.866 8.053 1.52.934 3.014 1.934 4.44 3 .707.534 1.414 1.08 2.094 1.654.693.56 1.373 1.146 2.026 1.746 1.974 1.8 3.827 3.734 5.52 5.8.574.68 1.12 1.387 1.654 2.107 1.08 1.427 2.08 2.907 3 4.44 1.4 2.293 2.626 4.693 3.693 7.187.707 1.666 1.32 3.373 1.867 5.12.813 2.613 1.44 5.306 1.866 8.08.134.92.254 1.853.347 2.786.187 1.867.293 3.76.293 5.694 0 4.293-.506 8.506-1.453 12.573 1.467.573 2.853 1.507 4.147 2.92 2.386 2.587 3.653 5.933 3.146 9.587-.08.6-.2 1.16-.346 1.706.693 1.04 1.24 2.214 1.573 3.48.733 2.787.493 5.307-.427 7.507\\\" fill=\\\"#fff\\\" fill-rule=\\\"nonzero\\\"/><circle cx=\\\"62.333\\\" cy=\\\"55.667\\\" fill=\\\"#ffd21e\\\" r=\\\"46.333\\\"/><g fill-rule=\\\"nonzero\\\"><path d=\\\"m108.667 55.667c0-25.59-20.744-46.334-46.334-46.334-25.589 0-46.333 20.744-46.333 46.334 0 25.589 20.744 46.333 46.333 46.333 25.59 0 46.334-20.744 46.334-46.333zm-98 0c0-28.535 23.132-51.667 51.666-51.667 28.535 0 51.667 23.132 51.667 51.667 0 28.534-23.132 51.666-51.667 51.666-28.534 0-51.666-23.132-51.666-51.666z\\\" fill=\\\"#ffac03\\\"/><path d=\\\"m77.387 43.055c1.7.6 2.376 4.093 4.092 3.181 3.251-1.729 4.485-5.765 2.757-9.016-1.729-3.251-5.765-4.485-9.016-2.757-3.251 1.729-4.485 5.765-2.757 9.016.816 1.535 3.406-.96 4.924-.424z\\\" fill=\\\"#3a3b45\\\"/><path d=\\\"m45.978 43.055c-1.699.6-2.375 4.093-4.092 3.181-3.251-1.729-4.485-5.765-2.756-9.016 1.728-3.251 5.765-4.485 9.016-2.757 3.251 1.729 4.485 5.765 2.756 9.016-.815 1.535-3.405-.96-4.924-.424z\\\" fill=\\\"#3a3b45\\\"/><path d=\\\"m62 75.052c13.105 0 17.333-11.684 17.333-17.684 0-3.118-2.096-2.136-5.453-.474-3.103 1.536-7.282 3.653-11.88 3.653-9.573 0-17.333-9.179-17.333-3.179s4.228 17.684 17.333 17.684z\\\" fill=\\\"#3a3b45\\\"/></g><g clip-path=\\\"url(#a)\\\"><path d=\\\"m62.333 88.667c6.387 0 11.564-5.178 11.564-11.564 0-4.975-3.141-9.216-7.548-10.848-.162-.06-.326-.116-.491-.169-1.111-.355-2.296 3.464-3.525 3.464-1.148 0-2.257-3.844-3.305-3.532-4.776 1.422-8.259 5.847-8.259 11.085 0 6.386 5.178 11.564 11.564 11.564z\\\" fill=\\\"#ef4e4e\\\" fill-rule=\\\"nonzero\\\"/></g><circle cx=\\\"93.667\\\" cy=\\\"45\\\" fill=\\\"#ffd21e\\\" r=\\\"4.333\\\"/><circle cx=\\\"31.667\\\" cy=\\\"45\\\" fill=\\\"#ffd21e\\\" r=\\\"4.333\\\"/><path d=\\\"m22.749 64c-2.158 0-4.088.887-5.433 2.495-.832.996-1.701 2.601-1.772 5.005-.905-.26-1.776-.405-2.589-.405-2.067 0-3.934.792-5.254 2.23-1.696 1.847-2.449 4.116-2.121 6.387.156 1.081.517 2.051 1.057 2.948-1.138.921-1.977 2.204-2.382 3.747-.318 1.209-.643 3.728 1.056 6.322-.108.17-.21.346-.304.526-1.022 1.938-1.087 4.129-.186 6.169 1.367 3.092 4.763 5.528 11.358 8.143 4.102 1.626 7.856 2.666 7.889 2.676 5.424 1.406 10.329 2.121 14.576 2.121 7.805 0 13.393-2.391 16.609-7.105 5.176-7.592 4.436-14.536-2.261-21.23-3.707-3.704-6.171-9.165-6.684-10.364-1.035-3.549-3.771-7.494-8.319-7.494h-.001c-.383 0-.769.03-1.151.09-1.992.314-3.733 1.46-4.977 3.186-1.343-1.67-2.647-2.998-3.827-3.747-1.778-1.128-3.556-1.7-5.284-1.7m0 5.333c.68 0 1.511.29 2.427.871 2.844 1.804 8.332 11.237 10.341 14.907.674 1.229 1.824 1.749 2.86 1.749 2.056 0 3.662-2.044.188-4.641-5.222-3.908-3.39-10.296-.897-10.69.109-.017.217-.025.321-.025 2.267 0 3.267 3.907 3.267 3.907s2.931 7.36 7.965 12.39c5.035 5.032 5.295 9.071 1.626 14.452-2.503 3.67-7.294 4.778-12.203 4.778-5.092 0-10.312-1.192-13.237-1.951-.144-.037-17.935-5.063-15.682-9.34.379-.719 1.003-1.007 1.788-1.007 3.174 0 8.946 4.723 11.427 4.723.555 0 .945-.236 1.105-.812 1.058-3.793-16.076-5.388-14.632-10.883.255-.972.946-1.366 1.916-1.365 4.194 0 13.602 7.375 15.574 7.375.15 0 .258-.044.317-.138.988-1.594.447-2.708-6.517-6.922-6.964-4.216-11.852-6.752-9.072-9.779.32-.349.773-.504 1.324-.504 4.228.001 14.217 9.092 14.217 9.092s2.696 2.804 4.327 2.804c.374 0 .693-.148.909-.513 1.156-1.95-10.737-10.963-11.408-14.682-.455-2.52.319-3.796 1.749-3.796\\\" fill=\\\"#ffac03\\\" fill-rule=\\\"nonzero\\\"/><path d=\\\"m50.846 102.253c3.67-5.381 3.41-9.42-1.625-14.452-5.035-5.03-7.965-12.39-7.965-12.39s-1.095-4.275-3.588-3.882c-2.494.394-4.324 6.782.898 10.69 5.223 3.906-1.04 6.561-3.049 2.892-2.009-3.67-7.496-13.103-10.341-14.907-2.844-1.804-4.847-.793-4.176 2.925.67 3.719 12.565 12.732 11.408 14.683-1.158 1.949-5.236-2.292-5.236-2.292s-12.763-11.615-15.542-8.588c-2.778 3.027 2.108 5.563 9.072 9.779 6.966 4.214 7.506 5.328 6.518 6.922-.99 1.595-16.363-11.366-17.807-5.872-1.443 5.495 15.689 7.09 14.632 10.883-1.057 3.795-12.068-7.18-14.32-2.904-2.253 4.277 15.537 9.303 15.681 9.34 5.747 1.491 20.342 4.649 25.44-2.827\\\" fill=\\\"#ffd21e\\\" fill-rule=\\\"nonzero\\\"/><path d=\\\"m102.584 64c2.159 0 4.088.887 5.433 2.495.832.996 1.702 2.601 1.772 5.005.906-.26 1.776-.405 2.59-.405 2.066 0 3.933.792 5.253 2.23 1.696 1.847 2.449 4.116 2.121 6.387-.156 1.081-.517 2.051-1.057 2.948 1.139.921 1.977 2.204 2.383 3.747.317 1.209.642 3.728-1.056 6.322.108.17.209.346.304.526 1.021 1.938 1.086 4.129.185 6.169-1.367 3.092-4.763 5.528-11.357 8.143-4.103 1.626-7.856 2.666-7.89 2.676-5.424 1.406-10.329 2.121-14.576 2.121-7.805 0-13.393-2.391-16.609-7.105-5.176-7.592-4.436-14.536 2.261-21.23 3.707-3.704 6.171-9.165 6.684-10.364 1.035-3.549 3.771-7.494 8.319-7.494h.001c.383 0 .77.03 1.151.09 1.992.314 3.733 1.46 4.977 3.186 1.343-1.67 2.647-2.998 3.827-3.747 1.779-1.128 3.556-1.7 5.284-1.7m0 5.333c-.68 0-1.511.29-2.427.871-2.844 1.804-8.332 11.237-10.341 14.907-.673 1.229-1.824 1.749-2.86 1.749-2.056 0-3.661-2.044-.188-4.641 5.223-3.908 3.391-10.296.897-10.69-.109-.017-.217-.025-.321-.025-2.267 0-3.267 3.907-3.267 3.907s-2.93 7.36-7.965 12.39c-5.035 5.032-5.295 9.071-1.625 14.452 2.502 3.67 7.293 4.778 12.202 4.778 5.092 0 10.312-1.192 13.238-1.951.144-.037 17.934-5.063 15.681-9.34-.379-.719-1.003-1.007-1.788-1.007-3.173 0-8.945 4.723-11.427 4.723-.554 0-.945-.236-1.105-.812-1.057-3.793 16.076-5.388 14.632-10.883-.255-.972-.945-1.366-1.916-1.365-4.193 0-13.601 7.375-15.573 7.375-.151 0-.259-.044-.318-.138-.988-1.594-.446-2.708 6.518-6.922 6.964-4.216 11.852-6.752 9.072-9.779-.32-.349-.774-.504-1.324-.504-4.228.001-14.218 9.092-14.218 9.092s-2.696 2.804-4.326 2.804c-.375 0-.694-.148-.91-.513-1.156-1.95 10.738-10.963 11.408-14.682.455-2.52-.318-3.796-1.749-3.796\\\" fill=\\\"#ffac03\\\" fill-rule=\\\"nonzero\\\"/><path d=\\\"m74.487 102.253c-3.669-5.381-3.409-9.42 1.625-14.452 5.035-5.03 7.966-12.39 7.966-12.39s1.094-4.275 3.588-3.882c2.493.394 4.324 6.782-.899 10.69-5.223 3.906 1.04 6.561 3.049 2.892 2.01-3.67 7.496-13.103 10.342-14.907 2.844-1.804 4.846-.793 4.176 2.925-.671 3.719-12.566 12.732-11.408 14.683 1.157 1.949 5.236-2.292 5.236-2.292s12.762-11.615 15.541-8.588-2.108 5.563-9.072 9.779c-6.965 4.214-7.505 5.328-6.517 6.922.989 1.595 16.362-11.366 17.806-5.872 1.443 5.495-15.689 7.09-14.632 10.883 1.058 3.795 12.068-7.18 14.32-2.904 2.254 4.277-15.537 9.303-15.681 9.34-5.747 1.491-20.341 4.649-25.44-2.827\\\" fill=\\\"#ffd21e\\\" fill-rule=\\\"nonzero\\\"/></svg>\\n\\\\ No newline at end of file\\ndiff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml\\nnew file mode 100644\\nindex 000000000..20f963aae\\n--- /dev/null\\n+++ b/docs/source/_toctree.yml\\n@@ -0,0 +1,22 @@\\n+- sections: \\n+ - local: index\\n+ title: π€ Accelerate\\n+ - local: quicktour\\n+ title: Quick tour\\n+ - local: installation\\n+ title: Installation\\n+ title: Get started\\n+- sections:\\n+ - local: sagemaker\\n+ title: Amazon SageMaker\\n+ title: Guides\\n+- sections:\\n+ - local: accelerator\\n+ title: Accelerator\\n+ - local: launcher\\n+ title: Notebook Launcher\\n+ - local: kwargs\\n+ title: Kwargs Handlers\\n+ - local: internal\\n+ title: Internals\\n+ title: API Reference\\ndiff --git a/docs/source/accelerator.mdx b/docs/source/accelerator.mdx\\nnew file mode 100644\\nindex 000000000..990b75443\\n--- /dev/null\\n+++ b/docs/source/accelerator.mdx\\n@@ -0,0 +1,41 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Accelerator\\n+\\n+The [`Accelerator`] is the main class provided by π€ Accelerate. It serves at the main entrypoint for\\n+the API. To quickly adapt your script to work on any kind of setup with π€ Accelerate juste:\\n+\\n+1. Initialize an [`Accelerator`] object (that we will call `accelerator` in the rest of this\\n+ page) as early as possible in your script.\\n+2. Pass along your model(s), optimizer(s), dataloader(s) to the [`~Accelerator.prepare`] method.\\n+3. (Optional but best practice) Remove all the `.cuda()` or `.to(device)` in your code and let the\\n+ `accelerator` handle device placement for you.\\n+4. Replace the `loss.backward()` in your code by `accelerator.backward(loss)`.\\n+5. (Optional, when using distributed evaluation) Gather your predictions and labelsbefore storing them or using them\\n+ for metric computation using [`~Accelerator.gather`].\\n+\\n+This is all what is needed in most cases. For more advanced case or a nicer experience here are the functions you\\n+should search for and replace by the corresponding methods of your `accelerator`:\\n+\\n+- `print` statements should be replaced by [`~Accelerator.print`] to be only printed once per\\n+ process.\\n+- Use [`~Accelerator.is_local_main_process`] for statements that should be executed once per server.\\n+- Use [`~Accelerator.is_main_process`] for statements that should be executed once only.\\n+- Use [`~Accelerator.wait_for_everyone`] to make sure all processes join that point before continuing\\n+ (useful before a model save for instance).\\n+- Use [`~Accelerator.unwrap_model`] to unwrap your model before saving it.\\n+- Use [`~Accelerator.save`] instead of `torch.save`.\\n+- Use [`~Accelerator.clip_grad_norm_`] instead of `torch.nn.utils.clip_grad_norm_` and\\n+ [`~Accelerator.clip_grad_value_`] instead of `torch.nn.utils.clip_grad_value_`.\\n+\\n+[[autodoc]] Accelerator\\ndiff --git a/docs/source/accelerator.rst b/docs/source/accelerator.rst\\ndeleted file mode 100644\\nindex a09e9c623..000000000\\n--- a/docs/source/accelerator.rst\\n+++ /dev/null\\n@@ -1,43 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-Accelerator\\n-=======================================================================================================================\\n-\\n-The :class:`~accelerate.Accelerator` is the main class provided by π€ Accelerate. It serves at the main entrypoint for\\n-the API. To quickly adapt your script to work on any kind of setup with π€ Accelerate juste:\\n-\\n-1. Initialize an :class:`~accelerate.Accelerator` object (that we will call :obj:`accelerator` in the rest of this\\n- page) as early as possible in your script.\\n-2. Pass along your model(s), optimizer(s), dataloader(s) to the :meth:`~accelerate.Accelerator.prepare` method.\\n-3. (Optional but best practice) Remove all the :obj:`.cuda()` or :obj:`.to(device)` in your code and let the\\n- :obj:`accelerator` handle device placement for you.\\n-4. Replace the :obj:`loss.backward()` in your code by :obj:`accelerator.backward(loss)`.\\n-5. (Optional, when using distributed evaluation) Gather your predictions and labelsbefore storing them or using them\\n- for metric computation using :meth:`~accelerate.Accelerator.gather`.\\n-\\n-This is all what is needed in most cases. For more advanced case or a nicer experience here are the functions you\\n-should search for and replace by the corresponding methods of your :obj:`accelerator`:\\n-\\n-- :obj:`print` statements should be replaced by :meth:`~accelerate.Accelerator.print` to be only printed once per\\n- process.\\n-- Use :meth:`~accelerate.Accelerator.is_local_main_process` for statements that should be executed once per server.\\n-- Use :meth:`~accelerate.Accelerator.is_main_process` for statements that should be executed once only.\\n-- Use :meth:`~accelerate.Accelerator.wait_for_everyone` to make sure all processes join that point before continuing\\n- (useful before a model save for instance).\\n-- Use :meth:`~accelerate.Accelerator.unwrap_model` to unwrap your model before saving it.\\n-- Use :meth:`~accelerate.Accelerator.save` instead of :obj:`torch.save`.\\n-- Use :meth:`~accelerate.Accelerator.clip_grad_norm_` instead of :obj:`torch.nn.utils.clip_grad_norm_` and\\n- :meth:`~accelerate.Accelerator.clip_grad_value_` instead of :obj:`torch.nn.utils.clip_grad_value_`.\\n-\\n-.. autoclass:: accelerate.Accelerator\\n- :members:\\ndiff --git a/docs/source/conf.py b/docs/source/conf.py\\ndeleted file mode 100644\\nindex e151e55dd..000000000\\n--- a/docs/source/conf.py\\n+++ /dev/null\\n@@ -1,210 +0,0 @@\\n-# -*- coding: utf-8 -*-\\n-#\\n-# Configuration file for the Sphinx documentation builder.\\n-#\\n-# This file does only contain a selection of the most common options. For a\\n-# full list see the documentation:\\n-# http://www.sphinx-doc.org/en/master/config\\n-\\n-# -- Path setup --------------------------------------------------------------\\n-\\n-# If extensions (or modules to document with autodoc) are in another directory,\\n-# add these directories to sys.path here. If the directory is relative to the\\n-# documentation root, use os.path.abspath to make it absolute, like shown here.\\n-#\\n-import os\\n-import sys\\n-\\n-sys.path.insert(0, os.path.abspath(\\\"../../src\\\"))\\n-\\n-\\n-# -- Project information -----------------------------------------------------\\n-\\n-project = \\\"accelerate\\\"\\n-copyright = \\\"2020, The Hugging Face Team, Licenced under the Apache License, Version 2.0\\\"\\n-author = \\\"huggingface\\\"\\n-\\n-# The short X.Y version\\n-version = \\\"0.6.0.dev0\\\"\\n-\\n-# -- General configuration ---------------------------------------------------\\n-\\n-# If your documentation needs a minimal Sphinx version, state it here.\\n-#\\n-# needs_sphinx = '1.0'\\n-\\n-# Add any Sphinx extension module names here, as strings. They can be\\n-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom\\n-# ones.\\n-extensions = [\\n- \\\"sphinx.ext.autodoc\\\",\\n- \\\"sphinx.ext.extlinks\\\",\\n- \\\"sphinx.ext.coverage\\\",\\n- \\\"sphinx.ext.napoleon\\\",\\n- \\\"recommonmark\\\",\\n- \\\"sphinx.ext.viewcode\\\",\\n- \\\"sphinx_markdown_tables\\\",\\n- \\\"sphinx_copybutton\\\",\\n- \\\"sphinxext.opengraph\\\",\\n-]\\n-\\n-# Add any paths that contain templates here, relative to this directory.\\n-templates_path = [\\\"_templates\\\"]\\n-\\n-# The suffix(es) of source filenames.\\n-# You can specify multiple suffix as a list of string:\\n-#\\n-source_suffix = [\\\".rst\\\", \\\".md\\\"]\\n-# source_suffix = '.rst'\\n-\\n-# The master toctree document.\\n-master_doc = \\\"index\\\"\\n-\\n-# The language for content autogenerated by Sphinx. Refer to documentation\\n-# for a list of supported languages.\\n-#\\n-# This is also used if you do content translation via gettext catalogs.\\n-# Usually you set \\\"language\\\" from the command line for these cases.\\n-language = None\\n-\\n-# List of patterns, relative to source directory, that match files and\\n-# directories to ignore when looking for source files.\\n-# This pattern also affects html_static_path and html_extra_path.\\n-exclude_patterns = [\\\"_build\\\", \\\"Thumbs.db\\\", \\\".DS_Store\\\"]\\n-\\n-# The name of the Pygments (syntax highlighting) style to use.\\n-pygments_style = None\\n-\\n-# Remove the prompt when copying examples\\n-copybutton_prompt_text = r\\\">>> |\\\\.\\\\.\\\\. \\\"\\n-copybutton_prompt_is_regexp = True\\n-\\n-# -- Options for HTML output -------------------------------------------------\\n-\\n-# The theme to use for HTML and HTML Help pages. See the documentation for\\n-# a list of builtin themes.\\n-#\\n-html_theme = \\\"sphinx_rtd_theme\\\"\\n-\\n-# Theme options are theme-specific and customize the look and feel of a theme\\n-# further. For a list of options available for each theme, see the\\n-# documentation.\\n-#\\n-html_theme_options = {\\\"analytics_id\\\": \\\"UA-83738774-2\\\"}\\n-\\n-# Configuration for OpenGraph and Twitter Card Tags.\\n-# These are responsible for creating nice shareable social images https://ahrefs.com/blog/open-graph-meta-tags/\\n-# https://ogp.me/#type_website\\n-ogp_image = \\\"https://huggingface.co/front/thumbnails/docs/accelerate.png\\\"\\n-ogp_description = \\\"Run your raw PyTorch training script on any kind of device. π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed setting (multi-GPUs, TPUs etc.)\\\"\\n-ogp_description_length = 160\\n-\\n-ogp_custom_meta_tags = [\\n- f'<meta name=\\\"twitter:image\\\" content=\\\"{ogp_image}\\\">',\\n- f'<meta name=\\\"twitter:description\\\" content=\\\"{ogp_description}\\\">',\\n-]\\n-\\n-\\n-# Add any paths that contain custom static files (such as style sheets) here,\\n-# relative to this directory. They are copied after the builtin static files,\\n-# so a file named \\\"default.css\\\" will overwrite the builtin \\\"default.css\\\".\\n-html_static_path = [\\\"_static\\\"]\\n-\\n-# Custom sidebar templates, must be a dictionary that maps document names\\n-# to template names.\\n-#\\n-# The default sidebars (for documents that don't match any pattern) are\\n-# defined by theme itself. Builtin themes are using these templates by\\n-# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',\\n-# 'searchbox.html']``.\\n-#\\n-# html_sidebars = {}\\n-\\n-# This must be the name of an image file (path relative to the configuration\\n-# directory) that is the favicon of the docs. Modern browsers use this as\\n-# the icon for tabs, windows and bookmarks. It should be a Windows-style\\n-# icon file (.ico).\\n-html_favicon = \\\"favicon.ico\\\"\\n-\\n-\\n-# -- Options for HTMLHelp output ---------------------------------------------\\n-\\n-# Output file base name for HTML help builder.\\n-htmlhelp_basename = \\\"acceleratedoc\\\"\\n-\\n-\\n-# -- Options for LaTeX output ------------------------------------------------\\n-\\n-latex_elements = {\\n- # The paper size ('letterpaper' or 'a4paper').\\n- #\\n- # 'papersize': 'letterpaper',\\n- # The font size ('10pt', '11pt' or '12pt').\\n- #\\n- # 'pointsize': '10pt',\\n- # Additional stuff for the LaTeX preamble.\\n- #\\n- # 'preamble': '',\\n- # Latex figure (float) alignment\\n- #\\n- # 'figure_align': 'htbp',\\n-}\\n-\\n-# Grouping the document tree into LaTeX files. List of tuples\\n-# (source start file, target name, title,\\n-# author, documentclass [howto, manual, or own class]).\\n-latex_documents = [\\n- (master_doc, \\\"accelerate.tex\\\", \\\"accelerate Documentation\\\", \\\"huggingface\\\", \\\"manual\\\"),\\n-]\\n-\\n-\\n-# -- Options for manual page output ------------------------------------------\\n-\\n-# One entry per manual page. List of tuples\\n-# (source start file, name, description, authors, manual section).\\n-man_pages = [(master_doc, \\\"accelerate\\\", \\\"accelerate Documentation\\\", [author], 1)]\\n-\\n-\\n-# -- Options for Texinfo output ----------------------------------------------\\n-\\n-# Grouping the document tree into Texinfo files. List of tuples\\n-# (source start file, target name, title, author,\\n-# dir menu entry, description, category)\\n-texinfo_documents = [\\n- (\\n- master_doc,\\n- \\\"accelerate\\\",\\n- \\\"accelerate Documentation\\\",\\n- author,\\n- \\\"accelerate\\\",\\n- \\\"One line description of project.\\\",\\n- \\\"Miscellaneous\\\",\\n- ),\\n-]\\n-\\n-\\n-# -- Options for Epub output -------------------------------------------------\\n-\\n-# Bibliographic Dublin Core info.\\n-epub_title = project\\n-\\n-# The unique identifier of the text. This can be a ISBN number\\n-# or the project homepage.\\n-#\\n-# epub_identifier = ''\\n-\\n-# A unique identification for the text.\\n-#\\n-# epub_uid = ''\\n-\\n-# A list of files that should not be packed into the epub file.\\n-epub_exclude_files = [\\\"search.html\\\"]\\n-\\n-\\n-def setup(app):\\n- app.add_css_file(\\\"css/huggingface.css\\\")\\n- app.add_css_file(\\\"css/code-snippets.css\\\")\\n- app.add_js_file(\\\"js/custom.js\\\")\\n-\\n-\\n-# -- Extension configuration -------------------------------------------------\\ndiff --git a/docs/source/favicon.ico b/docs/source/favicon.ico\\ndeleted file mode 100644\\nindex 424101de7..000000000\\nBinary files a/docs/source/favicon.ico and /dev/null differ\\ndiff --git a/docs/source/index.mdx b/docs/source/index.mdx\\nnew file mode 100644\\nindex 000000000..c41ae4a0e\\n--- /dev/null\\n+++ b/docs/source/index.mdx\\n@@ -0,0 +1,132 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Accelerate\\n+\\n+Run your *raw* PyTorch training script on any kind of device\\n+\\n+## Features\\n+\\n+- π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed\\n+ setting (multi-GPUs, TPUs etc.) while still letting you write your own training loop. The same code can then runs\\n+ seamlessly on your local machine for debugging or your training environment.\\n+\\n+- π€ Accelerate also provides a CLI tool that allows you to quickly configure and test your training environment then\\n+ launch the scripts.\\n+\\n+\\n+## Easy to integrate\\n+\\n+A traditional training loop in PyTorch looks like this:\\n+\\n+```python\\n+my_model.to(device)\\n+\\n+for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ loss.backward()\\n+ my_optimizer.step()\\n+```\\n+\\n+Changing it to work with accelerate is really easy and only adds a few lines of code:\\n+\\n+```diff\\n++ from accelerate import Accelerator\\n+\\n++ accelerator = Accelerator()\\n+ # Use the device given by the *accelerator* object.\\n++ device = accelerator.device\\n+ my_model.to(device)\\n+ # Pass every important object (model, optimizer, dataloader) to *accelerator.prepare*\\n++ my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n++ my_model, my_optimizer, my_training_dataloader\\n++ )\\n+\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ # Just a small change for the backward instruction\\n+- loss.backward()\\n++ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+```\\n+\\n+and with this, your script can now run in a distributed environment (multi-GPU, TPU).\\n+\\n+You can even simplify your script a bit by letting π€ Accelerate handle the device placement for you (which is safer,\\n+especially for TPU training):\\n+\\n+```diff\\n++ from accelerate import Accelerator\\n+\\n++ accelerator = Accelerator()\\n+- my_model.to(device)\\n+ # Pass every important object (model, optimizer, dataloader) to *accelerator.prepare*\\n++ my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n++ my_model, my_optimizer, my_training_dataloader\\n++ )\\n+\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+- inputs = inputs.to(device)\\n+- targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ # Just a small change for the backward instruction\\n+- loss.backward()\\n++ accelerator.backward(loss)\\n+ my_optimizer.step()\\n+```\\n+\\n+## Script launcher\\n+\\n+No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training! π€\\n+Accelerate comes with a CLI tool that will make your life easier when launching distributed scripts.\\n+\\n+On your machine(s) just run:\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n+default options when doing\\n+\\n+```bash\\n+accelerate launch my_script.py --args_to_my_script\\n+```\\n+\\n+For instance, here is how you would run the NLP example (from the root of the repo):\\n+\\n+```bash\\n+accelerate launch examples/nlp_example.py\\n+```\\n+\\n+## Supported integrations\\n+\\n+- CPU only\\n+- single GPU\\n+- multi-GPU on one node (machine)\\n+- multi-GPU on several nodes (machines)\\n+- TPU\\n+- FP16 with native AMP (apex on the roadmap)\\n+- DeepSpeed (experimental support)\\ndiff --git a/docs/source/index.rst b/docs/source/index.rst\\ndeleted file mode 100644\\nindex 384db658a..000000000\\n--- a/docs/source/index.rst\\n+++ /dev/null\\n@@ -1,161 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-Accelerate\\n-=======================================================================================================================\\n-\\n-Run your *raw* PyTorch training script on any kind of device\\n-\\n-Features\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-- π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed\\n- setting (multi-GPUs, TPUs etc.) while still letting you write your own training loop. The same code can then runs\\n- seamlessly on your local machine for debugging or your training environment.\\n-\\n-- π€ Accelerate also provides a CLI tool that allows you to quickly configure and test your training environment then\\n- launch the scripts.\\n-\\n-\\n-Easy to integrate\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-A traditional training loop in PyTorch looks like this:\\n-\\n-.. code-block:: python\\n-\\n- my_model.to(device)\\n-\\n- for batch in my_training_dataloader:\\n- my_optimizer.zero_grad()\\n- inputs, targets = batch\\n- inputs = inputs.to(device)\\n- targets = targets.to(device)\\n- outputs = my_model(inputs)\\n- loss = my_loss_function(outputs, targets)\\n- loss.backward()\\n- my_optimizer.step()\\n-\\n-Changing it to work with accelerate is really easy and only adds a few lines of code:\\n-\\n-.. code-block:: diff\\n-\\n- + from accelerate import Accelerator\\n-\\n- + accelerator = Accelerator()\\n- # Use the device given by the `accelerator` object.\\n- + device = accelerator.device\\n- my_model.to(device)\\n- # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n- + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n- + my_model, my_optimizer, my_training_dataloader\\n- + )\\n-\\n- for batch in my_training_dataloader:\\n- my_optimizer.zero_grad()\\n- inputs, targets = batch\\n- inputs = inputs.to(device)\\n- targets = targets.to(device)\\n- outputs = my_model(inputs)\\n- loss = my_loss_function(outputs, targets)\\n- # Just a small change for the backward instruction\\n- - loss.backward()\\n- + accelerator.backward(loss)\\n- my_optimizer.step()\\n-\\n-and with this, your script can now run in a distributed environment (multi-GPU, TPU).\\n-\\n-You can even simplify your script a bit by letting π€ Accelerate handle the device placement for you (which is safer,\\n-especially for TPU training):\\n-\\n-.. code-block:: diff\\n-\\n- + from accelerate import Accelerator\\n-\\n- + accelerator = Accelerator()\\n- - my_model.to(device)\\n- # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n- + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n- + my_model, my_optimizer, my_training_dataloader\\n- + )\\n-\\n- for batch in my_training_dataloader:\\n- my_optimizer.zero_grad()\\n- inputs, targets = batch\\n- - inputs = inputs.to(device)\\n- - targets = targets.to(device)\\n- outputs = my_model(inputs)\\n- loss = my_loss_function(outputs, targets)\\n- # Just a small change for the backward instruction\\n- - loss.backward()\\n- + accelerator.backward(loss)\\n- my_optimizer.step()\\n-\\n-\\n-Script launcher\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-No need to remember how to use ``torch.distributed.launch`` or to write a specific launcher for TPU training! π€\\n-Accelerate comes with a CLI tool that will make your life easier when launching distributed scripts.\\n-\\n-On your machine(s) just run:\\n-\\n-.. code-block:: bash\\n-\\n- accelerate config\\n-\\n-and answer the questions asked. This will generate a config file that will be used automatically to properly set the\\n-default options when doing\\n-\\n-.. code-block:: bash\\n-\\n- accelerate launch my_script.py --args_to_my_script\\n-\\n-For instance, here is how you would run the NLP example (from the root of the repo):\\n-\\n-.. code-block:: bash\\n-\\n- accelerate launch examples/nlp_example.py\\n-\\n-\\n-Supported integrations\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-- CPU only\\n-- single GPU\\n-- multi-GPU on one node (machine)\\n-- multi-GPU on several nodes (machines)\\n-- TPU\\n-- FP16 with native AMP (apex on the roadmap)\\n-- DeepSpeed (experimental support)\\n-\\n-.. toctree::\\n- :maxdepth: 2\\n- :caption: Get started\\n-\\n- quicktour\\n- installation\\n-\\n-.. toctree::\\n- :maxdepth: 2\\n- :caption: Guides\\n-\\n- sagemaker\\n-\\n-.. toctree::\\n- :maxdepth: 2\\n- :caption: API reference\\n-\\n- accelerator\\n- launcher\\n- kwargs\\n- internal\\ndiff --git a/docs/source/installation.md b/docs/source/installation.mdx\\nsimilarity index 99%\\nrename from docs/source/installation.md\\nrename to docs/source/installation.mdx\\nindex ca2f88286..4564ba00c 100644\\n--- a/docs/source/installation.md\\n+++ b/docs/source/installation.mdx\\n@@ -87,7 +87,7 @@ Do note that you have to keep that `accelerate` folder around and not delete it\\n \\n Now, let's get to the real benefit of this installation approach. Say, you saw some new feature has been just committed into `master`. If you have already performed all the steps above, to update your accelerate repo to include all the latest commits, all you need to do is to `cd` into that cloned repository folder and update the clone to the latest version:\\n \\n-```\\n+```bash\\n cd ~/accelerate/\\n git pull\\n ```\\ndiff --git a/docs/source/internal.mdx b/docs/source/internal.mdx\\nnew file mode 100644\\nindex 000000000..3acaaad87\\n--- /dev/null\\n+++ b/docs/source/internal.mdx\\n@@ -0,0 +1,61 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Internals\\n+\\n+## Optimizer\\n+\\n+[[autodoc]] optimizer.AcceleratedOptimizer\\n+\\n+## DataLoader\\n+\\n+The main work on your PyTorch `DataLoader` is done by the following function:\\n+\\n+[[autodoc]] data_loader.prepare_data_loader\\n+\\n+### BatchSamplerShard\\n+\\n+[[autodoc]] data_loader.DataLoaderShard\\n+\\n+### BatchSamplerShard\\n+\\n+[[autodoc]] data_loader.BatchSamplerShard\\n+\\n+### IterableDatasetShard\\n+\\n+[[autodoc]] data_loader.IterableDatasetShard\\n+\\n+## Distributed Config\\n+\\n+### AcceleratorState\\n+\\n+[[autodoc]] state.AcceleratorState\\n+\\n+### DistributedType\\n+\\n+[[autodoc]] state.DistributedType\\n+\\n+## Utilities\\n+\\n+[[autodoc]] utils.extract_model_from_parallel\\n+\\n+[[autodoc]] utils.gather\\n+\\n+[[autodoc]] utils.send_to_device\\n+\\n+[[autodoc]] utils.set_seed\\n+\\n+[[autodoc]] utils.synchronize_rng_state\\n+\\n+[[autodoc]] utils.synchronize_rng_states\\n+\\n+[[autodoc]] utils.wait_for_everyone\\ndiff --git a/docs/source/internal.rst b/docs/source/internal.rst\\ndeleted file mode 100644\\nindex 2d8f0f453..000000000\\n--- a/docs/source/internal.rst\\n+++ /dev/null\\n@@ -1,85 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-Internals\\n-=======================================================================================================================\\n-\\n-\\n-Optimizer\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-.. autoclass:: accelerate.optimizer.AcceleratedOptimizer\\n-\\n-\\n-DataLoader\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-The main work on your PyTorch :obj:`DataLoader` is done by the following function:\\n-\\n-.. autofunction:: accelerate.data_loader.prepare_data_loader\\n-\\n-\\n-BatchSamplerShard\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-.. autoclass:: accelerate.data_loader.DataLoaderShard\\n- :members:\\n-\\n-\\n-BatchSamplerShard\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-.. autoclass:: accelerate.data_loader.BatchSamplerShard\\n- :members:\\n-\\n-\\n-IterableDatasetShard\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-.. autoclass:: accelerate.data_loader.IterableDatasetShard\\n- :members:\\n-\\n-\\n-Distributed Config\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-\\n-AcceleratorState\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-.. autoclass:: accelerate.state.AcceleratorState\\n- :members:\\n-\\n-\\n-DistributedType\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-.. autoclass:: accelerate.state.DistributedType\\n- :members:\\n-\\n-\\n-Utilities\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-.. autofunction:: accelerate.utils.extract_model_from_parallel\\n-\\n-.. autofunction:: accelerate.utils.gather\\n-\\n-.. autofunction:: accelerate.utils.send_to_device\\n-\\n-.. autofunction:: accelerate.utils.set_seed\\n-\\n-.. autofunction:: accelerate.utils.synchronize_rng_state\\n-\\n-.. autofunction:: accelerate.utils.synchronize_rng_states\\n-\\n-.. autofunction:: accelerate.utils.wait_for_everyone\\ndiff --git a/docs/source/kwargs.mdx b/docs/source/kwargs.mdx\\nnew file mode 100644\\nindex 000000000..04f58af37\\n--- /dev/null\\n+++ b/docs/source/kwargs.mdx\\n@@ -0,0 +1,29 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Kwargs Handlers\\n+\\n+The following objects can be passed to the main [`Accelerator`] to customize how some PyTorch objects\\n+related to distributed training or mixed precision are created.\\n+\\n+\\n+## DistributedDataParallelKwargs\\n+\\n+[[autodoc]] DistributedDataParallelKwargs\\n+\\n+## GradScalerKwargs\\n+\\n+[[autodoc]] GradScalerKwargs\\n+\\n+## InitProcessGroupKwargs\\n+\\n+[[autodoc]] InitProcessGroupKwargs\\ndiff --git a/docs/source/kwargs.rst b/docs/source/kwargs.rst\\ndeleted file mode 100644\\nindex 61f42cd11..000000000\\n--- a/docs/source/kwargs.rst\\n+++ /dev/null\\n@@ -1,30 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-\\n-Kwargs Handlers\\n-=======================================================================================================================\\n-\\n-The following objects can be passed to the main :class:`~accelerate.Accelerator` to customize how some PyTorch objects\\n-related to distributed training or mixed precision are created.\\n-\\n-\\n-DistributedDataParallelKwargs\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-.. autoclass:: accelerate.DistributedDataParallelKwargs\\n-\\n-\\n-GradScalerKwargs\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-.. autoclass:: accelerate.GradScalerKwargs\\ndiff --git a/docs/source/launcher.mdx b/docs/source/launcher.mdx\\nnew file mode 100644\\nindex 000000000..fb672d5ad\\n--- /dev/null\\n+++ b/docs/source/launcher.mdx\\n@@ -0,0 +1,28 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Notebook Launcher\\n+\\n+Launch your training function inside a notebook. Currently supports launching a training with TPUs on [Google\\n+Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kaggle.com/code), as well as training on\\n+several GPUs (if the machine on which you are running your notebook has them).\\n+\\n+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb).\\n+\\n+<Tip warning={true}>\\n+\\n+Your `Accelerator` object should only be defined inside the training function. This is because the\\n+initialization should be done inside the launcher only.\\n+\\n+</Tip>\\n+\\n+[[autodoc]] notebook_launcher\\ndiff --git a/docs/source/launcher.rst b/docs/source/launcher.rst\\ndeleted file mode 100644\\nindex 1c2279946..000000000\\n--- a/docs/source/launcher.rst\\n+++ /dev/null\\n@@ -1,29 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-\\n-Notebook Launcher\\n-=======================================================================================================================\\n-\\n-Launch your training function inside a notebook. Currently supports launching a training with TPUs on [Google\\n-Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kaggle.com/code), as well as training on\\n-several GPUs (if the machine on which you are running your notebook has them).\\n-\\n-An example can be found in `this notebook\\n-<https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb>`__.\\n-\\n-.. warning::\\n-\\n- Your :obj:`Accelerator` object should only be defined inside the training function. This is because the\\n- initialization should be done inside the launcher only.\\n-\\n-.. autofunction:: accelerate.notebook_launcher\\ndiff --git a/docs/source/quicktour.mdx b/docs/source/quicktour.mdx\\nnew file mode 100644\\nindex 000000000..f16047925\\n--- /dev/null\\n+++ b/docs/source/quicktour.mdx\\n@@ -0,0 +1,445 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Quick tour\\n+\\n+Let's have a look at a look at π€ Accelerate main features and traps to avoid.\\n+\\n+## Main use\\n+\\n+To use π€ Accelerate in your own script, you have to change four things:\\n+\\n+1. Import the [`Accelerator`] main class instantiate one in an `accelerator` object:\\n+\\n+```python\\n+from accelerate import Accelerator\\n+\\n+accelerator = Accelerator()\\n+```\\n+\\n+This should happen as early as possible in your training script as it will initialize everything necessary for\\n+distributed training. You don't need to indicate the kind of environment you are in (just one machine with a GPU, one\\n+match with several GPUs, several machines with multiple GPUs or a TPU), the library will detect this automatically.\\n+\\n+2. Remove the call `.to(device)` or `.cuda()` for your model and input data. The `accelerator` object\\n+will handle this for you and place all those objects on the right device for you. If you know what you're doing, you\\n+can leave those `.to(device)` calls but you should use the device provided by the `accelerator` object:\\n+`accelerator.device`.\\n+\\n+To fully deactivate the automatic device placement, pass along `device_placement=False` when initializing your\\n+[`Accelerator`].\\n+\\n+<Tip warning={true}>\\n+\\n+If you place your objects manually on the proper device, be careful to create your optimizer after putting your\\n+model on `accelerator.device` or your training will fail on TPU.\\n+\\n+</Tip>\\n+\\n+3. Pass all objects relevant to training (optimizer, model, training dataloader) to the\\n+[`~Accelerator.prepare`] method. This will make sure everything is ready for training.\\n+\\n+```python\\n+model, optimizer, train_dataloader = accelerator.prepare(model, optimizer, train_dataloader)\\n+```\\n+\\n+In particular, your training dataloader will be sharded accross all GPUs/TPU cores available so that each one sees a\\n+different portion of the training dataset. Also, the random states of all processes will be synchronized at the\\n+beginning of each iteration through your dataloader, to make sure the data is shuffled the same way (if you decided to\\n+use `shuffle=True` or any kind of random sampler).\\n+\\n+<Tip>\\n+\\n+The actual batch size for your training will be the number of devices used multiplied by the batch size you set in\\n+your script: for instance training on 4 GPUs with a batch size of 16 set when creating the training dataloader will\\n+train at an actual batch size of 64.\\n+\\n+</Tip>\\n+\\n+Alternatively, you can use the option `split_batches=True` when creating initializing your\\n+[`Accelerator`], in which case the batch size will always stay the same, whether your run your\\n+script on 1, 2, 4 or 64 GPUs.\\n+\\n+You should execute this instruction as soon as all objects for training are created, before starting your actual\\n+training loop.\\n+\\n+<Tip warning={true}>\\n+\\n+Your training dataloader may change length when going through this method: if you run on X GPUs, it will have its\\n+length divided by X (since your actual batch size will be multiplied by X), unless you set\\n+`split_batches=True`.\\n+\\n+</Tip>\\n+\\n+Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n+to create a learning rate scheduler) should go after the call to [`~Accelerator.prepare`].\\n+\\n+You can perfectly send your dataloader to [`~Accelerator.prepare`] on its own, but it's best to send the\\n+model and optimizer to [`~Accelerator.prepare`] together.\\n+\\n+You may or may not want to send your validation dataloader to [`~Accelerator.prepare`], depending on\\n+whether you want to run distributed evaluation or not (see below).\\n+\\n+4. Replace the line `loss.backward()` by `accelerator.backward(loss)`.\\n+\\n+And you're all set! With all these changes, your script will run on your local machine as well as on multiple GPUs or a\\n+TPU! You can either use your favorite tool to launch the distributed training, or you can use the π€ Accelerate\\n+launcher.\\n+\\n+\\n+## Distributed evaluation\\n+\\n+You can perform regular evaluation in your training script, if you leave your validation dataloader out of the\\n+[`~Accelerator.prepare`] method. In this case, you will need to put the input data on the\\n+`accelerator.device` manually.\\n+\\n+To perform distributed evaluation, send along your validation dataloader to the [`~Accelerator.prepare`]\\n+method:\\n+\\n+```python\\n+validation_dataloader = accelerator.prepare(validation_dataloader)\\n+```\\n+\\n+Like for your training dataloader, it will mean that (should you run your script on multiple devices) each device will\\n+only see part of the evaluation data. This means you will need to group your predictions together. This is very easy to\\n+do with the [`~Accelerator.gather`] method.\\n+\\n+```python\\n+for inputs, targets in validation_dataloader:\\n+ predictions = model(inputs)\\n+ # Gather all predictions and targets\\n+ all_predictions = accelerator.gather(predictions)\\n+ all_targets = accelerator.gather(targets)\\n+ # Example of use with a *Datasets.Metric*\\n+ metric.add_batch(all_predictions, all_targets)\\n+```\\n+\\n+<Tip warning={true}>\\n+\\n+Like for the training dataloader, passing your validation dataloader through\\n+[`~Accelerator.prepare`] may change its: if you run on X GPUs, it will have its length divided by X\\n+(since your actual batch size will be multiplied by X), unless you set `split_batches=True`.\\n+\\n+Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n+to create a learning rate scheduler) should go after the call to [`~Accelerator.prepare`].\\n+\\n+</Tip>\\n+\\n+<Tip warning={true}>\\n+\\n+The [`~Accelerator.gather`] method requires the tensors to be all the same size on each process. If\\n+you have tensors of different sizes on each process (for instance when dynamically padding to the maximum length in\\n+a batch), you should use the [`~Accelerator.pad_across_processes`] method to pad you tensor to the\\n+biggest size across processes.\\n+\\n+</Tip>\\n+\\n+## Launching your distributed script\\n+\\n+You can use the regular commands to launch your distributed training (like `torch.distributed.launch` for\\n+PyTorch), they are fully compatible with π€ Accelerate. The only caveat here is that π€ Accelerate uses the environment\\n+to determine all useful information, so `torch.distributed.launch` should be used with the flag `--use_env`.\\n+\\n+π€ Accelerate also provides a CLI tool that unifies all launcher, so you only have to remember one command. To use it,\\n+just run\\n+\\n+```bash\\n+accelerate config\\n+```\\n+\\n+on your machine and reply to the questions asked. This will save a *default_config.yaml* file in your cache folder for\\n+π€ Accelerate. That cache folder is (with decreasing order of priority):\\n+\\n+- The content of your environment variable `HF_HOME` suffixed with *accelerate*.\\n+- If it does not exist, the content of your environment variable `XDG_CACHE_HOME` suffixed with\\n+ *huggingface/accelerate*.\\n+- If this does not exist either, the folder *~/.cache/huggingface/accelerate*\\n+\\n+You can also specify with the flag `--config_file` the location of the file you want to save.\\n+\\n+Once this is done, you can test everything is going well on your setup by running\\n+\\n+```bash\\n+accelerate test\\n+```\\n+\\n+This will launch a short script that will test the distributed environment. If it runs fine, you are ready for the next\\n+step!\\n+\\n+Note that if you specified a location for the config file in the previous step, you need to pass it here as well:\\n+\\n+```bash\\n+accelerate test --config_file path_to_config.yaml\\n+```\\n+\\n+Now that this is done, you can run your script with the following command:\\n+\\n+```bash\\n+accelerate launch path_to_script.py --args_for_the_script\\n+```\\n+\\n+If you stored the config file in a non-default location, you can indicate it to the launcher like his:\\n+\\n+```bash\\n+accelerate launch --config_file path_to_config.yaml path_to_script.py --args_for_the_script\\n+```\\n+\\n+You can also override any of the arguments determined by your config file, see TODO: insert ref here.\\n+\\n+\\n+## Launching training from a notebook\\n+\\n+In Accelerate 0.3.0, a new [`notebook_launcher`] has been introduced to help you launch your training\\n+function from a notebook. This launcher supports launching a training with TPUs on Colab or Kaggle, as well as training\\n+on several GPUs (if the machine on which you are running your notebook has them).\\n+\\n+Just define a function responsible for your whole training and/or evaluation in a cell of the notebook, then execute a\\n+cell with the following code:\\n+\\n+```python\\n+from accelerate import notebook_launcher\\n+\\n+notebook_launcher(training_function)\\n+```\\n+\\n+<Tip warning={true}>\\n+\\n+Your `Accelerator` object should only be defined inside the training function. This is because the\\n+initialization should be done inside the launcher only.\\n+\\n+</Tip>\\n+\\n+## Training on TPU\\n+\\n+If you want to launch your script on TPUs, there are a few caveats you should be aware of. Behind the scenes, the TPUs\\n+will create a graph of all the operations happening in your training step (forward pass, backward pass and optimizer\\n+step). This is why your first step of training will always be very long as building and compiling this graph for\\n+optimizations takes some time.\\n+\\n+The good news is that this compilation will be cached so the second step and all the following will be much faster. The\\n+bas news is that it only applies if all of your steps do exactly the same operations, which implies:\\n+\\n+- having all tensors of the same length in all your lengths\\n+- having static code (i.e., not a for loop of length that could change from step to step)\\n+\\n+Having any of the things above change between two steps will trigger a new compilation which will, once again, take a\\n+lot of time. In practice, that means you must take special care to have all your tensors in your inputs of the same\\n+shape (so no dynamic padding for instance if you are in an NLP problem) and should not use layer with for loops that\\n+have different lengths depending on the inputs (such as an LSTM) or the training will be excruciatingly slow.\\n+\\n+To introduce special behavior in your script for TPUs you can check the `distributed_type` of your\\n+`accelerator`:\\n+\\n+```python docstyle-ignore\\n+from accelerate import DistributedType\\n+\\n+if accelerator.distributed_type == DistributedType.TPU:\\n+ # do something of static shape\\n+else:\\n+ # go crazy and be dynamic\\n+```\\n+\\n+The [NLP example](https://github.com/huggingface/accelerate/blob/main/examples/nlp_example.py) shows an example in\\n+situation with dynamic padding.\\n+\\n+One last thing to pay close attnetion to: if your model has tied weights (such as language models which tie the weights\\n+of the embedding matrix with the weights of the decoder), moving this model to the TPU (either yourself or after you\\n+passed your model to [`~Accelerator.prepare`]) will break the tying. You will need to retie the weights\\n+after. You can find an example of this in the [run_clm_no_trainer](https://github.com/huggingface/transformers/blob/master/examples/pytorch/language-modeling/run_clm.py) script in\\n+the Transformers repository.\\n+\\n+\\n+## Other caveats\\n+\\n+We list here all smaller issues you could have in your script conversion and how to resolve them.\\n+\\n+### Execute a statement only on one processes\\n+\\n+Some of your instructions only need to run for one process on a given server: for instance a data download or a log\\n+statement. To do this, wrap the statement in a test like this:\\n+\\n+```python docstyle-ignore\\n+if accelerator.is_local_main_process:\\n+ # Is executed once per server\\n+```\\n+\\n+Another example is progress bars: to avoid having multiple progress bars in your output, you should only display one on\\n+the local main process:\\n+\\n+```python\\n+from tqdm.auto import tqdm\\n+\\n+progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)\\n+```\\n+\\n+The *local* means per machine: if you are running your training on two servers with several GPUs, the instruction will\\n+be executed once on each of those servers. If you need to execute something only once for all processes (and not per\\n+machine) for instance, uploading the final model to the π€ model hub, wrap it in a test like this:\\n+\\n+```python docstyle-ignore\\n+if accelerator.is_main_process:\\n+ # Is executed once only\\n+```\\n+\\n+For printing statements you only want executed once per machine, you can just replace the `print` function by\\n+`accelerator.print`.\\n+\\n+\\n+### Defer execution\\n+\\n+When you run your usual script, instructions are executed in order. Using π€ Accelerate to deploy your script on several\\n+GPUs at the same time introduces a complication: while each process executes all instructions in order, some may be\\n+faster than others.\\n+\\n+You might need to wait for all processes to have reached a certain point before executing a given instruction. For\\n+instance, you shouldn't save a model before being sure every process is done with training. To do this, just write the\\n+following line in your code:\\n+\\n+```\\n+accelerator.wait_for_everyone()\\n+```\\n+\\n+This instruction will block all the processes that arrive them first until all the other processes have reached that\\n+point (if you run your script on just one GPU or CPU, this wont' do anything).\\n+\\n+\\n+### Saving/loading a model\\n+\\n+Saving the model you trained might need a bit of adjustment: first you should wait for all processes to reach that\\n+point in the script as shown above, and then, you should unwrap your model before saving it. This is because when going\\n+through the [`~Accelerator.prepare`] method, your model may have been placed inside a bigger model,\\n+which deals with the distributed training. This in turn means that saving your model state dictionary without taking\\n+any precaution will take that potential extra layer into account, and you will end up with weights you can't load back\\n+in your base model.\\n+\\n+This is why it's recommended to *unwrap* your model first. Here is an example:\\n+\\n+```\\n+accelerator.wait_for_everyone()\\n+unwrapped_model = accelerator.unwrap_model(model)\\n+accelerator.save(unwrapped_model.state_dict(), filename)\\n+```\\n+\\n+If your script contains a logic to load checkpoint, we also recommend you load your weights in the unwrapped model\\n+(this is only useful if you use the load function after making your model go through\\n+[`~Accelerator.prepare`]). Here is an example:\\n+\\n+```\\n+unwrapped_model = accelerator.unwrap_model(model)\\n+unwrapped_model.load_state_dict(torch.load(filename))\\n+```\\n+\\n+Note that since all the model parameters are references to tensors, this will load your weights inside `model`.\\n+\\n+### Gradient clipping\\n+\\n+If you are using gradient clipping in your script, you should replace the calls to\\n+`torch.nn.utils.clip_grad_norm_` or `torch.nn.utils.clip_grad_value_` with `accelerator.clip_grad_norm_`\\n+and `accelerator.clip_grad_value_` respectively.\\n+\\n+\\n+### Mixed Precision training\\n+\\n+If you are running your training in Mixed Precision with Accelerate, you will get the best result with your loss being\\n+computed inside your model (like in Transformer models for instance). Every computation outside of the model will be\\n+executed in full precision (which is generally what you want for loss computation, expecially if it involves a\\n+softmax). However you might want to put your loss computation inside the *accelerator.autocast* context manager:\\n+\\n+```\\n+with accelerator.autocast():\\n+ loss = complex_loss_function(outputs, target):\\n+```\\n+\\n+Another caveat with Mixed Precision training is that the gradient will skip a few updates at the beginning and\\n+sometimes during training: because of the dynamic loss scaling strategy, there are points during training where the\\n+gradients have overflown, and the loss scaling factor is reduced to avoid this happening again at the next step.\\n+\\n+This means that you may update your learning rate scheduler when there was no update, which is fine in general, but may\\n+have an impact when you have very little training data, or if the first learning rate values of your scheduler are very\\n+important. In this case, you can skip the learning rate scheduler updates when the optimizer step was not done like\\n+this:\\n+\\n+```\\n+if not accelerator.optimizer_step_was_skipped:\\n+ lr_scheduler.step()\\n+```\\n+\\n+### DeepSpeed\\n+\\n+DeepSpeed support is experimental, so the underlying API will evolve in the near future and may have some slight\\n+breaking changes. In particular, π€ Accelerate does not support DeepSpeed config you have written yourself yet, this\\n+will be added in a next version.\\n+\\n+One main caveat for the DeepSpeed integration is that the DeepSpeed launcher always passes a `local_rank` variable to\\n+the training script, so your training script should accept it (whether you launch training with the DeepSpeed launcher\\n+or `accelerate launch`).\\n+\\n+<Tip warning={true}>\\n+\\n+The [`notebook_launcher`] does not support the DeepSpeed integration yet.\\n+\\n+</Tip>\\n+\\n+## Internal mechanism\\n+\\n+Internally, the library works by first analyzing the environment in which the script is launched to determine which\\n+kind of distributed setup is used, how many different processes there are and which one the current script is in. All\\n+that information is stored in the [`~AcceleratorState`].\\n+\\n+This class is initialized the first time you instantiate a [`Accelerator`] as well as performing any\\n+specific initialization your distributed setup needs. Its state is then uniquely shared through all instances of\\n+[`~state.AcceleratorState`].\\n+\\n+Then, when calling [`~Accelerator.prepare`], the library:\\n+\\n+- wraps your model(s) in the container adapted for the distributed setup,\\n+- wraps your optimizer(s) in a [`~optimizer.AcceleratedOptimizer`],\\n+- creates a new version of your dataloader(s) in a [`~data_loader.DataLoaderShard`].\\n+\\n+While the model(s) and optimizer(s) are just put in simple wrappers, the dataloader(s) are re-created. This is mostly\\n+because PyTorch does not let the user change the `batch_sampler` of a dataloader once it's been created and the\\n+library handles the sharding of your data between processes by changing that `batch_sampler` to yield every other\\n+`num_processes` batches.\\n+\\n+The [`~data_loader.DataLoaderShard`] subclasses `DataLoader` to add the following functionality:\\n+\\n+- it synchronizes the appropriate random number generator of all processes at each new iteration, to ensure any\\n+ randomization (like shuffling) is done the exact same way across processes.\\n+- it puts the batches on the proper device before yielding them (unless you have opted out of\\n+ `device_placement=True`).\\n+\\n+The random number generator synchronization will by default synchronize:\\n+\\n+- the `generator` attribute of a given sampler (like the PyTorch `RandomSampler`) for PyTorch >= 1.6\\n+- the main random number generator in PyTorch <=1.5.1\\n+\\n+You can choose which random number generator(s) to synchronize with the `rng_types` argument of the main\\n+[`Accelerator`]. In PyTorch >= 1.6, it is recommended to rely on local `generator` to avoid\\n+setting the same seed in the main random number generator in all processes.\\n+\\n+<Tip warning={true}>\\n+\\n+Synchronization the main torch (or CUDA or XLA) random number generator will affect any other potential random\\n+artifacts you could have in your dataset (like random data augmentation) in the sense all processes will get the\\n+same random numbers from the torch random modules (so will apply the same random data augmentation if it's\\n+controlled by torch).\\n+\\n+</Tip>\\n+\\n+<Tip>\\n+\\n+The randomization part of your custom sampler, batch sampler or iterable dataset should be done using a local\\n+`torch.Generator` object (in PyTorch >= 1.6), see the traditional `RandomSampler`, as an example.\\n+\\n+</Tip>\\n+\\n+See more details about the internal in the [Internals page](internal).\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\ndeleted file mode 100644\\nindex 686d85ce1..000000000\\n--- a/docs/source/quicktour.rst\\n+++ /dev/null\\n@@ -1,450 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-Quick tour\\n-=======================================================================================================================\\n-\\n-Let's have a look at a look at π€ Accelerate main features and traps to avoid.\\n-\\n-Main use\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-To use π€ Accelerate in your own script, you have to change four things:\\n-\\n-1. Import the :class:`~accelerate.Accelerator` main class instantiate one in an :obj:`accelerator` object:\\n-\\n-.. code-block:: python\\n-\\n- from accelerate import Accelerator\\n-\\n- accelerator = Accelerator()\\n-\\n-This should happen as early as possible in your training script as it will initialize everything necessary for\\n-distributed training. You don't need to indicate the kind of environment you are in (just one machine with a GPU, one\\n-match with several GPUs, several machines with multiple GPUs or a TPU), the library will detect this automatically.\\n-\\n-2. Remove the call :obj:`.to(device)` or :obj:`.cuda()` for your model and input data. The :obj:`accelerator` object\\n-will handle this for you and place all those objects on the right device for you. If you know what you're doing, you\\n-can leave those :obj:`.to(device)` calls but you should use the device provided by the :obj:`accelerator` object:\\n-:obj:`accelerator.device`.\\n-\\n-To fully deactivate the automatic device placement, pass along :obj:`device_placement=False` when initializing your\\n-:class:`~accelerate.Accelerator`.\\n-\\n-.. Warning::\\n-\\n- If you place your objects manually on the proper device, be careful to create your optimizer after putting your\\n- model on :obj:`accelerator.device` or your training will fail on TPU.\\n-\\n-3. Pass all objects relevant to training (optimizer, model, training dataloader) to the\\n-:meth:`~accelerate.Accelerator.prepare` method. This will make sure everything is ready for training.\\n-\\n-.. code-block:: python\\n-\\n- model, optimizer, train_dataloader = accelerator.prepare(model, optimizer, train_dataloader)\\n-\\n-In particular, your training dataloader will be sharded accross all GPUs/TPU cores available so that each one sees a\\n-different portion of the training dataset. Also, the random states of all processes will be synchronized at the\\n-beginning of each iteration through your dataloader, to make sure the data is shuffled the same way (if you decided to\\n-use :obj:`shuffle=True` or any kind of random sampler).\\n-\\n-.. Note::\\n-\\n- The actual batch size for your training will be the number of devices used multiplied by the batch size you set in\\n- your script: for instance training on 4 GPUs with a batch size of 16 set when creating the training dataloader will\\n- train at an actual batch size of 64.\\n-\\n- Alternatively, you can use the option :obj:`split_batches=True` when creating initializing your\\n- :class:`~accelerate.Accelerator`, in which case the batch size will always stay the same, whether your run your\\n- script on 1, 2, 4 or 64 GPUs.\\n-\\n-You should execute this instruction as soon as all objects for training are created, before starting your actual\\n-training loop.\\n-\\n-.. Warning::\\n-\\n- Your training dataloader may change length when going through this method: if you run on X GPUs, it will have its\\n- length divided by X (since your actual batch size will be multiplied by X), unless you set\\n- :obj:`split_batches=True`.\\n-\\n- Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n- to create a learning rate scheduler) should go after the call to :meth:`~accelerate.Accelerator.prepare`.\\n-\\n-You can perfectly send your dataloader to :meth:`~accelerate.Accelerator.prepare` on its own, but it's best to send the\\n-model and optimizer to :meth:`~accelerate.Accelerator.prepare` together.\\n-\\n-You may or may not want to send your validation dataloader to :meth:`~accelerate.Accelerator.prepare`, depending on\\n-whether you want to run distributed evaluation or not (see below).\\n-\\n-4. Replace the line :obj:`loss.backward()` by :obj:`accelerator.backward(loss)`.\\n-\\n-And you're all set! With all these changes, your script will run on your local machine as well as on multiple GPUs or a\\n-TPU! You can either use your favorite tool to launch the distributed training, or you can use the π€ Accelerate\\n-launcher.\\n-\\n-\\n-Distributed evaluation\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-You can perform regular evaluation in your training script, if you leave your validation dataloader out of the\\n-:meth:`~accelerate.Accelerator.prepare` method. In this case, you will need to put the input data on the\\n-:obj:`accelerator.device` manually.\\n-\\n-To perform distributed evaluation, send along your validation dataloader to the :meth:`~accelerate.Accelerator.prepare`\\n-method:\\n-\\n-.. code-block:: python\\n-\\n- validation_dataloader = accelerator.prepare(validation_dataloader)\\n-\\n-Like for your training dataloader, it will mean that (should you run your script on multiple devices) each device will\\n-only see part of the evaluation data. This means you will need to group your predictions together. This is very easy to\\n-do with the :meth:`~accelerate.Accelerator.gather` method.\\n-\\n-.. code-block:: python\\n-\\n- for inputs, targets in validation_dataloader:\\n- predictions = model(inputs)\\n- # Gather all predictions and targets\\n- all_predictions = accelerator.gather(predictions)\\n- all_targets = accelerator.gather(targets)\\n- # Example of use with a `Datasets.Metric`\\n- metric.add_batch(all_predictions, all_targets)\\n-\\n-\\n-.. Warning::\\n-\\n- Like for the training dataloader, passing your validation dataloader through\\n- :meth:`~accelerate.Accelerator.prepare` may change its: if you run on X GPUs, it will have its length divided by X\\n- (since your actual batch size will be multiplied by X), unless you set :obj:`split_batches=True`.\\n-\\n- Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n- to create a learning rate scheduler) should go after the call to :meth:`~accelerate.Accelerator.prepare`.\\n-\\n-.. Warning::\\n-\\n- The :meth:`~accelerate.Accelerator.gather` method requires the tensors to be all the same size on each process. If\\n- you have tensors of different sizes on each process (for instance when dynamically padding to the maximum length in\\n- a batch), you should use the :meth:`~accelerate.Accelerator.pad_across_processes` method to pad you tensor to the\\n- biggest size across processes.\\n-\\n-\\n-Launching your distributed script\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-You can use the regular commands to launch your distributed training (like :obj:`torch.distributed.launch` for\\n-PyTorch), they are fully compatible with π€ Accelerate. The only caveat here is that π€ Accelerate uses the environment\\n-to determine all useful information, so :obj:`torch.distributed.launch` should be used with the flag :obj:`--use_env`.\\n-\\n-π€ Accelerate also provides a CLI tool that unifies all launcher, so you only have to remember one command. To use it,\\n-just run\\n-\\n-.. code-block:: bash\\n-\\n- accelerate config\\n-\\n-on your machine and reply to the questions asked. This will save a `default_config.yaml` file in your cache folder for\\n-π€ Accelerate. That cache folder is (with decreasing order of priority):\\n-\\n- - The content of your environment variable ``HF_HOME`` suffixed with `accelerate`.\\n- - If it does not exist, the content of your environment variable ``XDG_CACHE_HOME`` suffixed with\\n- `huggingface/accelerate`.\\n- - If this does not exist either, the folder `~/.cache/huggingface/accelerate`\\n-\\n-You can also specify with the flag :obj:`--config_file` the location of the file you want to save.\\n-\\n-Once this is done, you can test everything is going well on your setup by running\\n-\\n-.. code-block:: bash\\n-\\n- accelerate test\\n-\\n-\\n-This will launch a short script that will test the distributed environment. If it runs fine, you are ready for the next\\n-step!\\n-\\n-Note that if you specified a location for the config file in the previous step, you need to pass it here as well:\\n-\\n-.. code-block:: bash\\n-\\n- accelerate test --config_file path_to_config.yaml\\n-\\n-\\n-Now that this is done, you can run your script with the following command:\\n-\\n-.. code-block:: bash\\n-\\n- accelerate launch path_to_script.py --args_for_the_script\\n-\\n-\\n-If you stored the config file in a non-default location, you can indicate it to the launcher like his:\\n-\\n-.. code-block:: bash\\n-\\n- accelerate launch --config_file path_to_config.yaml path_to_script.py --args_for_the_script\\n-\\n-You can also override any of the arguments determined by your config file, see TODO: insert ref here.\\n-\\n-\\n-Launching training from a notebook\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-In Accelerate 0.3.0, a new :class:`~accelerate.notebook_launcher` has been introduced to help you launch your training\\n-function from a notebook. This launcher supports launching a training with TPUs on Colab or Kaggle, as well as training\\n-on several GPUs (if the machine on which you are running your notebook has them).\\n-\\n-Just define a function responsible for your whole training and/or evaluation in a cell of the notebook, then execute a\\n-cell with the following code:\\n-\\n-.. code-block::\\n-\\n- from accelerate import notebook_launcher\\n-\\n- notebook_launcher(training_function)\\n-\\n-.. warning::\\n-\\n- Your :obj:`Accelerator` object should only be defined inside the training function. This is because the\\n- initialization should be done inside the launcher only.\\n-\\n-\\n-Training on TPU\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-If you want to launch your script on TPUs, there are a few caveats you should be aware of. Behind the scenes, the TPUs\\n-will create a graph of all the operations happening in your training step (forward pass, backward pass and optimizer\\n-step). This is why your first step of training will always be very long as building and compiling this graph for\\n-optimizations takes some time.\\n-\\n-The good news is that this compilation will be cached so the second step and all the following will be much faster. The\\n-bas news is that it only applies if all of your steps do exactly the same operations, which implies:\\n-\\n-- having all tensors of the same length in all your lengths\\n-- having static code (i.e., not a for loop of length that could change from step to step)\\n-\\n-Having any of the things above change between two steps will trigger a new compilation which will, once again, take a\\n-lot of time. In practice, that means you must take special care to have all your tensors in your inputs of the same\\n-shape (so no dynamic padding for instance if you are in an NLP problem) and should not use layer with for loops that\\n-have different lengths depending on the inputs (such as an LSTM) or the training will be excruciatingly slow.\\n-\\n-To introduce special behavior in your script for TPUs you can check the :obj:`distributed_type` of your\\n-:obj:`accelerator`:\\n-\\n-.. code-block:: python\\n-\\n- from accelerate import DistributedType\\n-\\n- if accelerator.distributed_type == DistributedType.TPU:\\n- # do something of static shape\\n- else:\\n- # go crazy and be dynamic\\n-\\n-The `NLP example <https://github.com/huggingface/accelerate/blob/main/examples/nlp_example.py>`__ shows an example in\\n-situation with dynamic padding.\\n-\\n-One last thing to pay close attnetion to: if your model has tied weights (such as language models which tie the weights\\n-of the embedding matrix with the weights of the decoder), moving this model to the TPU (either yourself or after you\\n-passed your model to :meth:`~accelerate.Accelerator.prepare`) will break the tying. You will need to retie the weights\\n-after. You can find an example of this in the `run_clm_no_trainer\\n-<https://github.com/huggingface/transformers/blob/master/examples/pytorch/language-modeling/run_clm.py>`__ script in\\n-the Transformers repository.\\n-\\n-\\n-Other caveats\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-We list here all smaller issues you could have in your script conversion and how to resolve them.\\n-\\n-Execute a statement only on one processes\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-Some of your instructions only need to run for one process on a given server: for instance a data download or a log\\n-statement. To do this, wrap the statement in a test like this:\\n-\\n-.. code-block:: python\\n-\\n- if accelerator.is_local_main_process:\\n- # Is executed once per server\\n-\\n-Another example is progress bars: to avoid having multiple progress bars in your output, you should only display one on\\n-the local main process:\\n-\\n-.. code-block:: python\\n-\\n- from tqdm.auto import tqdm\\n-\\n- progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)\\n-\\n-The `local` means per machine: if you are running your training on two servers with several GPUs, the instruction will\\n-be executed once on each of those servers. If you need to execute something only once for all processes (and not per\\n-machine) for instance, uploading the final model to the π€ model hub, wrap it in a test like this:\\n-\\n-.. code-block:: python\\n-\\n- if accelerator.is_main_process:\\n- # Is executed once only\\n-\\n-For printing statements you only want executed once per machine, you can just replace the :obj:`print` function by\\n-:obj:`accelerator.print`.\\n-\\n-\\n-Defer execution\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-When you run your usual script, instructions are executed in order. Using π€ Accelerate to deploy your script on several\\n-GPUs at the same time introduces a complication: while each process executes all instructions in order, some may be\\n-faster than others.\\n-\\n-You might need to wait for all processes to have reached a certain point before executing a given instruction. For\\n-instance, you shouldn't save a model before being sure every process is done with training. To do this, just write the\\n-following line in your code:\\n-\\n-.. code-block::\\n-\\n- accelerator.wait_for_everyone()\\n-\\n-This instruction will block all the processes that arrive them first until all the other processes have reached that\\n-point (if you run your script on just one GPU or CPU, this wont' do anything).\\n-\\n-\\n-Saving/loading a model\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-Saving the model you trained might need a bit of adjustment: first you should wait for all processes to reach that\\n-point in the script as shown above, and then, you should unwrap your model before saving it. This is because when going\\n-through the :meth:`~accelerate.Accelerator.prepare` method, your model may have been placed inside a bigger model,\\n-which deals with the distributed training. This in turn means that saving your model state dictionary without taking\\n-any precaution will take that potential extra layer into account, and you will end up with weights you can't load back\\n-in your base model.\\n-\\n-This is why it's recommended to `unwrap` your model first. Here is an example:\\n-\\n-.. code-block::\\n-\\n- accelerator.wait_for_everyone()\\n- unwrapped_model = accelerator.unwrap_model(model)\\n- accelerator.save(unwrapped_model.state_dict(), filename)\\n-\\n-If your script contains a logic to load checkpoint, we also recommend you load your weights in the unwrapped model\\n-(this is only useful if you use the load function after making your model go through\\n-:meth:`~accelerate.Accelerator.prepare`). Here is an example:\\n-\\n-.. code-block::\\n-\\n- unwrapped_model = accelerator.unwrap_model(model)\\n- unwrapped_model.load_state_dict(torch.load(filename))\\n-\\n-Note that since all the model parameters are references to tensors, this will load your weights inside :obj:`model`.\\n-\\n-Gradient clipping\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-If you are using gradient clipping in your script, you should replace the calls to\\n-:obj:`torch.nn.utils.clip_grad_norm_` or :obj:`torch.nn.utils.clip_grad_value_` with :obj:`accelerator.clip_grad_norm_`\\n-and :obj:`accelerator.clip_grad_value_` respectively.\\n-\\n-\\n-Mixed Precision training\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-If you are running your training in Mixed Precision with Accelerate, you will get the best result with your loss being\\n-computed inside your model (like in Transformer models for instance). Every computation outside of the model will be\\n-executed in full precision (which is generally what you want for loss computation, expecially if it involves a\\n-softmax). However you might want to put your loss computation inside the `accelerator.autocast` context manager:\\n-\\n-.. code-block::\\n-\\n- with accelerator.autocast():\\n- loss = complex_loss_function(outputs, target):\\n-\\n-Another caveat with Mixed Precision training is that the gradient will skip a few updates at the beginning and\\n-sometimes during training: because of the dynamic loss scaling strategy, there are points during training where the\\n-gradients have overflown, and the loss scaling factor is reduced to avoid this happening again at the next step.\\n-\\n-This means that you may update your learning rate scheduler when there was no update, which is fine in general, but may\\n-have an impact when you have very little training data, or if the first learning rate values of your scheduler are very\\n-important. In this case, you can skip the learning rate scheduler updates when the optimizer step was not done like\\n-this:\\n-\\n-.. code-block::\\n-\\n- if not accelerator.optimizer_step_was_skipped:\\n- lr_scheduler.step()\\n-\\n-\\n-DeepSpeed\\n-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n-\\n-DeepSpeed support is experimental, so the underlying API will evolve in the near future and may have some slight\\n-breaking changes. In particular, π€ Accelerate does not support DeepSpeed config you have written yourself yet, this\\n-will be added in a next version.\\n-\\n-One main caveat for the DeepSpeed integration is that the DeepSpeed launcher always passes a ``local_rank`` variable to\\n-the training script, so your training script should accept it (whether you launch training with the DeepSpeed launcher\\n-or ``accelerate launch``).\\n-\\n-.. Warning::\\n-\\n- The :func:`~accelerate.notebook_launcher` does not support the DeepSpeed integration yet.\\n-\\n-\\n-Internal mechanism\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-Internally, the library works by first analyzing the environment in which the script is launched to determine which\\n-kind of distributed setup is used, how many different processes there are and which one the current script is in. All\\n-that information is stored in the :class:`~accelerate.state.AcceleratorState`.\\n-\\n-This class is initialized the first time you instantiate a :class:`~accelerate.Accelerator` as well as performing any\\n-specific initialization your distributed setup needs. Its state is then uniquely shared through all instances of\\n-:class:`~accelerate.state.AcceleratorState`.\\n-\\n-Then, when calling :meth:`~accelerate.Accelerator.prepare`, the library:\\n-\\n-- wraps your model(s) in the container adapted for the distributed setup,\\n-- wraps your optimizer(s) in a :class:`~accelerate.optimizer.AcceleratedOptimizer`,\\n-- creates a new version of your dataloader(s) in a :class:`~accelerate.data_loader.DataLoaderShard`.\\n-\\n-While the model(s) and optimizer(s) are just put in simple wrappers, the dataloader(s) are re-created. This is mostly\\n-because PyTorch does not let the user change the :obj:`batch_sampler` of a dataloader once it's been created and the\\n-library handles the sharding of your data between processes by changing that :obj:`batch_sampler` to yield every other\\n-:obj:`num_processes` batches.\\n-\\n-The :class:`~accelerate.data_loader.DataLoaderShard` subclasses :obj:`DataLoader` to add the following functionality:\\n-\\n-- it synchronizes the appropriate random number generator of all processes at each new iteration, to ensure any\\n- randomization (like shuffling) is done the exact same way across processes.\\n-- it puts the batches on the proper device before yielding them (unless you have opted out of\\n- :obj:`device_placement=True`).\\n-\\n-The random number generator synchronization will by default synchronize:\\n-\\n-- the :obj:`generator` attribute of a given sampler (like the PyTorch :obj:`RandomSampler`) for PyTorch >= 1.6\\n-- the main random number generator in PyTorch <=1.5.1\\n-\\n-You can choose which random number generator(s) to synchronize with the :obj:`rng_types` argument of the main\\n-:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator` to avoid\\n-setting the same seed in the main random number generator in all processes.\\n-\\n-.. Warning::\\n-\\n- Synchronization the main torch (or CUDA or XLA) random number generator will affect any other potential random\\n- artifacts you could have in your dataset (like random data augmentation) in the sense all processes will get the\\n- same random numbers from the torch random modules (so will apply the same random data augmentation if it's\\n- controlled by torch).\\n-\\n-.. Note::\\n-\\n- The randomization part of your custom sampler, batch sampler or iterable dataset should be done using a local\\n- :obj:`torch.Generator` object (in PyTorch >= 1.6), see the traditional :obj:`RandomSampler`, as an example.\\n-\\n-See more details about the internal in the :doc:`Internals page <internal>`.\\ndiff --git a/docs/source/sagemaker.mdx b/docs/source/sagemaker.mdx\\nnew file mode 100644\\nindex 000000000..d55ccd28b\\n--- /dev/null\\n+++ b/docs/source/sagemaker.mdx\\n@@ -0,0 +1,150 @@\\n+<!--Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+the License. You may obtain a copy of the License at\\n+\\n+http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+specific language governing permissions and limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to\\n+make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+## Getting Started\\n+\\n+### Setup & Installation\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more [here](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html).\\n+\\n+After you have your AWS Account you need to install the `sagemaker` sdk for π€ Accelerate with.\\n+\\n+```bash\\n+pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+```\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. π€\\n+Accelerate is not in the DLC yet (will soon be added!) so to use it within Amazon SageMaker you need to create a\\n+`requirements.txt` in the same directory where your training script is located and add it as dependency.\\n+\\n+```\\n+accelerate\\n+```\\n+\\n+You should also add any other dependencies you have to this `requirements.txt`.\\n+\\n+\\n+### Configure π€ Accelerate\\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n+the π€ Accelerate CLI.\\n+\\n+```bash\\n+accelerate config\\n+# In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+```\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n+\\n+<Tip>\\n+\\n+π€ Accelerate is not saving any of your credentials.\\n+\\n+</Tip>\\n+\\n+### Prepare a π€ Accelerate fine-tuning script\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n+after training you need to specify either `/opt/ml/model` or use `os.environ[\\\"SM_MODEL_DIR\\\"]` as your save\\n+directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+\\n+```diff\\n+- torch.save('/opt/ml/model`)\\n++ accelerator.save('/opt/ml/model')\\n+```\\n+\\n+<Tip warning={true}>\\n+\\n+SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to\\n+specify type as bool in your script and provide an explicit True or False value for this hyperparameter. [[REF]](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script).\\n+\\n+</Tip>\\n+\\n+### Launch Training\\n+\\n+You can launch your training with π€ Accelerate CLI with\\n+\\n+```\\n+accelerate launch path_to_script.py --args_to_the_script\\n+```\\n+\\n+This will launch your training script using your configuration. The only thing you have to do is provide all the\\n+arguments needed by your training script as named arguments.\\n+\\n+**Examples**\\n+\\n+<Tip>\\n+\\n+If you run one of the example scripts, don't forget to add `accelerator.save('/opt/ml/model')` to it.\\n+\\n+</Tip>\\n+\\n+```bash\\n+accelerate launch ./examples/sagemaker_example.py\\n+```\\n+\\n+Outputs:\\n+\\n+```\\n+Configuring Amazon SageMaker environment\\n+Converting Arguments to Hyperparameters\\n+Creating Estimator\\n+2021-04-08 11:56:50 Starting - Starting the training job...\\n+2021-04-08 11:57:13 Starting - Launching requested ML instancesProfilerReport-1617883008: InProgress\\n+.........\\n+2021-04-08 11:58:54 Starting - Preparing the instances for training.........\\n+2021-04-08 12:00:24 Downloading - Downloading input data\\n+2021-04-08 12:00:24 Training - Downloading the training image..................\\n+2021-04-08 12:03:39 Training - Training image download completed. Training in progress..\\n+........\\n+epoch 0: {'accuracy': 0.7598039215686274, 'f1': 0.8178438661710037}\\n+epoch 1: {'accuracy': 0.8357843137254902, 'f1': 0.882249560632689}\\n+epoch 2: {'accuracy': 0.8406862745098039, 'f1': 0.8869565217391304}\\n+........\\n+2021-04-08 12:05:40 Uploading - Uploading generated training model\\n+2021-04-08 12:05:40 Completed - Training job completed\\n+Training seconds: 331\\n+Billable seconds: 331\\n+You can find your model data at: s3://your-bucket/accelerate-sagemaker-1-2021-04-08-11-56-47-108/output/model.tar.gz\\n+```\\n+\\n+## Advanced Features\\n+\\n+### Distributed Training: Data Parallelism\\n+\\n+*currently in development, will be supported soon.*\\n+\\n+### Distributed Training: Model Parallelism\\n+\\n+*currently in development, will be supported soon.*\\n+\\n+### Python packages and dependencies\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. If you\\n+want to use different/other Python packages you can do this by adding them to the `requirements.txt`. These packages\\n+will be installed before your training script is started.\\n+\\n+### Remote scripts: Use scripts located on Github\\n+\\n+*undecided if feature is needed. Contact us if you would like this feature.*\\n+\\n+### Use Spot Instances\\n+\\n+*undecided if feature is needed. Contact us if you would like this feature.*\\ndiff --git a/docs/source/sagemaker.rst b/docs/source/sagemaker.rst\\ndeleted file mode 100644\\nindex b889c99b3..000000000\\n--- a/docs/source/sagemaker.rst\\n+++ /dev/null\\n@@ -1,169 +0,0 @@\\n-.. \\n- Copyright 2021 The HuggingFace Team. All rights reserved.\\n-\\n- Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n- the License. You may obtain a copy of the License at\\n-\\n- http://www.apache.org/licenses/LICENSE-2.0\\n-\\n- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n- an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n- specific language governing permissions and limitations under the License.\\n-\\n-Amazon SageMaker\\n-=======================================================================================================================\\n-\\n-Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n-<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n-make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n-<https://aws.amazon.com/sagemaker/>`_.\\n-\\n-To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n-\\n-\\n-\\n-Getting Started\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-Setup & Installation\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-\\n-Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n-have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\n-\\n-After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n-\\n-.. code-block:: \\n-\\n- pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n-\\n-\\n-π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n-Accelerate is not in the DLC yet (will soon be added!) so to use it within Amazon SageMaker you need to create a\\n-``requirements.txt`` in the same directory where your training script is located and add it as dependency.\\n-\\n-.. code-block:: \\n-\\n- accelerate\\n-\\n-You should also add any other dependencies you have to this ``requirements.txt``.\\n-\\n-\\n-Configure π€ Accelerate\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n-the π€ Accelerate CLI.\\n-\\n-.. code-block:: \\n-\\n- accelerate config\\n- # In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n-\\n-\\n-π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n-\\n-.. note::\\n- π€ Accelerate is not saving any of your credentials.\\n-\\n-\\n-Prepare a π€ Accelerate fine-tuning script\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n-after training you need to specify either ``/opt/ml/model`` or use ``os.environ[\\\"SM_MODEL_DIR\\\"]`` as your save\\n-directory. After training, artifacts in this directory are uploaded to S3.\\n-\\n-\\n-.. code-block:: diff\\n-\\n- - torch.save('/opt/ml/model`)\\n- + accelerator.save('/opt/ml/model')\\n-\\n-\\n-.. warning::\\n- SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to\\n- specify type as bool in your script and provide an explicit True or False value for this hyperparameter. `[REF]\\n- <https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script>`__.\\n-\\n-\\n-Launch Training\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-You can launch your training with π€ Accelerate CLI with\\n-\\n-.. code-block:: \\n-\\n- accelerate launch path_to_script.py --args_to_the_script\\n-\\n-\\n-This will launch your training script using your configuration. The only thing you have to do is provide all the\\n-arguments needed by your training script as named arguments.\\n-\\n-**Examples**\\n-\\n-.. note::\\n- If you run one of the example scripts, don't forget to add ``accelerator.save('/opt/ml/model')`` to it.\\n-\\n-.. code-block:: \\n-\\n- accelerate launch ./examples/sagemaker_example.py \\n-\\n-\\n-Outputs:\\n-\\n-.. code-block:: \\n-\\n- Configuring Amazon SageMaker environment\\n- Converting Arguments to Hyperparameters\\n- Creating Estimator\\n- 2021-04-08 11:56:50 Starting - Starting the training job...\\n- 2021-04-08 11:57:13 Starting - Launching requested ML instancesProfilerReport-1617883008: InProgress\\n- .........\\n- 2021-04-08 11:58:54 Starting - Preparing the instances for training.........\\n- 2021-04-08 12:00:24 Downloading - Downloading input data\\n- 2021-04-08 12:00:24 Training - Downloading the training image..................\\n- 2021-04-08 12:03:39 Training - Training image download completed. Training in progress..\\n- ........\\n- epoch 0: {'accuracy': 0.7598039215686274, 'f1': 0.8178438661710037}\\n- epoch 1: {'accuracy': 0.8357843137254902, 'f1': 0.882249560632689}\\n- epoch 2: {'accuracy': 0.8406862745098039, 'f1': 0.8869565217391304}\\n- ........\\n- 2021-04-08 12:05:40 Uploading - Uploading generated training model\\n- 2021-04-08 12:05:40 Completed - Training job completed\\n- Training seconds: 331\\n- Billable seconds: 331\\n- You can find your model data at: s3://your-bucket/accelerate-sagemaker-1-2021-04-08-11-56-47-108/output/model.tar.gz\\n-\\n-\\n-\\n-Advanced Features\\n------------------------------------------------------------------------------------------------------------------------\\n-\\n-Distributed Training: Data Parallelism\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-*currently in development, will be supported soon.*\\n-\\n-Distributed Training: Model Parallelism\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-*currently in development, will be supported soon.*\\n-\\n-Python packages and dependencies\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. If you\\n-want to use different/other Python packages you can do this by adding them to the ``requirements.txt``. These packages\\n-will be installed before your training script is started.\\n-\\n-Remote scripts: Use scripts located on Github\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-*undecided if feature is needed. Contact us if you would like this feature.*\\n-\\n-Use Spot Instances\\n-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n-\\n-*undecided if feature is needed. Contact us if you would like this feature.*\\ndiff --git a/setup.py b/setup.py\\nindex bec3b9805..e1b2d3d1b 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -17,15 +17,7 @@\\n \\n extras = {}\\n extras[\\\"quality\\\"] = [\\\"black ~= 22.0\\\", \\\"isort >= 5.5.4\\\", \\\"flake8 >= 3.8.3\\\"]\\n-extras[\\\"docs\\\"] = [\\n- \\\"docutils==0.16.0\\\",\\n- \\\"recommonmark\\\",\\n- \\\"sphinx==3.2.1\\\",\\n- \\\"sphinx-markdown-tables\\\",\\n- \\\"sphinx-rtd-theme==0.4.3\\\",\\n- \\\"sphinx-copybutton\\\",\\n- \\\"sphinxext-opengraph==0.4.1\\\",\\n-]\\n+extras[\\\"docs\\\"] = []\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n \\\"pytest-xdist\\\",\\ndiff --git a/src/accelerate/__init__.py b/src/accelerate/__init__.py\\nindex f77a26a56..54ca364f6 100644\\n--- a/src/accelerate/__init__.py\\n+++ b/src/accelerate/__init__.py\\n@@ -5,7 +5,7 @@\\n __version__ = \\\"0.6.0.dev0\\\"\\n \\n from .accelerator import Accelerator\\n-from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs\\n+from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs\\n from .launchers import debug_launcher, notebook_launcher\\n from .state import DistributedType\\n from .utils import DeepSpeedPlugin, synchronize_rng_states\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 694dcc769..fabd3e9fc 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -56,49 +56,48 @@ class Accelerator:\\n Creates an instance of an accelerator for distributed training (on multi-GPU, TPU) or mixed precision training.\\n \\n Args:\\n- device_placement (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n+ device_placement (`bool`, *optional*, defaults to `True`):\\n Whether or not the accelerator should put objects on device (tensors yielded by the dataloader, model,\\n etc...).\\n- split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n Whether or not the accelerator should split the batches yielded by the dataloaders across the devices. If\\n- :obj:`True` the actual batch size used will be the same on any kind of distributed processes, but it must\\n- be a round multiple of the :obj:`num_processes` you are using. If :obj:`False`, actual batch size used will\\n- be the one set in your script multiplied by the number of processes.\\n- mixed_precision (:obj:`str`, `optional`):\\n+ `True` the actual batch size used will be the same on any kind of distributed processes, but it must be a\\n+ round multiple of the `num_processes` you are using. If `False`, actual batch size used will be the one set\\n+ in your script multiplied by the number of processes.\\n+ mixed_precision (`str`, *optional*):\\n Whether or not to use mixed precision training (fp16 or bfloat16). Choose from 'no','fp16','bf16'. Will\\n- default to the value in the environment variable :obj:`MIXED_PRECISION`, which will use the default value\\n- in the accelerate config of the current system or the flag passed with the :obj:`accelerate.launch`\\n- command. 'fp16' requires pytorch 1.6 or higher. 'bf16' requires pytorch 1.10 or higher.\\n- cpu (:obj:`bool`, `optional`):\\n- Whether or not to force the script to execute on CPU. Will ignore GPU available if set to :obj:`True` and\\n- force the execution on one process only.\\n- deepspeed_plugin (:obj:`DeepSpeedPlugin`, `optional`):\\n+ default to the value in the environment variable `MIXED_PRECISION`, which will use the default value in the\\n+ accelerate config of the current system or the flag passed with the `accelerate.launch` command. 'fp16'\\n+ requires pytorch 1.6 or higher. 'bf16' requires pytorch 1.10 or higher.\\n+ cpu (`bool`, *optional*):\\n+ Whether or not to force the script to execute on CPU. Will ignore GPU available if set to `True` and force\\n+ the execution on one process only.\\n+ deepspeed_plugin (`DeepSpeedPlugin`, *optional*):\\n Tweak your DeepSpeed related args using this argument. This argument is optional and can be configured\\n- directly using `accelerate config`\\n- rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ directly using *accelerate config*\\n+ rng_types (list of `str` or [`~utils.RNGType`]):\\n The list of random number generators to synchronize at the beginning of each iteration in your prepared\\n dataloaders. Should be one or several of:\\n \\n- - :obj:`\\\"torch\\\"`: the base torch random number generator\\n- - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n- - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n- - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n- your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n-\\n- Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n- >= 1.6.\\n- dispatch_batches (:obj:`bool`, `optional`):\\n- If set to :obj:`True`, the dataloader prepared by the Accelerator is only iterated through on the main\\n- process and then the batches are split and broadcast to each process. Will default to :obj:`True` for\\n- :obj:`DataLoader` whose underlying dataset is an :obj:`IterableDataset`, :obj:`False` otherwise.\\n- kwargs_handlers (list of kwargs handlers, `optional`)\\n- A list of :obj:`KwargHandler` to customize how the objects related to distributed training or mixed\\n- precision are created. See :doc:`kwargs` for more information.\\n+ - `\\\"torch\\\"`: the base torch random number generator\\n+ - `\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - `\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - `\\\"generator\\\"`: the `torch.Generator` of the sampler (or batch sampler if there is no sampler in your\\n+ dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n+\\n+ Will default to `[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and `[\\\"generator\\\"]` for PyTorch versions >= 1.6.\\n+ dispatch_batches (`bool`, *optional*):\\n+ If set to `True`, the dataloader prepared by the Accelerator is only iterated through on the main process\\n+ and then the batches are split and broadcast to each process. Will default to `True` for `DataLoader` whose\\n+ underlying dataset is an `IterableDataset`, `False` otherwise.\\n+ kwargs_handlers (`List[KwargHandler]`, *optional*)\\n+ A list of `KwargHandler` to customize how the objects related to distributed training or mixed precision\\n+ are created. See [kwargs](kwargs) for more information.\\n \\n Attributes\\n \\n- - **device** (:obj:`torch.device`) -- The device to use.\\n- - **state** (:class:`~accelerate.AcceleratorState`) -- The distributed setup state.\\n+ - **device** (`torch.device`) -- The device to use.\\n+ - **state** ([`~state.AcceleratorState`]) -- The distributed setup state.\\n \\\"\\\"\\\"\\n \\n def __init__(\\n@@ -276,7 +275,7 @@ def _goes_first(self, is_main):\\n \\n def print(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n- Use in replacement of :obj:`print()` to only print once per server.\\n+ Use in replacement of `print()` to only print once per server.\\n \\\"\\\"\\\"\\n if self.is_local_main_process:\\n print(*args, **kwargs)\\n@@ -296,14 +295,14 @@ def _prepare_one(self, obj):\\n \\n def prepare(self, *args):\\n \\\"\\\"\\\"\\n- Prepare all objects passed in :obj:`args` for distributed training and mixed precision, then return them in the\\n- same order.\\n+ Prepare all objects passed in `args` for distributed training and mixed precision, then return them in the same\\n+ order.\\n \\n Accepts the following type of objects:\\n \\n- - :obj:`torch.utils.data.DataLoader`: PyTorch Dataloader\\n- - :obj:`torch.nn.Module`: PyTorch Module\\n- - :obj:`torch.optim.Optimizer`: PyTorch Optimizer\\n+ - `torch.utils.data.DataLoader`: PyTorch Dataloader\\n+ - `torch.nn.Module`: PyTorch Module\\n+ - `torch.optim.Optimizer`: PyTorch Optimizer\\n \\\"\\\"\\\"\\n # On TPUs, putting the model on the XLA device will create new parameters, so the corresponding optimizer will\\n # have parameters disconnected from the model (so no training :-( ).\\n@@ -460,7 +459,7 @@ def prepare_optimizer(self, optimizer):\\n \\n def backward(self, loss, **kwargs):\\n \\\"\\\"\\\"\\n- Use :obj:`accelerator.backward(loss)` in lieu of :obj:`loss.backward()`.\\n+ Use `accelerator.backward(loss)` in lieu of `loss.backward()`.\\n \\\"\\\"\\\"\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n self.deepspeed_engine.backward(loss, **kwargs)\\n@@ -474,9 +473,9 @@ def unscale_gradients(self, optimizer=None):\\n Unscale the gradients in mixed precision training with AMP. This is a noop in all other settings.\\n \\n Args:\\n- optimizer (:obj:`torch.optim.Optimizer` or :obj:`List[torch.optim.Optimizer]`, `optional`):\\n+ optimizer (`torch.optim.Optimizer` or `List[torch.optim.Optimizer]`, *optional*):\\n The optimizer(s) for which to unscale gradients. If not set, will unscale gradients on all optimizers\\n- that were passed to :meth:`~accelerate.Accelerator.prepare`.\\n+ that were passed to [`~Accelerator.prepare`].\\n \\\"\\\"\\\"\\n if self.state.use_fp16 and self.native_amp:\\n if optimizer is None:\\n@@ -491,34 +490,33 @@ def unscale_gradients(self, optimizer=None):\\n \\n def clip_grad_norm_(self, parameters, max_norm, norm_type=2):\\n \\\"\\\"\\\"\\n- Should be used in place of :func:`torch.nn.utils.clip_grad_norm_`.\\n+ Should be used in place of `torch.nn.utils.clip_grad_norm_`.\\n \\\"\\\"\\\"\\n self.unscale_gradients()\\n torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=norm_type)\\n \\n def clip_grad_value_(self, parameters, clip_value):\\n \\\"\\\"\\\"\\n- Should be used in place of :func:`torch.nn.utils.clip_grad_value_`.\\n+ Should be used in place of `torch.nn.utils.clip_grad_value_`.\\n \\\"\\\"\\\"\\n self.unscale_gradients()\\n torch.nn.utils.clip_grad_value_(parameters, clip_value)\\n \\n def gather(self, tensor):\\n \\\"\\\"\\\"\\n- Gather the values in `tensor` accross all processes and concatenate them on the first dimension. Useful to\\n+ Gather the values in *tensor* accross all processes and concatenate them on the first dimension. Useful to\\n regroup the predictions from all processes when doing evaluation.\\n \\n Note:\\n This gather happens in all processes.\\n \\n Args:\\n- tensor (:obj:`torch.Tensor`, or a nested tuple/list/dictionary of :obj:`torch.Tensor`):\\n+ tensor (`torch.Tensor`, or a nested tuple/list/dictionary of `torch.Tensor`):\\n The tensors to gather across all processes.\\n \\n Returns:\\n- :obj:`torch.Tensor`, or a nested tuple/list/dictionary of :obj:`torch.Tensor`: The gathered tensor(s). Note\\n- that the first dimension of the result is `num_processes` multiplied by the first dimension of the input\\n- tensors.\\n+ `torch.Tensor`, or a nested tuple/list/dictionary of `torch.Tensor`: The gathered tensor(s). Note that the\\n+ first dimension of the result is *num_processes* multiplied by the first dimension of the input tensors.\\n \\\"\\\"\\\"\\n return gather(tensor)\\n \\n@@ -528,24 +526,24 @@ def pad_across_processes(self, tensor, dim=0, pad_index=0, pad_first=False):\\n they can safely be gathered.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to gather.\\n- dim (:obj:`int`, `optional`, defaults to 0):\\n+ dim (`int`, *optional*, defaults to 0):\\n The dimension on which to pad.\\n- pad_index (:obj:`int`, `optional`, defaults to 0):\\n+ pad_index (`int`, *optional*, defaults to 0):\\n The value with which to pad.\\n- pad_first (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ pad_first (`bool`, *optional*, defaults to `False`):\\n Whether to pad at the beginning or the end.\\n \\\"\\\"\\\"\\n return pad_across_processes(tensor, dim=dim, pad_index=pad_index, pad_first=pad_first)\\n \\n def unwrap_model(self, model):\\n \\\"\\\"\\\"\\n- Unwraps the :obj:`model` from the additional layer possible added by :meth:`~accelerate.Accelerator.prepare`.\\n- Useful before saving the model.\\n+ Unwraps the `model` from the additional layer possible added by [`~Accelerator.prepare`]. Useful before saving\\n+ the model.\\n \\n Args:\\n- model (:obj:`torch.nn.Module`):\\n+ model (`torch.nn.Module`):\\n The model to unwrap.\\n \\\"\\\"\\\"\\n return extract_model_from_parallel(model)\\n@@ -559,12 +557,12 @@ def wait_for_everyone(self):\\n \\n def save(self, obj, f):\\n \\\"\\\"\\\"\\n- Save the object passed to disk once per machine. Use in place of :obj:`torch.save`.\\n+ Save the object passed to disk once per machine. Use in place of `torch.save`.\\n \\n Args:\\n obj: The object to save.\\n- f (:obj:`str` or :obj:`os.PathLike`):\\n- Where to save the content of :obj:`obj`.\\n+ f (`str` or `os.PathLike`):\\n+ Where to save the content of `obj`.\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n@@ -573,7 +571,7 @@ def save_state(self, output_dir: str):\\n Saves the current states of the model, optimizer, scaler, RNG generators, and registered objects.\\n \\n Args:\\n- output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ output_dir (`str` or `os.PathLike`):\\n The name of the folder to save all relevant weights and states.\\n \\\"\\\"\\\"\\n # Check if folder exists\\n@@ -593,7 +591,7 @@ def load_state(self, input_dir: str):\\n Loads the current states of the model, optimizer, scaler, RNG generators, and registered objects.\\n \\n Args:\\n- input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ input_dir (`str` or `os.PathLike`):\\n The name of the folder all relevant weights and states were saved in.\\n \\\"\\\"\\\"\\n # Check if folder exists\\n@@ -674,7 +672,11 @@ def register_for_checkpointing(self, *objects):\\n These should be utilized when the state is being loaded or saved in the same script. It is not designed to be\\n used in different scripts\\n \\n- Note: Every `object` must have a `load_state_dict` and `state_dict` function to be stored.\\n+ <Tip>\\n+\\n+ Every `object` must have a `load_state_dict` and `state_dict` function to be stored.\\n+\\n+ </Tip>\\n \\\"\\\"\\\"\\n invalid_objects = []\\n for obj in objects:\\ndiff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nindex e1a28d108..0636dffaa 100644\\n--- a/src/accelerate/checkpointing.py\\n+++ b/src/accelerate/checkpointing.py\\n@@ -41,15 +41,15 @@ def save_accelerator_state(\\n Saves the current states of the models, optimizers, scaler, and RNG generators to a given directory.\\n \\n Args:\\n- output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ output_dir (`str` or `os.PathLike`):\\n The name of the folder to save all relevant weights and states.\\n- model_states (:obj:`List[torch.nn.Module]`):\\n+ model_states (`List[torch.nn.Module]`):\\n A list of model states\\n- optimizers (:obj:`List[torch.optim.Optimizer]`):\\n+ optimizers (`List[torch.optim.Optimizer]`):\\n A list of optimizer instances\\n- process_index (:obj:`int`):\\n+ process_index (`int`):\\n The current process index in the Accelerator state\\n- scaler (:obj:`torch.cuda.amp.GradScaler`, `optional`):\\n+ scaler (`torch.cuda.amp.GradScaler`, *optional*):\\n An optional gradient scaler instance to save\\n \\\"\\\"\\\"\\n # Model states\\n@@ -92,16 +92,16 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n Loads states of the models, optimizers, scaler, and RNG generators from a given directory.\\n \\n Args:\\n- input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ input_dir (`str` or `os.PathLike`):\\n The name of the folder to load all relevant weights and states.\\n- model_stmodelsates (:obj:`List[torch.nn.Module]`):\\n+ model_stmodelsates (`List[torch.nn.Module]`):\\n A list of model instances\\n- optimizers (:obj:`List[torch.optim.Optimizer]`):\\n+ optimizers (`List[torch.optim.Optimizer]`):\\n A list of optimizer instances\\n- process_index (:obj:`int`):\\n+ process_index (`int`):\\n The current process index in the Accelerator state\\n- scaler (:obj:`torch.cuda.amp.GradScaler`, `optional`):\\n- An optional `GradScaler` instance to load\\n+ scaler (`torch.cuda.amp.GradScaler`, *optional*):\\n+ An optional *GradScaler* instance to load\\n \\\"\\\"\\\"\\n # Model states\\n for i, model in enumerate(models):\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex cc46e5577..a827633c0 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -67,34 +67,34 @@\\n \\n class BatchSamplerShard(BatchSampler):\\n \\\"\\\"\\\"\\n- Wraps a PyTorch :obj:`BatchSampler` to generate batches for one of the processes only. Instances of this class will\\n- always yield a number of batches that is a round multiple of :obj:`num_processes` and that all have the same size.\\n- Depending on the value of the :obj:`drop_last` attribute of the batch sampler passed, it will either stop the\\n- iteration at the first batch that would be too small / not present on all processes or loop with indices from the\\n- beginning.\\n+ Wraps a PyTorch `BatchSampler` to generate batches for one of the processes only. Instances of this class will\\n+ always yield a number of batches that is a round multiple of `num_processes` and that all have the same size.\\n+ Depending on the value of the `drop_last` attribute of the batch sampler passed, it will either stop the iteration\\n+ at the first batch that would be too small / not present on all processes or loop with indices from the beginning.\\n \\n Args:\\n- batch_sampler (:obj:`torch.utils.data.sampler.BatchSampler`):\\n+ batch_sampler (`torch.utils.data.sampler.BatchSampler`):\\n The batch sampler to split in several shards.\\n- num_processes (:obj:`int`, `optional`, defaults to 1):\\n+ num_processes (`int`, *optional*, defaults to 1):\\n The number of processes running concurrently.\\n- process_index (:obj:`int`, `optional`, defaults to 0):\\n+ process_index (`int`, *optional*, defaults to 0):\\n The index of the current process.\\n- split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n Whether the shards should be created by splitting a batch to give a piece of it on each process, or by\\n yielding different full batches on each process.\\n \\n- On two processes with a sampler of :obj:`[[0, 1, 2, 3], [4, 5, 6, 7]]`, this will result in:\\n+ On two processes with a sampler of `[[0, 1, 2, 3], [4, 5, 6, 7]]`, this will result in:\\n \\n- - the sampler on process 0 to yield :obj:`[0, 1, 2, 3]` and the sampler on process 1 to yield :obj:`[4, 5,\\n- 6, 7]` if this argument is set to :obj:`False`.\\n- - the sampler on process 0 to yield :obj:`[0, 1]` then :obj:`[4, 5]` and the sampler on process 1 to yield\\n- :obj:`[2, 3]` then :obj:`[6, 7]` if this argument is set to :obj:`True`.\\n+ - the sampler on process 0 to yield `[0, 1, 2, 3]` and the sampler on process 1 to yield `[4, 5, 6, 7]` if\\n+ this argument is set to `False`.\\n+ - the sampler on process 0 to yield `[0, 1]` then `[4, 5]` and the sampler on process 1 to yield `[2, 3]`\\n+ then `[6, 7]` if this argument is set to `True`.\\n \\n- .. warning::\\n+ <Tip warning={true}>\\n \\n- This does not support :obj:`BatchSampler` with varying batch size yet.\\n- \\\"\\\"\\\"\\n+ This does not support `BatchSampler` with varying batch size yet.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n \\n def __init__(\\n self,\\n@@ -188,35 +188,35 @@ def _iter_with_no_split(self):\\n \\n class IterableDatasetShard(IterableDataset):\\n \\\"\\\"\\\"\\n- Wraps a PyTorch :obj:`IterableDataset` to generate samples for one of the processes only. Instances of this class\\n- will always yield a number of samples that is a round multiple of the actual batch size (depending of the value of\\n- :obj:`split_batches`, this is either :obj:`batch_size` or :obj:`batch_size x num_processes`). Depending on the\\n- value of the :obj:`drop_last` attribute of the batch sampler passed, it will either stop the iteration at the first\\n- batch that would be too small or loop with indices from the beginning.\\n+ Wraps a PyTorch `IterableDataset` to generate samples for one of the processes only. Instances of this class will\\n+ always yield a number of samples that is a round multiple of the actual batch size (depending of the value of\\n+ `split_batches`, this is either `batch_size` or `batch_size x num_processes`). Depending on the value of the\\n+ `drop_last` attribute of the batch sampler passed, it will either stop the iteration at the first batch that would\\n+ be too small or loop with indices from the beginning.\\n \\n Args:\\n- dataset (:obj:`torch.utils.data.dataset.IterableDataset`):\\n+ dataset (`torch.utils.data.dataset.IterableDataset`):\\n The batch sampler to split in several shards.\\n- batch_size (:obj:`int`, `optional`, defaults to 1):\\n- The size of the batches per shard (if :obj:`split_batches=False`) or the size of the batches (if\\n- :obj:`split_batches=True`).\\n- drop_last (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ batch_size (`int`, *optional*, defaults to 1):\\n+ The size of the batches per shard (if `split_batches=False`) or the size of the batches (if\\n+ `split_batches=True`).\\n+ drop_last (`bool`, *optional*, defaults to `False`):\\n Whether or not to drop the last incomplete batch or complete the last batches by using the samples from the\\n beginning.\\n- num_processes (:obj:`int`, `optional`, defaults to 1):\\n+ num_processes (`int`, *optional*, defaults to 1):\\n The number of processes running concurrently.\\n- process_index (:obj:`int`, `optional`, defaults to 0):\\n+ process_index (`int`, *optional*, defaults to 0):\\n The index of the current process.\\n- split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n Whether the shards should be created by splitting a batch to give a piece of it on each process, or by\\n yielding different full batches on each process.\\n \\n- On two processes with an iterable dataset yielding of :obj:`[0, 1, 2, 3, 4, 5, 6, 7]`, this will result in:\\n+ On two processes with an iterable dataset yielding of `[0, 1, 2, 3, 4, 5, 6, 7]`, this will result in:\\n \\n- - the shard on process 0 to yield :obj:`[0, 1, 2, 3]` and the shard on process 1 to yield :obj:`[4, 5, 6,\\n- 7]` if this argument is set to :obj:`False`.\\n- - the shard on process 0 to yield :obj:`[0, 1, 4, 5]` and the sampler on process 1 to yield :obj:`[2, 3, 6,\\n- 7]` if this argument is set to :obj:`True`.\\n+ - the shard on process 0 to yield `[0, 1, 2, 3]` and the shard on process 1 to yield `[4, 5, 6, 7]` if this\\n+ argument is set to `False`.\\n+ - the shard on process 0 to yield `[0, 1, 4, 5]` and the sampler on process 1 to yield `[2, 3, 6, 7]` if\\n+ this argument is set to `True`.\\n \\\"\\\"\\\"\\n \\n def __init__(\\n@@ -269,25 +269,25 @@ def __iter__(self):\\n \\n class DataLoaderShard(DataLoader):\\n \\\"\\\"\\\"\\n- Subclass of a PyTorch :obj:`DataLoader` that will deal with device placement and current distributed setup.\\n+ Subclass of a PyTorch `DataLoader` that will deal with device placement and current distributed setup.\\n \\n Args:\\n- dataset (:obj:`torch.utils.data.dataset.Dataset`):\\n+ dataset (`torch.utils.data.dataset.Dataset`):\\n The dataset to use to build this datalaoder.\\n- device (:obj:`torch.device`, `optional`):\\n+ device (`torch.device`, *optional*):\\n If passed, the device to put all batches on.\\n- rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ rng_types (list of `str` or [`~utils.RNGType`]):\\n The list of random number generators to synchronize at the beginning of each iteration. Should be one or\\n several of:\\n \\n- - :obj:`\\\"torch\\\"`: the base torch random number generator\\n- - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n- - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n- - :obj:`\\\"generator\\\"`: an optional :obj:`torch.Generator`\\n- generator (:obj:`torch.Generator`, `optional`):\\n+ - `\\\"torch\\\"`: the base torch random number generator\\n+ - `\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - `\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - `\\\"generator\\\"`: an optional `torch.Generator`\\n+ generator (`torch.Generator`, *optional*):\\n A random number generator to keep synchronized across processes.\\n kwargs:\\n- All other keyword arguments to pass to the regular :obj:`DataLoader` initialization.\\n+ All other keyword arguments to pass to the regular `DataLoader` initialization.\\n \\\"\\\"\\\"\\n \\n def __init__(self, dataset, device=None, rng_types=None, generator=None, **kwargs):\\n@@ -308,21 +308,21 @@ def __iter__(self):\\n \\n class DataLoaderDispatcher(DataLoader):\\n \\\"\\\"\\\"\\n- Subclass of a PyTorch :obj:`DataLoader` that will iterate and preprocess on process 0 only, then dispatch on each\\n+ Subclass of a PyTorch `DataLoader` that will iterate and preprocess on process 0 only, then dispatch on each\\n process their part of the batch.\\n \\n Args:\\n- split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n- Whether the resulting :obj:`DataLoader` should split the batches of the original data loader across devices\\n- or yield full batches (in which case it will yield batches starting at the :obj:`process_index`-th and\\n- advancing of :obj:`num_processes` batches at each iteration).\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n+ Whether the resulting `DataLoader` should split the batches of the original data loader across devices or\\n+ yield full batches (in which case it will yield batches starting at the `process_index`-th and advancing of\\n+ `num_processes` batches at each iteration).\\n \\n- Another way to see this is that the observed batch size will be the same as the initial :obj:`dataloader`\\n- if this option is set to :obj:`True`, the batch size of the initial :obj:`dataloader` multiplied by\\n- :obj:`num_processes` otherwise.\\n+ Another way to see this is that the observed batch size will be the same as the initial `dataloader` if\\n+ this option is set to `True`, the batch size of the initial `dataloader` multiplied by `num_processes`\\n+ otherwise.\\n \\n- Setting this option to :obj:`True` requires that the batch size of the :obj:`dataloader` is a round\\n- multiple of :obj:`batch_size`.\\n+ Setting this option to `True` requires that the batch size of the `dataloader` is a round multiple of\\n+ `batch_size`.\\n \\\"\\\"\\\"\\n \\n def __init__(self, dataset, split_batches: bool = False, **kwargs):\\n@@ -425,58 +425,58 @@ def prepare_data_loader(\\n dispatch_batches: Optional[bool] = None,\\n ) -> DataLoader:\\n \\\"\\\"\\\"\\n- Wraps a PyTorch :obj:`DataLoader` to generate batches for one of the processes only.\\n+ Wraps a PyTorch `DataLoader` to generate batches for one of the processes only.\\n \\n- Depending on the value of the :obj:`drop_last` attribute of the :obj:`dataloader` passed, it will either stop the\\n- iteration at the first batch that would be too small / not present on all processes or loop with indices from the\\n- beginning.\\n+ Depending on the value of the `drop_last` attribute of the `dataloader` passed, it will either stop the iteration\\n+ at the first batch that would be too small / not present on all processes or loop with indices from the beginning.\\n \\n Args:\\n- dataloader (:obj:`torch.utils.data.dataloader.DataLoader`):\\n+ dataloader (`torch.utils.data.dataloader.DataLoader`):\\n The data loader to split across several devices.\\n- device (:obj:`torch.device`):\\n- The target device for the returned :obj:`DataLoader`.\\n- num_processes (:obj:`int`, `optional`):\\n+ device (`torch.device`):\\n+ The target device for the returned `DataLoader`.\\n+ num_processes (`int`, *optional*):\\n The number of processes running concurrently. Will default to the value given by\\n- :class:`~accelerate.AcceleratorState`.\\n- process_index (:obj:`int`, `optional`):\\n- The index of the current process. Will default to the value given by :class:`~accelerate.AcceleratorState`.\\n- split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n- Whether the resulting :obj:`DataLoader` should split the batches of the original data loader across devices\\n- or yield full batches (in which case it will yield batches starting at the :obj:`process_index`-th and\\n- advancing of :obj:`num_processes` batches at each iteration).\\n-\\n- Another way to see this is that the observed batch size will be the same as the initial :obj:`dataloader`\\n- if this option is set to :obj:`True`, the batch size of the initial :obj:`dataloader` multiplied by\\n- :obj:`num_processes` otherwise.\\n-\\n- Setting this option to :obj:`True` requires that the batch size of the :obj:`dataloader` is a round\\n- multiple of :obj:`batch_size`.\\n- put_on_device (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n- Whether or not to put the batches on :obj:`device` (only works if the batches are nested list, tuples or\\n+ [`~state.AcceleratorState`].\\n+ process_index (`int`, *optional*):\\n+ The index of the current process. Will default to the value given by [`~state.AcceleratorState`].\\n+ split_batches (`bool`, *optional*, defaults to `False`):\\n+ Whether the resulting `DataLoader` should split the batches of the original data loader across devices or\\n+ yield full batches (in which case it will yield batches starting at the `process_index`-th and advancing of\\n+ `num_processes` batches at each iteration).\\n+\\n+ Another way to see this is that the observed batch size will be the same as the initial `dataloader` if\\n+ this option is set to `True`, the batch size of the initial `dataloader` multiplied by `num_processes`\\n+ otherwise.\\n+\\n+ Setting this option to `True` requires that the batch size of the `dataloader` is a round multiple of\\n+ `batch_size`.\\n+ put_on_device (`bool`, *optional*, defaults to `False`):\\n+ Whether or not to put the batches on `device` (only works if the batches are nested list, tuples or\\n dictionaries of tensors).\\n- rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ rng_types (list of `str` or [`~utils.RNGType`]):\\n The list of random number generators to synchronize at the beginning of each iteration. Should be one or\\n several of:\\n \\n- - :obj:`\\\"torch\\\"`: the base torch random number generator\\n- - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n- - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n- - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n- your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n+ - `\\\"torch\\\"`: the base torch random number generator\\n+ - `\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - `\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - `\\\"generator\\\"`: the `torch.Generator` of the sampler (or batch sampler if there is no sampler in your\\n+ dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n- dispatch_batches (:obj:`bool`, `optional`):\\n- If set to :obj:`True`, the datalaoder prepared is only iterated through on the main process and then the\\n- batches are split and broadcast to each process. Will default to :obj:`True` when the underlying dataset is\\n- an :obj:`IterableDataset`, :obj:`False` otherwise.\\n+ dispatch_batches (`bool`, *optional*):\\n+ If set to `True`, the datalaoder prepared is only iterated through on the main process and then the batches\\n+ are split and broadcast to each process. Will default to `True` when the underlying dataset is an\\n+ `IterableDataset`, `False` otherwise.\\n \\n Returns:\\n- :obj:`torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\n+ `torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\n \\n- .. warning::\\n+ <Tip warning={true}>\\n \\n- This does not support :obj:`BatchSampler` with varying batch size yet.\\n- \\\"\\\"\\\"\\n+ This does not support `BatchSampler` with varying batch size yet.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n if dispatch_batches is None:\\n if version.parse(torch.__version__) < version.parse(\\\"1.8.0\\\") or not put_on_device:\\n dispatch_batches = False\\ndiff --git a/src/accelerate/deepspeed_utils.py b/src/accelerate/deepspeed_utils.py\\nindex 07450a87e..5f261f2e3 100644\\n--- a/src/accelerate/deepspeed_utils.py\\n+++ b/src/accelerate/deepspeed_utils.py\\n@@ -71,7 +71,7 @@ class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):\\n Internal wrapper around a deepspeed optimizer.\\n \\n Args:\\n- optimizer (:obj:`torch.optim.optimizer.Optimizer`):\\n+ optimizer (`torch.optim.optimizer.Optimizer`):\\n The optimizer to wrap.\\n \\\"\\\"\\\"\\n \\ndiff --git a/src/accelerate/kwargs_handlers.py b/src/accelerate/kwargs_handlers.py\\nindex 51760efdc..cf5985644 100644\\n--- a/src/accelerate/kwargs_handlers.py\\n+++ b/src/accelerate/kwargs_handlers.py\\n@@ -20,7 +20,7 @@\\n \\n class KwargsHandler:\\n \\\"\\\"\\\"\\n- Internal mixin that implements a :obj:`to_kwargs()` method for a dataclass.\\n+ Internal mixin that implements a `to_kwargs()` method for a dataclass.\\n \\\"\\\"\\\"\\n \\n def to_dict(self):\\n@@ -38,15 +38,16 @@ def to_kwargs(self):\\n @dataclass\\n class DistributedDataParallelKwargs(KwargsHandler):\\n \\\"\\\"\\\"\\n- Use this object in your :class:`~accelerate.Accelerator` to customize how your model is wrapped in a\\n- :obj:`torch.nn.parallel.DistributedDataParallel`. Please refer to the documentation of this `wrapper\\n- <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__ for more information\\n- on each argument.\\n+ Use this object in your [`Accelerator`] to customize how your model is wrapped in a\\n+ `torch.nn.parallel.DistributedDataParallel`. Please refer to the documentation of this\\n+ [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) for more\\n+ information on each argument.\\n \\n- .. warning::\\n+ <Tip warning={true}>\\n \\n- :obj:`gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.\\n- \\\"\\\"\\\"\\n+ `gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n \\n dim: int = 0\\n broadcast_buffers: bool = True\\n@@ -59,14 +60,15 @@ class DistributedDataParallelKwargs(KwargsHandler):\\n @dataclass\\n class GradScalerKwargs(KwargsHandler):\\n \\\"\\\"\\\"\\n- Use this object in your :class:`~accelerate.Accelerator` to customize the behavior of mixed precision, specifically\\n- how the :obj:`torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this `scaler\\n- <https://pytorch.org/docs/stable/amp.html?highlight=gradscaler>`__ for more information on each argument.\\n+ Use this object in your [`Accelerator`] to customize the behavior of mixed precision, specifically how the\\n+ `torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this\\n+ [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) for more information on each argument.\\n \\n- .. warning::\\n+ <Tip warning={true}>\\n \\n- :obj:`GradScaler` is only available in PyTorch 1.5.0 and later versions.\\n- \\\"\\\"\\\"\\n+ `GradScaler` is only available in PyTorch 1.5.0 and later versions.\\n+\\n+ </Tip>\\\"\\\"\\\"\\n \\n init_scale: float = 65536.0\\n growth_factor: float = 2.0\\n@@ -78,10 +80,10 @@ class GradScalerKwargs(KwargsHandler):\\n @dataclass\\n class InitProcessGroupKwargs(KwargsHandler):\\n \\\"\\\"\\\"\\n- Use this object in your :class:`~accelerate.Accelerator` to customize the initialization of the distributed\\n- processes. Please refer to the documentation of this `method\\n- <https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group>`__ for more information on\\n- each argument.\\n+ Use this object in your [`Accelerator`] to customize the initialization of the distributed processes. Please refer\\n+ to the documentation of this\\n+ [method](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) for more\\n+ information on each argument.\\n \\\"\\\"\\\"\\n \\n init_method: Optional[str] = None\\ndiff --git a/src/accelerate/launchers.py b/src/accelerate/launchers.py\\nindex a47eb9a4c..48c4404dd 100644\\n--- a/src/accelerate/launchers.py\\n+++ b/src/accelerate/launchers.py\\n@@ -31,17 +31,17 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mix\\n multiple cores for instance).\\n \\n Args:\\n- function (:obj:`Callable`):\\n+ function (`Callable`):\\n The training function to execute. If it accepts arguments, the first argument should be the index of the\\n process run.\\n- args (:obj:`Tuple`):\\n- Tuple of arguments to pass to the function (it will receive :obj:`*args`).\\n- num_processes (:obj:`int`, `optional`):\\n+ args (`Tuple`):\\n+ Tuple of arguments to pass to the function (it will receive `*args`).\\n+ num_processes (`int`, *optional*):\\n The number of processes to use for training. Will default to 8 in Colab/Kaggle if a TPU is available, to\\n the number of GPUs available otherwise.\\n- mixed_precision (:obj:`str`, `optional`, defaults to :obj:`no`):\\n- If :obj:`fp16` or :obj:`bf16`, will use mixed precision training on multi-GPU.\\n- use_port (:obj:`str`, `optional`, defaults to :obj:`\\\"29500\\\"`):\\n+ mixed_precision (`str`, *optional*, defaults to `\\\"no\\\"`):\\n+ If `fp16` or `bf16`, will use mixed precision training on multi-GPU.\\n+ use_port (`str`, *optional*, defaults to `\\\"29500\\\"`):\\n The port to use to communicate between processes when launching a multi-GPU training.\\n \\\"\\\"\\\"\\n # Are we in a google colab or a Kaggle Kernel?\\n@@ -140,18 +140,19 @@ def debug_launcher(function, args=(), num_processes=2):\\n \\\"\\\"\\\"\\n Launches a training function using several processes on CPU for debugging purposes.\\n \\n- .. warning::\\n+ <Tip warning={true}>\\n \\n- This function is provided for internal testing and debugging, but it's not intended for real trainings. It will\\n- only use the CPU.\\n+ This function is provided for internal testing and debugging, but it's not intended for real trainings. It will\\n+ only use the CPU.\\n \\n+ </Tip>\\n \\n Args:\\n- function (:obj:`Callable`):\\n+ function (`Callable`):\\n The training function to execute.\\n- args (:obj:`Tuple`):\\n- Tuple of arguments to pass to the function (it will receive :obj:`*args`).\\n- num_processes (:obj:`int`, *optional*, defaults to 2):\\n+ args (`Tuple`):\\n+ Tuple of arguments to pass to the function (it will receive `*args`).\\n+ num_processes (`int`, *optional*, defaults to 2):\\n The number of processes to use for training.\\n \\\"\\\"\\\"\\n if version.parse(torch.__version__) < version.parse(\\\"1.5.0\\\"):\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 52217ba6a..4360c0c09 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -41,12 +41,12 @@ class AcceleratedOptimizer(torch.optim.Optimizer):\\n Internal wrapper around a torch optimizer.\\n \\n Args:\\n- optimizer (:obj:`torch.optim.optimizer.Optimizer`):\\n+ optimizer (`torch.optim.optimizer.Optimizer`):\\n The optimizer to wrap.\\n- device_placement (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n+ device_placement (`bool`, *optional*, defaults to `True`):\\n Whether or not the optimizer should handle device placement. If so, it will place the state dictionary of\\n- :obj:`optimizer` on the right device.\\n- scaler (:obj:`torch.cuda.amp.grad_scaler.GradScaler`, `optional`):\\n+ `optimizer` on the right device.\\n+ scaler (`torch.cuda.amp.grad_scaler.GradScaler`, *optional*):\\n The scaler to use in the step function if training with mixed precision.\\n \\\"\\\"\\\"\\n \\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex e8c910e19..0e0c21e1a 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -127,19 +127,19 @@ class ComputeEnvironment(str, Enum):\\n # Inspired by Alex Martelli's 'Borg'.\\n class AcceleratorState:\\n \\\"\\\"\\\"\\n- This is a variation of a `singleton class <https://en.wikipedia.org/wiki/Singleton_pattern>`__ in the sense that\\n- all instance of :obj:`AcceleratorState` share the same state, which is initialized on the first instantiation.\\n-\\n- Attributes\\n-\\n- - **device** (:obj:`torch.device`) -- The device to use.\\n- - **distributed_type** (:obj:`~accelerate.state.DistributedType`) -- The type of distributed environment\\n- currently in use.\\n- - **num_processes** (:obj:`int`) -- The number of processes currently launched in parallel.\\n- - **process_index** (:obj:`int`) -- The index of the current process.\\n- - **local_process_index** (:obj:`int`) -- The index of the current process on the current server.\\n- - **mixed_precision** (:obj:`str`) -- Whether or not the current script will use mixed precision. If you are\\n- using mixed precision, define if you want to use FP16 or BF16 (bfloat16) as the floating point.\\n+ This is a variation of a [singleton class](https://en.wikipedia.org/wiki/Singleton_pattern) in the sense that all\\n+ instance of `AcceleratorState` share the same state, which is initialized on the first instantiation.\\n+\\n+ Attributes:\\n+\\n+ - **device** (`torch.device`) -- The device to use.\\n+ - **distributed_type** (`~accelerate.state.DistributedType`) -- The type of distributed environment currently\\n+ in use.\\n+ - **num_processes** (`int`) -- The number of processes currently launched in parallel.\\n+ - **process_index** (`int`) -- The index of the current process.\\n+ - **local_process_index** (`int`) -- The index of the current process on the current server.\\n+ - **mixed_precision** (`str`) -- Whether or not the current script will use mixed precision. If you are using\\n+ mixed precision, define if you want to use FP16 or BF16 (bfloat16) as the floating point.\\n \\\"\\\"\\\"\\n \\n _shared_state = {}\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 4b20cc1c3..69e74f2a5 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -65,11 +65,12 @@ class TensorInformation:\\n \\n def set_seed(seed: int, device_specific: bool = False):\\n \\\"\\\"\\\"\\n- Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch``.\\n+ Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.\\n \\n Args:\\n- seed (:obj:`int`): The seed to set.\\n- device_specific (:obj:`bool`, `optional`, defaults to :obj:`False`): Whether to differ the seed on each device slightly with `self.process_index`\\n+ seed (`int`): The seed to set.\\n+ device_specific (`bool`, *optional*, defaults to `False`):\\n+ Whether to differ the seed on each device slightly with `self.process_index`.\\n \\\"\\\"\\\"\\n if device_specific:\\n seed += AcceleratorState().process_index\\n@@ -146,23 +147,22 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n Recursively apply a function on a data structure that is a nested list/tuple/dictionary of a given base type.\\n \\n Args:\\n- func (:obj:`callable`):\\n+ func (`callable`):\\n The function to recursively apply.\\n- data (nested list/tuple/dictionary of :obj:`main_type`):\\n- The data on which to apply :obj:`func`\\n+ data (nested list/tuple/dictionary of `main_type`):\\n+ The data on which to apply `func`\\n *args:\\n- Positional arguments that will be passed to :obj:`func` when applied on the unpacked data.\\n- main_type (:obj:`type`, `optional`, defaults to :obj:`torch.Tensor`):\\n- The base type of the objects to which apply :obj:`func`.\\n- error_on_other_type (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n- Whether to return an error or not if after unpacking :obj:`data`, we get on an object that is not of type\\n- :obj:`main_type`. If :obj:`False`, the function will leave objects of types different than :obj:`main_type`\\n- unchanged.\\n+ Positional arguments that will be passed to `func` when applied on the unpacked data.\\n+ main_type (`type`, *optional*, defaults to `torch.Tensor`):\\n+ The base type of the objects to which apply `func`.\\n+ error_on_other_type (`bool`, *optional*, defaults to `False`):\\n+ Whether to return an error or not if after unpacking `data`, we get on an object that is not of type\\n+ `main_type`. If `False`, the function will leave objects of types different than `main_type` unchanged.\\n **kwargs:\\n- Keyword arguments that will be passed to :obj:`func` when applied on the unpacked data.\\n+ Keyword arguments that will be passed to `func` when applied on the unpacked data.\\n \\n Returns:\\n- The same data structure as :obj:`data` with :obj:`func` applied to every object of type :obj:`main_type`.\\n+ The same data structure as `data` with `func` applied to every object of type `main_type`.\\n \\\"\\\"\\\"\\n if isinstance(data, (tuple, list)):\\n return honor_type(\\n@@ -198,13 +198,13 @@ def send_to_device(tensor, device):\\n Recursively sends the elements in a nested list/tuple/dictionary of tensors to a given device.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to send to a given device.\\n- device (:obj:`torch.device`):\\n- The device to send the data to\\n+ device (`torch.device`):\\n+ The device to send the data to.\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors sent to the proper device.\\n+ The same data structure as `tensor` with all tensors sent to the proper device.\\n \\\"\\\"\\\"\\n \\n def _send_to_device(t, device):\\n@@ -221,11 +221,11 @@ def get_data_structure(data):\\n Recursively gathers the information needed to rebuild a nested list/tuple/dictionary of tensors.\\n \\n Args:\\n- data (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ data (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to send to analyze.\\n \\n Returns:\\n- The same data structure as :obj:`data` with :class:`~accelerate.utils.TensorInformation` instead of tensors.\\n+ The same data structure as `data` with [`~utils.TensorInformation`] instead of tensors.\\n \\\"\\\"\\\"\\n \\n def _get_data_structure(tensor):\\n@@ -236,11 +236,10 @@ def _get_data_structure(tensor):\\n \\n def initialize_tensors(data_structure):\\n \\\"\\\"\\\"\\n- Recursively initializes tensors from a nested list/tuple/dictionary of\\n- :class:`~accelerate.utils.TensorInformation`.\\n+ Recursively initializes tensors from a nested list/tuple/dictionary of [`~utils.TensorInformation`].\\n \\n Returns:\\n- The same data structure as :obj:`data` with tensors instead of :class:`~accelerate.utils.TensorInformation`.\\n+ The same data structure as `data` with tensors instead of [`~utils.TensorInformation`].\\n \\\"\\\"\\\"\\n \\n def _initialize_tensor(tensor_info):\\n@@ -254,11 +253,11 @@ def convert_to_fp32(tensor):\\n Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to convert from FP16/BF16 to FP32.\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n+ The same data structure as `tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n \\\"\\\"\\\"\\n \\n def _convert_to_fp32(tensor):\\n@@ -279,11 +278,11 @@ def convert_outputs_to_fp32(model_forward):\\n precision will be convert back to FP32.\\n \\n Args:\\n- model_forward (:obj:`Callable`):\\n+ model_forward (`Callable`):\\n The function which outputs we want to treat.\\n \\n Returns:\\n- The same function as :obj:`model_forward` but with converted outputs.\\n+ The same function as `model_forward` but with converted outputs.\\n \\\"\\\"\\\"\\n \\n def convert_outputs(*args, **kwargs):\\n@@ -298,10 +297,10 @@ def extract_model_from_parallel(model):\\n Extract a model from its distributed containers.\\n \\n Args:\\n- model (:obj:`torch.nn.Module`): The model to extract.\\n+ model (`torch.nn.Module`): The model to extract.\\n \\n Returns:\\n- :obj:`torch.nn.Module`: The extracted model.\\n+ `torch.nn.Module`: The extracted model.\\n \\\"\\\"\\\"\\n options = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)\\n if is_deepspeed_available():\\n@@ -343,11 +342,11 @@ def gather(tensor):\\n Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to gather.\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors sent to the proper device.\\n+ The same data structure as `tensor` with all tensors sent to the proper device.\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n return _tpu_gather(tensor, name=\\\"accelerate.utils.gather\\\")\\n@@ -380,7 +379,7 @@ def gather_object(object: Any):\\n The data to gather.\\n \\n Returns:\\n- The same data structure as :obj:`object` with all the objects sent to every device.\\n+ The same data structure as `object` with all the objects sent to every device.\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n raise NotImplementedError(\\\"gather objects in TPU is not supported\\\")\\n@@ -413,13 +412,13 @@ def broadcast(tensor, from_process: int = 0):\\n Recursively broadcast tensor in a nested list/tuple/dictionary of tensors to all devices.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to gather.\\n- from_process (:obj:`int`, `optional`, defaults to 0):\\n+ from_process (`int`, *optional*, defaults to 0):\\n The process from which to send the data\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors broadcasted to the proper device.\\n+ The same data structure as `tensor` with all tensors broadcasted to the proper device.\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n return _tpu_broadcast(tensor, src=from_process, name=\\\"accelerate.utils.broadcast\\\")\\n@@ -438,7 +437,7 @@ def broadcast_object_list(object_list, from_process: int = 0):\\n Args:\\n object_list (list of picklable objects):\\n The list of objects to broadcast. This list will be modified inplace.\\n- from_process (:obj:`int`, `optional`, defaults to 0):\\n+ from_process (`int`, *optional*, defaults to 0):\\n The process from which to send the data.\\n \\n Returns:\\n@@ -459,13 +458,13 @@ def slice_tensors(data, tensor_slice):\\n Recursively takes a slice in a nested list/tuple/dictionary of tensors.\\n \\n Args:\\n- data (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ data (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to slice.\\n- tensor_slice (:obj:`slice`):\\n+ tensor_slice (`slice`):\\n The slice to take.\\n \\n Returns:\\n- The same data structure as :obj:`data` with all the tensors slices.\\n+ The same data structure as `data` with all the tensors slices.\\n \\\"\\\"\\\"\\n \\n def _slice_tensor(tensor, tensor_slice):\\n@@ -479,10 +478,10 @@ def find_batch_size(data):\\n Recursively finds the batch size in a nested list/tuple/dictionary of lists of tensors.\\n \\n Args:\\n- data (nested list/tuple/dictionary of :obj:`torch.Tensor`): The data from which to find the batch size.\\n+ data (nested list/tuple/dictionary of `torch.Tensor`): The data from which to find the batch size.\\n \\n Returns:\\n- :obj:`int`: The batch size.\\n+ `int`: The batch size.\\n \\\"\\\"\\\"\\n if isinstance(data, (tuple, list)):\\n return find_batch_size(data[0])\\n@@ -499,13 +498,13 @@ def concatenate(data, dim=0):\\n Recursively concatenate the tensors in a nested list/tuple/dictionary of lists of tensors with the same shape.\\n \\n Args:\\n- data (nested list/tuple/dictionary of lists of tensors :obj:`torch.Tensor`):\\n+ data (nested list/tuple/dictionary of lists of tensors `torch.Tensor`):\\n The data to concatenate.\\n- dim (:obj:`int`, `optional`, defaults to 0):\\n+ dim (`int`, *optional*, defaults to 0):\\n The dimension on which to concatenate.\\n \\n Returns:\\n- The same data structure as :obj:`data` with all the tensors concatenated.\\n+ The same data structure as `data` with all the tensors concatenated.\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n@@ -522,13 +521,13 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n can safely be gathered.\\n \\n Args:\\n- tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ tensor (nested list/tuple/dictionary of `torch.Tensor`):\\n The data to gather.\\n- dim (:obj:`int`, `optional`, defaults to 0):\\n+ dim (`int`, *optional*, defaults to 0):\\n The dimension on which to pad.\\n- pad_index (:obj:`int`, `optional`, defaults to 0):\\n+ pad_index (`int`, *optional*, defaults to 0):\\n The value with which to pad.\\n- pad_first (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ pad_first (`bool`, *optional*, defaults to `False`):\\n Whether to pad at the beginning or the end.\\n \\\"\\\"\\\"\\n \\n@@ -566,9 +565,11 @@ def wait_for_everyone():\\n \\\"\\\"\\\"\\n Introduces a blocking point in the script, making sure all processes have reached this point before continuing.\\n \\n- Warning::\\n+ <Tip warning={true}>\\n \\n- Make sure all processes will reach this instruction otherwise one of your processes will hang forever.\\n+ Make sure all processes will reach this instruction otherwise one of your processes will hang forever.\\n+\\n+ </Tip>\\n \\\"\\\"\\\"\\n if (\\n AcceleratorState().distributed_type == DistributedType.MULTI_GPU\\n@@ -582,7 +583,7 @@ def wait_for_everyone():\\n \\n def save(obj, f):\\n \\\"\\\"\\\"\\n- Save the data to disk. Use in place of :obj:`torch.save()`.\\n+ Save the data to disk. Use in place of `torch.save()`.\\n \\n Args:\\n obj: The data to save\\n@@ -599,11 +600,11 @@ class PrepareForLaunch:\\n Prepare a function that will launched in a distributed setup.\\n \\n Args:\\n- launcher (:obj:`Callable`):\\n+ launcher (`Callable`):\\n The function to launch.\\n- distributed_type (:class:`~accelerate.state.DistributedType`):\\n+ distributed_type ([`~state.DistributedType`]):\\n The distributed type to prepare for.\\n- debug (:obj:`bool`, *optional*, defaults to :obj:`False`):\\n+ debug (`bool`, *optional*, defaults to `False`):\\n Whether or not this is a debug launch.\\n \\\"\\\"\\\"\\n \\n@@ -680,9 +681,9 @@ def __post_init__(self):\\n @contextmanager\\n def patch_environment(**kwargs):\\n \\\"\\\"\\\"\\n- A context manager that will add each keyword argument passed to ``os.environ`` and remove them when exiting.\\n+ A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting.\\n \\n- Will convert the values in :obj:`kwargs` to strings and upper-case all the keys.\\n+ Will convert the values in `kwargs` to strings and upper-case all the keys.\\n \\\"\\\"\\\"\\n for key, value in kwargs.items():\\n os.environ[key.upper()] = str(value)\\n@@ -695,7 +696,7 @@ def patch_environment(**kwargs):\\n \\n def get_pretty_name(obj):\\n \\\"\\\"\\\"\\n- Gets a pretty name from ``obj``\\n+ Gets a pretty name from `obj`.\\n \\\"\\\"\\\"\\n if not hasattr(obj, \\\"__qualname__\\\") and not hasattr(obj, \\\"__name__\\\"):\\n obj = getattr(obj, \\\"__class__\\\", obj)\\ndiff --git a/utils/style_doc.py b/utils/style_doc.py\\nindex 0e363eaab..2a325805f 100644\\n--- a/utils/style_doc.py\\n+++ b/utils/style_doc.py\\n@@ -1,6 +1,5 @@\\n # coding=utf-8\\n-\\n-# Copyright 2021 The HuggingFace Inc. team.\\n+# Copyright 2020 The HuggingFace Inc. team.\\n #\\n # Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n # you may not use this file except in compliance with the License.\\n@@ -13,78 +12,209 @@\\n # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n-\\n \\\"\\\"\\\"Style utils for the .rst and the docstrings.\\\"\\\"\\\"\\n \\n import argparse\\n import os\\n import re\\n import warnings\\n-from enum import Enum\\n-\\n-\\n-# Special blocks where the inside should be formatted.\\n-TEXTUAL_BLOCKS = [\\\"note\\\", \\\"warning\\\"]\\n-# List of acceptable characters for titles and sections underline.\\n-TITLE_SPECIAL_CHARS = \\\"\\\"\\\"= - ` : ' \\\" ~ ^ _ * + # < >\\\"\\\"\\\".split(\\\" \\\")\\n-# Special words for docstrings (s? means the s is optional)\\n-DOC_SPECIAL_WORD = [\\n- \\\"Args?\\\",\\n- \\\"Params?\\\",\\n- \\\"Parameters?\\\",\\n- \\\"Arguments?\\\",\\n- \\\"Examples?\\\",\\n- \\\"Usage\\\",\\n- \\\"Returns?\\\",\\n- \\\"Raises?\\\",\\n- \\\"Attributes?\\\",\\n-]\\n+\\n+import black\\n+\\n+\\n+BLACK_AVOID_PATTERNS = {}\\n+\\n \\n # Regexes\\n-# Matches any declaration of textual block, like `.. note::`. (ignore case to avoid writing all versions in the list)\\n-_re_textual_blocks = re.compile(r\\\"^\\\\s*\\\\.\\\\.\\\\s+(\\\" + \\\"|\\\".join(TEXTUAL_BLOCKS) + r\\\")\\\\s*::\\\\s*$\\\", re.IGNORECASE)\\n-# Matches list introduction in rst.\\n+# Re pattern that catches list introduction (with potential indent)\\n _re_list = re.compile(r\\\"^(\\\\s*-\\\\s+|\\\\s*\\\\*\\\\s+|\\\\s*\\\\d+\\\\.\\\\s+)\\\")\\n-# Matches the indent in a line.\\n-_re_indent = re.compile(r\\\"^(\\\\s*)\\\\S\\\")\\n-# Matches a table declaration in rst.\\n-_re_table = re.compile(r\\\"(\\\\+-+)+\\\\+\\\\s*$\\\")\\n-# Matches a code block in rst `:: `.\\n-_re_code_block = re.compile(r\\\"^\\\\s*::\\\\s*$\\\")\\n-# Matches any block of the form `.. something::` or `.. something:: bla`.\\n-_re_ignore = re.compile(r\\\"^\\\\s*\\\\.\\\\.\\\\s+(.*?)\\\\s*::\\\\s*\\\\S*\\\\s*$\\\")\\n-# Matches comment introduction in rst.\\n-_re_comment = re.compile(r\\\"\\\\s*\\\\.\\\\.\\\\s*$\\\")\\n+# Re pattern that catches code block introduction (with potentinal indent)\\n+_re_code = re.compile(r\\\"^(\\\\s*)```(.*)$\\\")\\n+# Re pattern that catches rst args blocks of the form `Parameters:`.\\n+_re_args = re.compile(\\\"^\\\\s*(Args?|Arguments?|Params?|Parameters?):\\\\s*$\\\")\\n+# Re pattern that catches return blocks of the form `Return:`.\\n+_re_returns = re.compile(\\\"^\\\\s*Returns?:\\\\s*$\\\")\\n # Matches the special tag to ignore some paragraphs.\\n _re_doc_ignore = re.compile(r\\\"(\\\\.\\\\.|#)\\\\s*docstyle-ignore\\\")\\n-# Matches the example introduction in docstrings.\\n-_re_example = re.compile(r\\\"::\\\\s*$\\\")\\n-# Matches the parameters introduction in docstrings.\\n-_re_arg_def = re.compile(r\\\"^\\\\s*(Args?|Parameters?|Params|Arguments?|Environment|Attributes?)\\\\s*:\\\\s*$\\\")\\n-# Matches the return introduction in docstrings.\\n-_re_return = re.compile(r\\\"^\\\\s*(Returns?|Raises?|Note)\\\\s*:\\\\s*$\\\")\\n-# Matches any doc special word.\\n-_re_any_doc_special_word = re.compile(r\\\"^\\\\s*(\\\" + \\\"|\\\".join(DOC_SPECIAL_WORD) + r\\\")::?\\\\s*$\\\")\\n+# Re pattern that matches <Tip>, </Tip> and <Tip warning={true}> blocks.\\n+_re_tip = re.compile(\\\"^\\\\s*</?Tip(>|\\\\s+warning={true}>)\\\\s*$\\\")\\n+\\n+DOCTEST_PROMPTS = [\\\">>>\\\", \\\"...\\\"]\\n+\\n+\\n+def is_empty_line(line):\\n+ return len(line) == 0 or line.isspace()\\n+\\n+\\n+def find_indent(line):\\n+ \\\"\\\"\\\"\\n+ Returns the number of spaces that start a line indent.\\n+ \\\"\\\"\\\"\\n+ search = re.search(\\\"^(\\\\s*)(?:\\\\S|$)\\\", line)\\n+ if search is None:\\n+ return 0\\n+ return len(search.groups()[0])\\n+\\n+\\n+def parse_code_example(code_lines):\\n+ \\\"\\\"\\\"\\n+ Parses a code example\\n+\\n+ Args:\\n+ code_lines (`List[str]`): The code lines to parse.\\n+ max_len (`int`): The maximum lengh per line.\\n+\\n+ Returns:\\n+ (List[`str`], List[`str`]): The list of code samples and the list of outputs.\\n+ \\\"\\\"\\\"\\n+ has_doctest = code_lines[0][:3] in DOCTEST_PROMPTS\\n+\\n+ code_samples = []\\n+ outputs = []\\n+ in_code = True\\n+ current_bit = []\\n+\\n+ for line in code_lines:\\n+ if in_code and has_doctest and not is_empty_line(line) and line[:3] not in DOCTEST_PROMPTS:\\n+ code_sample = \\\"\\\\n\\\".join(current_bit)\\n+ code_samples.append(code_sample.strip())\\n+ in_code = False\\n+ current_bit = []\\n+ elif not in_code and line[:3] in DOCTEST_PROMPTS:\\n+ output = \\\"\\\\n\\\".join(current_bit)\\n+ outputs.append(output.strip())\\n+ in_code = True\\n+ current_bit = []\\n+\\n+ # Add the line without doctest prompt\\n+ if line[:3] in DOCTEST_PROMPTS:\\n+ line = line[4:]\\n+ current_bit.append(line)\\n+\\n+ # Add last sample\\n+ if in_code:\\n+ code_sample = \\\"\\\\n\\\".join(current_bit)\\n+ code_samples.append(code_sample.strip())\\n+ else:\\n+ output = \\\"\\\\n\\\".join(current_bit)\\n+ outputs.append(output.strip())\\n+\\n+ return code_samples, outputs\\n \\n \\n-class SpecialBlock(Enum):\\n- NOT_SPECIAL = 0\\n- NO_STYLE = 1\\n- ARG_LIST = 2\\n+def format_code_example(code: str, max_len: int, in_docstring: bool = False):\\n+ \\\"\\\"\\\"\\n+ Format a code example using black. Will take into account the doctest syntax as well as any initial indentation in\\n+ the code provided.\\n \\n+ Args:\\n+ code (`str`): The code example to format.\\n+ max_len (`int`): The maximum lengh per line.\\n+ in_docstring (`bool`, *optional*, defaults to `False`): Whether or not the code example is inside a docstring.\\n \\n-def split_text_in_lines(text, max_len, prefix=\\\"\\\", min_indent=None):\\n+ Returns:\\n+ `str`: The formatted code.\\n+ \\\"\\\"\\\"\\n+ code_lines = code.split(\\\"\\\\n\\\")\\n+\\n+ # Find initial indent\\n+ idx = 0\\n+ while idx < len(code_lines) and is_empty_line(code_lines[idx]):\\n+ idx += 1\\n+ if idx >= len(code_lines):\\n+ return \\\"\\\", \\\"\\\"\\n+ indent = find_indent(code_lines[idx])\\n+\\n+ # Remove the initial indent for now, we will had it back after styling.\\n+ # Note that l[indent:] works for empty lines\\n+ code_lines = [l[indent:] for l in code_lines[idx:]]\\n+ has_doctest = code_lines[0][:3] in DOCTEST_PROMPTS\\n+\\n+ code_samples, outputs = parse_code_example(code_lines)\\n+\\n+ # Let's blackify the code! We put everything in one big text to go faster.\\n+ delimiter = \\\"\\\\n\\\\n### New code sample ###\\\\n\\\"\\n+ full_code = delimiter.join(code_samples)\\n+ line_length = max_len - indent\\n+ if has_doctest:\\n+ line_length -= 4\\n+\\n+ for k, v in BLACK_AVOID_PATTERNS.items():\\n+ full_code = full_code.replace(k, v)\\n+ try:\\n+ mode = black.Mode(target_versions={black.TargetVersion.PY37}, line_length=line_length)\\n+ formatted_code = black.format_str(full_code, mode=mode)\\n+ error = \\\"\\\"\\n+ except Exception as e:\\n+ formatted_code = full_code\\n+ error = f\\\"Code sample:\\\\n{full_code}\\\\n\\\\nError message:\\\\n{e}\\\"\\n+\\n+ # Let's get back the formatted code samples\\n+ for k, v in BLACK_AVOID_PATTERNS.items():\\n+ formatted_code = formatted_code.replace(v, k)\\n+ # Triple quotes will mess docstrings.\\n+ if in_docstring:\\n+ formatted_code = formatted_code.replace('\\\"\\\"\\\"', \\\"'''\\\")\\n+\\n+ code_samples = formatted_code.split(delimiter)\\n+ # We can have one output less than code samples\\n+ if len(outputs) == len(code_samples) - 1:\\n+ outputs.append(\\\"\\\")\\n+\\n+ formatted_lines = []\\n+ for code_sample, output in zip(code_samples, outputs):\\n+ # black may have added some new lines, we remove them\\n+ code_sample = code_sample.strip()\\n+ in_triple_quotes = False\\n+ in_decorator = False\\n+ for line in code_sample.strip().split(\\\"\\\\n\\\"):\\n+ if has_doctest and not is_empty_line(line):\\n+ prefix = (\\n+ \\\"... \\\"\\n+ if line.startswith(\\\" \\\") or line in [\\\")\\\", \\\"]\\\", \\\"}\\\"] or in_triple_quotes or in_decorator\\n+ else \\\">>> \\\"\\n+ )\\n+ else:\\n+ prefix = \\\"\\\"\\n+ indent_str = \\\"\\\" if is_empty_line(line) else (\\\" \\\" * indent)\\n+ formatted_lines.append(indent_str + prefix + line)\\n+\\n+ if '\\\"\\\"\\\"' in line:\\n+ in_triple_quotes = not in_triple_quotes\\n+ if line.startswith(\\\" \\\"):\\n+ in_decorator = False\\n+ if line.startswith(\\\"@\\\"):\\n+ in_decorator = True\\n+\\n+ formatted_lines.extend([\\\" \\\" * indent + line for line in output.split(\\\"\\\\n\\\")])\\n+ if not output.endswith(\\\"===PT-TF-SPLIT===\\\"):\\n+ formatted_lines.append(\\\"\\\")\\n+\\n+ result = \\\"\\\\n\\\".join(formatted_lines)\\n+ return result.rstrip(), error\\n+\\n+\\n+def format_text(text, max_len, prefix=\\\"\\\", min_indent=None):\\n \\\"\\\"\\\"\\n- Split `text` in the biggest lines possible with the constraint of `max_len` using `prefix` on the first line and\\n- then indenting with the same length as `prefix`.\\n+ Format a text in the biggest lines possible with the constraint of a maximum length and an indentation.\\n+\\n+ Args:\\n+ text (`str`): The text to format\\n+ max_len (`int`): The maximum length per line to use\\n+ prefix (`str`, *optional*, defaults to `\\\"\\\"`): A prefix that will be added to the text.\\n+ The prefix doesn't count toward the indent (like a - introducing a list).\\n+ min_indent (`int`, *optional*): The minimum indent of the text.\\n+ If not set, will default to the length of the `prefix`.\\n+\\n+ Returns:\\n+ `str`: The formatted text.\\n \\\"\\\"\\\"\\n text = re.sub(r\\\"\\\\s+\\\", \\\" \\\", text)\\n- indent = \\\" \\\" * len(prefix)\\n if min_indent is not None:\\n- if len(indent) < len(min_indent):\\n- indent = min_indent\\n- if len(prefix) < len(min_indent):\\n- prefix = \\\" \\\" * (len(min_indent) - len(prefix)) + prefix\\n+ if len(prefix) < min_indent:\\n+ prefix = \\\" \\\" * (min_indent - len(prefix)) + prefix\\n+\\n+ indent = \\\" \\\" * len(prefix)\\n new_lines = []\\n words = text.split(\\\" \\\")\\n current_line = f\\\"{prefix}{words[0]}\\\"\\n@@ -99,379 +229,189 @@ def split_text_in_lines(text, max_len, prefix=\\\"\\\", min_indent=None):\\n return \\\"\\\\n\\\".join(new_lines)\\n \\n \\n-def get_indent(line):\\n- \\\"\\\"\\\"Get the indentation of `line`.\\\"\\\"\\\"\\n- indent_search = _re_indent.search(line)\\n- return indent_search.groups()[0] if indent_search is not None else \\\"\\\"\\n-\\n-\\n-class CodeStyler:\\n- \\\"\\\"\\\"A generic class to style .rst files.\\\"\\\"\\\"\\n-\\n- def is_no_style_block(self, line):\\n- \\\"\\\"\\\"Whether or not `line` introduces a block where styling should be ignore\\\"\\\"\\\"\\n- if _re_code_block.search(line) is not None:\\n- return True\\n- if _re_textual_blocks.search(line) is not None:\\n- return False\\n- return _re_ignore.search(line) is not None\\n-\\n- def is_comment_or_textual_block(self, line):\\n- \\\"\\\"\\\"Whether or not `line` introduces a block where styling should not be ignored (note, warnings...)\\\"\\\"\\\"\\n- if _re_comment.search(line):\\n- return True\\n- return _re_textual_blocks.search(line) is not None\\n-\\n- def is_special_block(self, line):\\n- \\\"\\\"\\\"Whether or not `line` introduces a special block.\\\"\\\"\\\"\\n- if self.is_no_style_block(line):\\n- self.in_block = SpecialBlock.NO_STYLE\\n- return True\\n- return False\\n-\\n- def init_in_block(self, text):\\n- \\\"\\\"\\\"\\n- Returns the initial value for `self.in_block`.\\n-\\n- Useful for some docstrings beginning inside an argument declaration block (all models).\\n- \\\"\\\"\\\"\\n- return SpecialBlock.NOT_SPECIAL\\n-\\n- def end_of_special_style(self, line):\\n- \\\"\\\"\\\"\\n- Sets back the `in_block` attribute to `NOT_SPECIAL`.\\n-\\n- Useful for some docstrings where we may have to go back to `ARG_LIST` instead.\\n- \\\"\\\"\\\"\\n- self.in_block = SpecialBlock.NOT_SPECIAL\\n-\\n- def style_paragraph(self, paragraph, max_len, no_style=False, min_indent=None):\\n- \\\"\\\"\\\"\\n- Style `paragraph` (a list of lines) by making sure no line goes over `max_len`, except if the `no_style` flag\\n- is passed.\\n- \\\"\\\"\\\"\\n- if len(paragraph) == 0:\\n- return \\\"\\\"\\n- if no_style or self.in_block == SpecialBlock.NO_STYLE:\\n- return \\\"\\\\n\\\".join(paragraph)\\n- if _re_list.search(paragraph[0]) is not None:\\n- # Great, we're in a list. So we need to split our paragraphs in smaller parts, one for each item.\\n- result = \\\"\\\"\\n- remainder = \\\"\\\"\\n- prefix = _re_list.search(paragraph[0]).groups()[0]\\n- prefix_indent = get_indent(paragraph[0])\\n- current_item = [paragraph[0][len(prefix) :]]\\n- for i, line in enumerate(paragraph[1:]):\\n- new_item_search = _re_list.search(line)\\n- indent = get_indent(line)\\n- if len(indent) < len(prefix_indent) or (len(indent) == len(prefix_indent) and new_item_search is None):\\n- # There might not be an empty line after the list, formatting the remainder recursively.\\n- remainder = \\\"\\\\n\\\" + self.style_paragraph(\\n- paragraph[i + 1 :], max_len, no_style=no_style, min_indent=min_indent\\n- )\\n- break\\n- elif new_item_search is not None:\\n- text = \\\" \\\".join([l.strip() for l in current_item])\\n- result += split_text_in_lines(text, max_len, prefix, min_indent=min_indent) + \\\"\\\\n\\\"\\n- prefix = new_item_search.groups()[0]\\n- prefix_indent = indent\\n- current_item = [line[len(prefix) :]]\\n- else:\\n- current_item.append(line)\\n- # Treat the last item\\n- text = \\\" \\\".join([l.strip() for l in current_item])\\n- result += split_text_in_lines(text, max_len, prefix, min_indent=min_indent)\\n- # Add the potential remainder\\n- return result + remainder\\n-\\n- if len(paragraph) > 1 and self.is_comment_or_textual_block(paragraph[0]):\\n- # Comments/notes in rst should be restyled with indentation, ignoring the first line.\\n- indent = get_indent(paragraph[1])\\n- text = \\\" \\\".join([l.strip() for l in paragraph[1:]])\\n- return paragraph[0] + \\\"\\\\n\\\" + split_text_in_lines(text, max_len, indent, min_indent=min_indent)\\n-\\n- if self.in_block == SpecialBlock.ARG_LIST:\\n- # Arg lists are special: we need to ignore the lines that are at the first indentation level beneath the\\n- # Args/Parameters (parameter description), then we can style the indentation level beneath.\\n- result = \\\"\\\"\\n- # The args/parameters could be in that paragraph and should be ignored\\n- if _re_arg_def.search(paragraph[0]) is not None:\\n- if len(paragraph) == 1:\\n- return paragraph[0]\\n- result += paragraph[0] + \\\"\\\\n\\\"\\n- paragraph = paragraph[1:]\\n-\\n- if self.current_indent is None:\\n- self.current_indent = get_indent(paragraph[1])\\n-\\n- current_item = []\\n- for line in paragraph:\\n- if get_indent(line) == self.current_indent:\\n- if len(current_item) > 0:\\n- item_indent = get_indent(current_item[0])\\n- text = \\\" \\\".join([l.strip() for l in current_item])\\n- result += split_text_in_lines(text, max_len, item_indent, min_indent=min_indent) + \\\"\\\\n\\\"\\n- result += line + \\\"\\\\n\\\"\\n- current_item = []\\n- else:\\n- current_item.append(line)\\n- if len(current_item) > 0:\\n- item_indent = get_indent(current_item[0])\\n- text = \\\" \\\".join([l.strip() for l in current_item])\\n- result += split_text_in_lines(text, max_len, item_indent, min_indent=min_indent) + \\\"\\\\n\\\"\\n- return result[:-1]\\n-\\n- indent = get_indent(paragraph[0])\\n- text = \\\" \\\".join([l.strip() for l in paragraph])\\n- return split_text_in_lines(text, max_len, indent, min_indent=min_indent)\\n-\\n- def style(self, text, max_len=119, min_indent=None):\\n- \\\"\\\"\\\"Style `text` to `max_len`.\\\"\\\"\\\"\\n- new_lines = []\\n- paragraph = []\\n- self.current_indent = \\\"\\\"\\n- self.previous_indent = None\\n- # If one of those is True, the paragraph should not be touched (code samples, lists...)\\n- no_style = False\\n- no_style_next = False\\n- self.in_block = self.init_in_block(text)\\n- # If this is True, we force-break a paragraph, even if there is no new empty line.\\n- break_paragraph = False\\n-\\n- lines = text.split(\\\"\\\\n\\\")\\n- last_line = None\\n- for line in lines:\\n- # New paragraph\\n- line_is_empty = len(line.strip()) == 0\\n- list_begins = (\\n- _re_list.search(line) is not None\\n- and last_line is not None\\n- and len(get_indent(line)) > len(get_indent(last_line))\\n- )\\n- if line_is_empty or break_paragraph or list_begins:\\n- if len(paragraph) > 0:\\n- if self.in_block != SpecialBlock.NOT_SPECIAL:\\n- indent = get_indent(paragraph[0])\\n- # Are we still in a no-style block?\\n- if self.current_indent is None:\\n- # If current_indent is None, we haven't begun the interior of the block so the answer is\\n- # yes, unless we have an indent of 0 in which case the special block took one line only.\\n- if len(indent) == 0:\\n- self.in_block = SpecialBlock.NOT_SPECIAL\\n- else:\\n- self.current_indent = indent\\n- elif not indent.startswith(self.current_indent):\\n- # If not, we are leaving the block when we unindent.\\n- self.end_of_special_style(paragraph[0])\\n-\\n- if self.is_special_block(paragraph[0]):\\n- # Maybe we are starting a special block.\\n- if len(paragraph) > 1:\\n- # If we have the interior of the block in the paragraph, we grab the indent.\\n- self.current_indent = get_indent(paragraph[1])\\n- else:\\n- # We will determine the indent with the next paragraph\\n- self.current_indent = None\\n- styled_paragraph = self.style_paragraph(\\n- paragraph, max_len, no_style=no_style, min_indent=min_indent\\n- )\\n- new_lines.append(styled_paragraph + \\\"\\\\n\\\")\\n- else:\\n- new_lines.append(\\\"\\\")\\n-\\n- paragraph = []\\n- no_style = no_style_next\\n- no_style_next = False\\n- last_line = None\\n- if (not break_paragraph and not list_begins) or line_is_empty:\\n- break_paragraph = False\\n- continue\\n- break_paragraph = False\\n-\\n- # Title and section lines should go to the max + add a new paragraph.\\n- if (\\n- len(set(line)) == 1\\n- and line[0] in TITLE_SPECIAL_CHARS\\n- and last_line is not None\\n- and len(line) >= len(last_line)\\n- ):\\n- line = line[0] * max_len\\n- break_paragraph = True\\n- # proper doc comment indicates the next paragraph should be no-style.\\n- if _re_doc_ignore.search(line) is not None:\\n- no_style_next = True\\n- # Table are in just one paragraph and should be no-style.\\n- if _re_table.search(line) is not None:\\n- no_style = True\\n- paragraph.append(line)\\n- last_line = line\\n-\\n- # Just have to treat the last paragraph. It could still be in a no-style block (or not)\\n- if len(paragraph) > 0:\\n- # Are we still in a special block\\n- # (if current_indent is None, we are but no need to set it since we are the end.)\\n- if self.in_block != SpecialBlock.NO_STYLE and self.current_indent is not None:\\n- indent = get_indent(paragraph[0])\\n- if not indent.startswith(self.current_indent):\\n- self.in_block = SpecialBlock.NOT_SPECIAL\\n- _ = self.is_special_block(paragraph[0])\\n- new_lines.append(self.style_paragraph(paragraph, max_len, no_style=no_style, min_indent=min_indent) + \\\"\\\\n\\\")\\n- return \\\"\\\\n\\\".join(new_lines)\\n-\\n-\\n-class DocstringStyler(CodeStyler):\\n- \\\"\\\"\\\"Class to style docstrings that take the main method from `CodeStyler`.\\\"\\\"\\\"\\n-\\n- def is_no_style_block(self, line):\\n- if _re_textual_blocks.search(line) is not None:\\n- return False\\n- if _re_example.search(line) is not None:\\n- return True\\n- return _re_code_block.search(line) is not None\\n-\\n- def is_comment_or_textual_block(self, line):\\n- if _re_return.search(line) is not None:\\n- self.in_block = SpecialBlock.NOT_SPECIAL\\n- return True\\n- return super().is_comment_or_textual_block(line)\\n-\\n- def is_special_block(self, line):\\n- if self.is_no_style_block(line):\\n- if self.previous_indent is None and self.in_block == SpecialBlock.ARG_LIST:\\n- self.previous_indent = self.current_indent\\n- self.in_block = SpecialBlock.NO_STYLE\\n- return True\\n- if _re_arg_def.search(line) is not None:\\n- self.in_block = SpecialBlock.ARG_LIST\\n- return True\\n- return False\\n-\\n- def end_of_special_style(self, line):\\n- if self.previous_indent is not None and line.startswith(self.previous_indent):\\n- self.in_block = SpecialBlock.ARG_LIST\\n- self.current_indent = self.previous_indent\\n- else:\\n- self.in_block = SpecialBlock.NOT_SPECIAL\\n- self.previous_indent = None\\n-\\n- def init_in_block(self, text):\\n- lines = text.split(\\\"\\\\n\\\")\\n- while len(lines) > 0 and len(lines[0]) == 0:\\n- lines = lines[1:]\\n- if len(lines) == 0:\\n- return SpecialBlock.NOT_SPECIAL\\n- if re.search(r\\\":\\\\s*$\\\", lines[0]):\\n- indent = get_indent(lines[0])\\n- if (\\n- len(lines) == 1\\n- or len(get_indent(lines[1])) > len(indent)\\n- or (len(get_indent(lines[1])) == len(indent) and re.search(r\\\":\\\\s*$\\\", lines[1]))\\n- ):\\n- self.current_indent = indent\\n- return SpecialBlock.ARG_LIST\\n- return SpecialBlock.NOT_SPECIAL\\n-\\n-\\n-rst_styler = CodeStyler()\\n-doc_styler = DocstringStyler()\\n-\\n-\\n-def _add_new_lines_before_list(text):\\n- \\\"\\\"\\\"Add a new empty line before a list begins.\\\"\\\"\\\"\\n- lines = text.split(\\\"\\\\n\\\")\\n- new_lines = []\\n- in_list = False\\n- for idx, line in enumerate(lines):\\n- # Detect if the line is the start of a new list.\\n- if _re_list.search(line) is not None and not in_list:\\n- current_indent = get_indent(line)\\n- in_list = True\\n- # If the line before is non empty, add an extra new line.\\n- if idx > 0 and len(lines[idx - 1]) != 0:\\n- new_lines.append(\\\"\\\")\\n- # Detect if we're out of the current list.\\n- if in_list and not line.startswith(current_indent) and _re_list.search(line) is None:\\n- in_list = False\\n- new_lines.append(line)\\n- return \\\"\\\\n\\\".join(new_lines)\\n+def split_line_on_first_colon(line):\\n+ splits = line.split(\\\":\\\")\\n+ return splits[0], \\\":\\\".join(splits[1:])\\n \\n \\n-def _add_new_lines_before_doc_special_words(text):\\n- lines = text.split(\\\"\\\\n\\\")\\n+def style_docstring(docstring, max_len):\\n+ \\\"\\\"\\\"\\n+ Style a docstring by making sure there is no useless whitespace and the maximum horizontal space is used.\\n+\\n+ Args:\\n+ docstring (`str`): The docstring to style.\\n+ max_len (`int`): The maximum length of each line.\\n+\\n+ Returns:\\n+ `str`: The styled docstring\\n+ \\\"\\\"\\\"\\n+ lines = docstring.split(\\\"\\\\n\\\")\\n new_lines = []\\n+\\n+ # Initialization\\n+ current_paragraph = None\\n+ current_indent = -1\\n+ in_code = False\\n+ param_indent = -1\\n+ prefix = \\\"\\\"\\n+ black_errors = []\\n+\\n+ # Special case for docstrings that begin with continuation of Args with no Args block.\\n+ idx = 0\\n+ while idx < len(lines) and is_empty_line(lines[idx]):\\n+ idx += 1\\n+ if (\\n+ len(lines[idx]) > 1\\n+ and lines[idx].rstrip().endswith(\\\":\\\")\\n+ and find_indent(lines[idx + 1]) > find_indent(lines[idx])\\n+ ):\\n+ param_indent = find_indent(lines[idx])\\n+\\n for idx, line in enumerate(lines):\\n- # Detect if the line is the start of a new list.\\n- if _re_any_doc_special_word.search(line) is not None:\\n- # If the line before is non empty, add an extra new line.\\n- if idx > 0 and len(lines[idx - 1]) != 0:\\n+ # Doing all re searches once for the one we need to repeat.\\n+ list_search = _re_list.search(line)\\n+ code_search = _re_code.search(line)\\n+\\n+ # Are we starting a new paragraph?\\n+ # New indentation or new line:\\n+ new_paragraph = find_indent(line) != current_indent or is_empty_line(line)\\n+ # List item\\n+ new_paragraph = new_paragraph or list_search is not None\\n+ # Code block beginning\\n+ new_paragraph = new_paragraph or code_search is not None\\n+ # Beginning/end of tip\\n+ new_paragraph = new_paragraph or _re_tip.search(line)\\n+\\n+ # In this case, we treat the current paragraph\\n+ if not in_code and new_paragraph and current_paragraph is not None and len(current_paragraph) > 0:\\n+ paragraph = \\\" \\\".join(current_paragraph)\\n+ new_lines.append(format_text(paragraph, max_len, prefix=prefix, min_indent=current_indent))\\n+ current_paragraph = None\\n+\\n+ if code_search is not None:\\n+ if not in_code:\\n+ current_paragraph = []\\n+ current_indent = len(code_search.groups()[0])\\n+ current_code = code_search.groups()[1]\\n+ prefix = \\\"\\\"\\n+ if current_indent < param_indent:\\n+ param_indent = -1\\n+ else:\\n+ current_indent = -1\\n+ code = \\\"\\\\n\\\".join(current_paragraph)\\n+ if current_code in [\\\"py\\\", \\\"python\\\"]:\\n+ formatted_code, error = format_code_example(code, max_len, in_docstring=True)\\n+ new_lines.append(formatted_code)\\n+ if len(error) > 0:\\n+ black_errors.append(error)\\n+ else:\\n+ new_lines.append(code)\\n+ current_paragraph = None\\n+ new_lines.append(line)\\n+ in_code = not in_code\\n+\\n+ elif in_code:\\n+ current_paragraph.append(line)\\n+ elif is_empty_line(line):\\n+ current_paragraph = None\\n+ current_indent = -1\\n+ prefix = \\\"\\\"\\n+ new_lines.append(line)\\n+ elif list_search is not None:\\n+ prefix = list_search.groups()[0]\\n+ current_indent = len(prefix)\\n+ current_paragraph = [line[current_indent:]]\\n+ elif _re_args.search(line):\\n+ new_lines.append(line)\\n+ param_indent = find_indent(lines[idx + 1])\\n+ elif _re_tip.search(line):\\n+ # Add a new line before if not present\\n+ if not is_empty_line(new_lines[-1]):\\n new_lines.append(\\\"\\\")\\n- new_lines.append(line)\\n- return \\\"\\\\n\\\".join(new_lines)\\n-\\n+ new_lines.append(line)\\n+ # Add a new line after if not present\\n+ if idx < len(lines) - 1 and not is_empty_line(lines[idx + 1]):\\n+ new_lines.append(\\\"\\\")\\n+ elif current_paragraph is None or find_indent(line) != current_indent:\\n+ indent = find_indent(line)\\n+ # Special behavior for parameters intros.\\n+ if indent == param_indent:\\n+ # Special rules for some docstring where the Returns blocks has the same indent as the parameters.\\n+ if _re_returns.search(line) is not None:\\n+ param_indent = -1\\n+ new_lines.append(line)\\n+ elif len(line) < max_len:\\n+ new_lines.append(line)\\n+ else:\\n+ intro, description = split_line_on_first_colon(line)\\n+ new_lines.append(intro + \\\":\\\")\\n+ if len(description) != 0:\\n+ if find_indent(lines[idx + 1]) > indent:\\n+ current_indent = find_indent(lines[idx + 1])\\n+ else:\\n+ current_indent = indent + 4\\n+ current_paragraph = [description.strip()]\\n+ prefix = \\\"\\\"\\n+ else:\\n+ # Check if we have exited the parameter block\\n+ if indent < param_indent:\\n+ param_indent = -1\\n \\n-def style_rst_file(doc_file, max_len=119, check_only=False):\\n- \\\"\\\"\\\" Style one rst file `doc_file` to `max_len`.\\\"\\\"\\\"\\n- with open(doc_file, \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n- doc = f.read()\\n+ current_paragraph = [line.strip()]\\n+ current_indent = find_indent(line)\\n+ prefix = \\\"\\\"\\n+ elif current_paragraph is not None:\\n+ current_paragraph.append(line.lstrip())\\n \\n- # Add missing new lines before lists\\n- clean_doc = _add_new_lines_before_list(doc)\\n- # Style\\n- clean_doc = rst_styler.style(clean_doc, max_len=max_len)\\n+ if current_paragraph is not None and len(current_paragraph) > 0:\\n+ paragraph = \\\" \\\".join(current_paragraph)\\n+ new_lines.append(format_text(paragraph, max_len, prefix=prefix, min_indent=current_indent))\\n \\n- diff = clean_doc != doc\\n- if not check_only and diff:\\n- print(f\\\"Overwriting content of {doc_file}.\\\")\\n- with open(doc_file, \\\"w\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n- f.write(clean_doc)\\n-\\n- return diff\\n-\\n-\\n-def style_docstring(docstring, max_len=119):\\n- \\\"\\\"\\\"Style `docstring` to `max_len`.\\\"\\\"\\\"\\n- # One-line docstring that are not too long are left as is.\\n- if len(docstring) < max_len and \\\"\\\\n\\\" not in docstring:\\n- return docstring\\n-\\n- # Grab the indent from the last line\\n- last_line = docstring.split(\\\"\\\\n\\\")[-1]\\n- # Is it empty except for the last triple-quotes (not-included in `docstring`)?\\n- indent_search = re.search(r\\\"^(\\\\s*)$\\\", last_line)\\n- if indent_search is not None:\\n- indent = indent_search.groups()[0]\\n- if len(indent) > 0:\\n- docstring = docstring[: -len(indent)]\\n- # Or are the triple quotes next to text (we will fix that).\\n- else:\\n- indent_search = _re_indent.search(last_line)\\n- indent = indent_search.groups()[0] if indent_search is not None else \\\"\\\"\\n+ return \\\"\\\\n\\\".join(new_lines), \\\"\\\\n\\\\n\\\".join(black_errors)\\n \\n- # Add missing new lines before Args/Returns etc.\\n- docstring = _add_new_lines_before_doc_special_words(docstring)\\n- # Add missing new lines before lists\\n- docstring = _add_new_lines_before_list(docstring)\\n- # Style\\n- styled_doc = doc_styler.style(docstring, max_len=max_len, min_indent=indent)\\n \\n- # Add new lines if necessary\\n- if not styled_doc.startswith(\\\"\\\\n\\\"):\\n- styled_doc = \\\"\\\\n\\\" + styled_doc\\n- if not styled_doc.endswith(\\\"\\\\n\\\"):\\n- styled_doc += \\\"\\\\n\\\"\\n- return styled_doc + indent\\n+def style_docstrings_in_code(code, max_len=119):\\n+ \\\"\\\"\\\"\\n+ Style all docstrings in some code.\\n \\n+ Args:\\n+ code (`str`): The code in which we want to style the docstrings.\\n+ max_len (`int`): The maximum number of characters per line.\\n \\n-def style_file_docstrings(code_file, max_len=119, check_only=False):\\n- \\\"\\\"\\\"Style all docstrings in `code_file` to `max_len`.\\\"\\\"\\\"\\n- with open(code_file, \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n- code = f.read()\\n- splits = code.split('\\\"\\\"\\\"')\\n+ Returns:\\n+ `Tuple[str, str]`: A tuple with the clean code and the black errors (if any)\\n+ \\\"\\\"\\\"\\n+ # fmt: off\\n+ splits = code.split('\\\\\\\"\\\\\\\"\\\\\\\"')\\n splits = [\\n (s if i % 2 == 0 or _re_doc_ignore.search(splits[i - 1]) is not None else style_docstring(s, max_len=max_len))\\n for i, s in enumerate(splits)\\n ]\\n- clean_code = '\\\"\\\"\\\"'.join(splits)\\n+ black_errors = \\\"\\\\n\\\\n\\\".join([s[1] for s in splits if isinstance(s, tuple) and len(s[1]) > 0])\\n+ splits = [s[0] if isinstance(s, tuple) else s for s in splits]\\n+ clean_code = '\\\\\\\"\\\\\\\"\\\\\\\"'.join(splits)\\n+ # fmt: on\\n+\\n+ return clean_code, black_errors\\n+\\n+\\n+def style_file_docstrings(code_file, max_len=119, check_only=False):\\n+ \\\"\\\"\\\"\\n+ Style all docstrings in a given file.\\n+\\n+ Args:\\n+ code_file (`str` or `os.PathLike`): The file in which we want to style the docstring.\\n+ max_len (`int`): The maximum number of characters per line.\\n+ check_only (`bool`, *optional*, defaults to `False`):\\n+ Whether to restyle file or just check if they should be restyled.\\n+\\n+ Returns:\\n+ `bool`: Whether or not the file was or should be restyled.\\n+ \\\"\\\"\\\"\\n+ with open(code_file, \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n+ code = f.read()\\n+\\n+ clean_code, black_errors = style_docstrings_in_code(code, max_len=max_len)\\n \\n diff = clean_code != code\\n if not check_only and diff:\\n@@ -479,31 +419,122 @@ def style_file_docstrings(code_file, max_len=119, check_only=False):\\n with open(code_file, \\\"w\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n f.write(clean_code)\\n \\n- return diff\\n+ return diff, black_errors\\n+\\n+\\n+def style_mdx_file(mdx_file, max_len=119, check_only=False):\\n+ \\\"\\\"\\\"\\n+ Style a MDX file by formatting all Python code samples.\\n+\\n+ Args:\\n+ mdx_file (`str` or `os.PathLike`): The file in which we want to style the examples.\\n+ max_len (`int`): The maximum number of characters per line.\\n+ check_only (`bool`, *optional*, defaults to `False`):\\n+ Whether to restyle file or just check if they should be restyled.\\n+\\n+ Returns:\\n+ `bool`: Whether or not the file was or should be restyled.\\n+ \\\"\\\"\\\"\\n+ with open(mdx_file, \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n+ content = f.read()\\n+\\n+ lines = content.split(\\\"\\\\n\\\")\\n+ current_code = []\\n+ current_language = \\\"\\\"\\n+ in_code = False\\n+ new_lines = []\\n+ black_errors = []\\n+\\n+ for line in lines:\\n+ if _re_code.search(line) is not None:\\n+ in_code = not in_code\\n+ if in_code:\\n+ current_language = _re_code.search(line).groups()[1]\\n+ current_code = []\\n+ else:\\n+ code = \\\"\\\\n\\\".join(current_code)\\n+ if current_language in [\\\"py\\\", \\\"python\\\"]:\\n+ code, error = format_code_example(code, max_len)\\n+ if len(error) > 0:\\n+ black_errors.append(error)\\n+ new_lines.append(code)\\n+\\n+ new_lines.append(line)\\n+ elif in_code:\\n+ current_code.append(line)\\n+ else:\\n+ new_lines.append(line)\\n+\\n+ if in_code:\\n+ raise ValueError(f\\\"There was a problem when styling {mdx_file}. A code block is opened without being closed.\\\")\\n+\\n+ clean_content = \\\"\\\\n\\\".join(new_lines)\\n+ diff = clean_content != content\\n+ if not check_only and diff:\\n+ print(f\\\"Overwriting content of {mdx_file}.\\\")\\n+ with open(mdx_file, \\\"w\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\") as f:\\n+ f.write(clean_content)\\n+\\n+ return diff, \\\"\\\\n\\\\n\\\".join(black_errors)\\n \\n \\n def style_doc_files(*files, max_len=119, check_only=False):\\n \\\"\\\"\\\"\\n- Style all `files` to `max_len` and fixes mistakes if not `check_only`, otherwise raises an error if styling should\\n- be done.\\n+ Applies doc styling or checks everything is correct in a list of files.\\n+\\n+ Args:\\n+ files (several `str` or `os.PathLike`): The files to treat.\\n+ max_len (`int`): The maximum number of characters per line.\\n+ check_only (`bool`, *optional*, defaults to `False`):\\n+ Whether to restyle file or just check if they should be restyled.\\n+\\n+ Returns:\\n+ List[`str`]: The list of files changed or that should be restyled.\\n \\\"\\\"\\\"\\n changed = []\\n+ black_errors = []\\n for file in files:\\n # Treat folders\\n if os.path.isdir(file):\\n files = [os.path.join(file, f) for f in os.listdir(file)]\\n- files = [f for f in files if os.path.isdir(f) or f.endswith(\\\".rst\\\") or f.endswith(\\\".py\\\")]\\n+ files = [f for f in files if os.path.isdir(f) or f.endswith(\\\".mdx\\\") or f.endswith(\\\".py\\\")]\\n changed += style_doc_files(*files, max_len=max_len, check_only=check_only)\\n- # Treat rst\\n- elif file.endswith(\\\".rst\\\"):\\n- if style_rst_file(file, max_len=max_len, check_only=check_only):\\n- changed.append(file)\\n+ # Treat mdx\\n+ elif file.endswith(\\\".mdx\\\"):\\n+ try:\\n+ diff, black_error = style_mdx_file(file, max_len=max_len, check_only=check_only)\\n+ if diff:\\n+ changed.append(file)\\n+ if len(black_error) > 0:\\n+ black_errors.append(\\n+ f\\\"There was a problem while formatting an example in {file} with black:\\\\m{black_error}\\\"\\n+ )\\n+ except Exception:\\n+ print(f\\\"There is a problem in {file}.\\\")\\n+ raise\\n # Treat python files\\n elif file.endswith(\\\".py\\\"):\\n- if style_file_docstrings(file, max_len=max_len, check_only=check_only):\\n- changed.append(file)\\n+ try:\\n+ diff, black_error = style_file_docstrings(file, max_len=max_len, check_only=check_only)\\n+ if diff:\\n+ changed.append(file)\\n+ if len(black_error) > 0:\\n+ black_errors.append(\\n+ f\\\"There was a problem while formatting an example in {file} with black:\\\\m{black_error}\\\"\\n+ )\\n+ except Exception:\\n+ print(f\\\"There is a problem in {file}.\\\")\\n+ raise\\n else:\\n- warnings.warn(f\\\"Ignoring {file} because it's not a py or an rst file or a folder.\\\")\\n+ warnings.warn(f\\\"Ignoring {file} because it's not a py or an mdx file or a folder.\\\")\\n+ if len(black_errors) > 0:\\n+ black_message = \\\"\\\\n\\\\n\\\".join(black_errors)\\n+ raise ValueError(\\n+ \\\"Some code examples can't be interpreted by black, which means they aren't regular python:\\\\n\\\\n\\\"\\n+ + black_message\\n+ + \\\"\\\\n\\\\nMake sure to fix the corresponding docstring or doc file, or remove the py/python after ``` if it \\\"\\n+ + \\\"was not supposed to be a Python code sample.\\\"\\n+ )\\n return changed\\n \\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"_The documentation is not available anymore as the PR was closed or merged._\",\n \"from_author\": false\n },\n {\n \"body\": \"Even if everything is pushed properly on `doc-build-dev`, there is nothing at https://moon-ci-docs.huggingface.co/docs/accelerate/pr_271. Guessing something needs to be activated on moon-landing @mishig25 ?\",\n \"from_author\": true\n },\n {\n \"body\": \"Indeed, there needs to be a small update on moon-landing side. More[ info here](https://huggingface.slack.com/archives/C02GLJ5S0E9/p1646780697260569?thread_ts=1646410559.029439&cid=C02GLJ5S0E9)\\r\\n<img width=\\\"1000\\\" alt=\\\"Screenshot 2022-03-09 at 00 02 02\\\" src=\\\"https://user-images.githubusercontent.com/11827707/157340774-6481b81c-e5ea-460c-a395-632aad53783c.png\\\">\\r\\n\",\n \"from_author\": false\n },\n {\n \"body\": \"I think `~` before `Accelerator` should not be there\\r\\n<img width=\\\"400\\\" alt=\\\"Screenshot 2022-03-09 at 00 06 33\\\" src=\\\"https://user-images.githubusercontent.com/11827707/157340963-a88cd88c-ac76-41aa-b1e2-71c6417f8130.png\\\">\\r\\n\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/271\",\n \"pr_id\": 874536042\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 1254c19e9..0fd2a5701 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -22,7 +22,7 @@\\n \\n from packaging import version\\n \\n-from .checkpointing import load_accelerator_state, save_accelerator_state\\n+from .checkpointing import load_accelerator_state, load_custom_state, save_accelerator_state, save_custom_state\\n from .data_loader import prepare_data_loader\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n@@ -33,6 +33,7 @@\\n convert_outputs_to_fp32,\\n extract_model_from_parallel,\\n gather,\\n+ get_pretty_name,\\n pad_across_processes,\\n save,\\n wait_for_everyone,\\n@@ -188,6 +189,7 @@ def __init__(\\n # Internal references to the training objects\\n self._optimizers = []\\n self._models = []\\n+ self._custom_objects = []\\n \\n # RNG Types\\n self.rng_types = rng_types\\n@@ -564,7 +566,7 @@ def save(self, obj, f):\\n \\n def save_state(self, output_dir: str):\\n \\\"\\\"\\\"\\n- Saves the current states of the model, optimizer, scaler, and RNG generators.\\n+ Saves the current states of the model, optimizer, scaler, RNG generators, and registered objects.\\n \\n Args:\\n output_dir (:obj:`str` or :obj:`os.PathLike`):\\n@@ -575,11 +577,16 @@ def save_state(self, output_dir: str):\\n os.makedirs(output_dir, exist_ok=True)\\n logger.info(f\\\"Saving current state to {output_dir}\\\")\\n weights = [self.get_state_dict(m) for m in self._models]\\n- return save_accelerator_state(output_dir, weights, self._optimizers, self.state.process_index, self.scaler)\\n+ save_location = save_accelerator_state(\\n+ output_dir, weights, self._optimizers, self.state.process_index, self.scaler\\n+ )\\n+ for i, obj in enumerate(self._custom_objects):\\n+ save_custom_state(obj, output_dir, i)\\n+ return save_location\\n \\n def load_state(self, input_dir: str):\\n \\\"\\\"\\\"\\n- Loads the current states of the model, optimizer, scaler, and RNG generators.\\n+ Loads the current states of the model, optimizer, scaler, RNG generators, and registered objects.\\n \\n Args:\\n input_dir (:obj:`str` or :obj:`os.PathLike`):\\n@@ -591,6 +598,16 @@ def load_state(self, input_dir: str):\\n raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n logger.info(f\\\"Loading states from {input_dir}\\\")\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+ custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n+ if len(custom_checkpoints) != len(self._custom_objects):\\n+ err = \\\"Warning! Number of found checkpoints does not match the number of registered objects:\\\"\\n+ err += f\\\"\\\\n\\\\tFound checkpoints: {len(custom_checkpoints)}\\\"\\n+ err += f\\\"\\\\n\\\\tRegistered objects: {len(self._custom_objects)}\\\\nSkipping.\\\"\\n+ logger.warn(err)\\n+ else:\\n+ logger.info(f\\\"Loading in {len(custom_checkpoints)} custom states\\\")\\n+ for index, obj in enumerate(self._custom_objects):\\n+ load_custom_state(obj, input_dir, index)\\n \\n def free_memory(self):\\n \\\"\\\"\\\"\\n@@ -646,6 +663,26 @@ def get_state_dict(self, model):\\n \\n return state_dict\\n \\n+ def register_for_checkpointing(self, *objects):\\n+ \\\"\\\"\\\"\\n+ Makes note of `objects` and will save or load them in during `save_state` or `load_state`.\\n+\\n+ These should be utilized when the state is being loaded or saved in the same script. It is not designed to be\\n+ used in different scripts\\n+\\n+ Note: Every `object` must have a `load_state_dict` and `state_dict` function to be stored.\\n+ \\\"\\\"\\\"\\n+ invalid_objects = []\\n+ for obj in objects:\\n+ if not hasattr(obj, \\\"state_dict\\\") or not hasattr(obj, \\\"load_state_dict\\\"):\\n+ invalid_objects.append(obj)\\n+ if len(invalid_objects) > 0:\\n+ err = \\\"All `objects` must include a `state_dict` and `load_state_dict` function to be stored. The following inputs are invalid:\\\"\\n+ for index, obj in enumerate(invalid_objects):\\n+ err += f\\\"\\\\n\\\\t- Item at index {index}, `{get_pretty_name(obj)}`\\\"\\n+ raise ValueError(err)\\n+ self._custom_objects.extend(objects)\\n+\\n @contextmanager\\n def autocast(self):\\n \\\"\\\"\\\"\\ndiff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nindex 37d68b90c..e1a28d108 100644\\n--- a/src/accelerate/checkpointing.py\\n+++ b/src/accelerate/checkpointing.py\\n@@ -14,6 +14,7 @@\\n \\n import os\\n import random\\n+from pathlib import Path\\n from typing import List\\n \\n import numpy as np\\n@@ -21,7 +22,7 @@\\n from torch.cuda.amp import GradScaler\\n \\n from .state import is_tpu_available\\n-from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, get_pretty_name, save\\n \\n \\n if is_tpu_available():\\n@@ -132,3 +133,22 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n if is_tpu_available():\\n xm.set_rng_state(states[\\\"xm_seed\\\"])\\n logger.info(\\\"All random states loaded successfully\\\")\\n+\\n+\\n+def save_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Saves the state of `obj` to `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ # Should this be the right way to get a qual_name type value from `obj`?\\n+ save_location = Path(path) / f\\\"custom_checkpoint_{index}.pkl\\\"\\n+ logger.info(f\\\"Saving the state of {get_pretty_name(obj)} to {save_location}\\\")\\n+ torch.save(obj.state_dict(), save_location)\\n+\\n+\\n+def load_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Loads the state of `obj` at `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ load_location = f\\\"{path}/custom_checkpoint_{index}.pkl\\\"\\n+ logger.info(f\\\"Loading the state of {get_pretty_name(obj)} from {load_location}\\\")\\n+ obj.load_state_dict(torch.load(load_location))\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 62b1291ee..4b20cc1c3 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -691,3 +691,16 @@ def patch_environment(**kwargs):\\n \\n for key in kwargs:\\n del os.environ[key.upper()]\\n+\\n+\\n+def get_pretty_name(obj):\\n+ \\\"\\\"\\\"\\n+ Gets a pretty name from ``obj``\\n+ \\\"\\\"\\\"\\n+ if not hasattr(obj, \\\"__qualname__\\\") and not hasattr(obj, \\\"__name__\\\"):\\n+ obj = getattr(obj, \\\"__class__\\\", obj)\\n+ if hasattr(obj, \\\"__qualname__\\\"):\\n+ return obj.__qualname__\\n+ if hasattr(obj, \\\"__name__\\\"):\\n+ return obj.__name__\\n+ return str(obj)\\ndiff --git a/tests/test_state_checkpointing.py b/tests/test_state_checkpointing.py\\nindex a74dcb724..87b2d3b06 100644\\n--- a/tests/test_state_checkpointing.py\\n+++ b/tests/test_state_checkpointing.py\\n@@ -43,13 +43,13 @@ def get_dataset(n_batches):\\n return (train_dataloader, valid_dataloader)\\n \\n \\n-def train(num_epochs, model, dataloader, optimizer, accelerator):\\n+def train(num_epochs, model, dataloader, optimizer, accelerator, scheduler=None):\\n \\\"Trains for `num_epochs`\\\"\\n rands = []\\n for epoch in range(num_epochs):\\n # Train quickly\\n model.train()\\n- for step, batch in enumerate(dataloader):\\n+ for batch in dataloader:\\n x, y = batch\\n outputs = model(x)\\n loss = torch.nn.functional.mse_loss(outputs, y)\\n@@ -57,6 +57,8 @@ def train(num_epochs, model, dataloader, optimizer, accelerator):\\n optimizer.step()\\n optimizer.zero_grad()\\n rands.append(random.random()) # Introduce some randomness\\n+ if scheduler is not None:\\n+ scheduler.step()\\n return rands\\n \\n \\n@@ -123,3 +125,41 @@ def test_can_resume_training(self):\\n self.assertEqual(b1, b3)\\n self.assertEqual(opt_state1, opt_state3)\\n self.assertEqual(ground_truth_rands, test_rands)\\n+\\n+ def test_invalid_registration(self):\\n+ t = torch.tensor([1, 2, 3])\\n+ t1 = torch.tensor([2, 3, 4])\\n+ net = DummyModel()\\n+ opt = torch.optim.Adam(net.parameters())\\n+ accelerator = Accelerator()\\n+ with self.assertRaises(ValueError) as ve:\\n+ accelerator.register_for_checkpointing(t, t1, net, opt)\\n+ message = str(ve.exception)\\n+ self.assertTrue(\\\"Item at index 0\\\" in message)\\n+ self.assertTrue(\\\"Item at index 1\\\" in message)\\n+ self.assertFalse(\\\"Item at index 2\\\" in message)\\n+ self.assertFalse(\\\"Item at index 3\\\" in message)\\n+\\n+ def test_with_scheduler(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.99)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator()\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ accelerator.register_for_checkpointing(scheduler)\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ scheduler_state = scheduler.state_dict()\\n+ train(3, model, train_dataloader, optimizer, accelerator, scheduler)\\n+ self.assertNotEqual(scheduler_state, scheduler.state_dict())\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(initial)\\n+ self.assertEqual(scheduler_state, scheduler.state_dict())\\n\",\n \"code_comments\": [\n {\n \"body\": \"Why the +1 here?\",\n \"diff_hunk\": \"@@ -591,6 +597,14 @@ def load_state(self, input_dir: str):\\n raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n logger.info(f\\\"Loading states from {input_dir}\\\")\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+ custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n+ if len(custom_checkpoints) != (len(self._custom_objects) + 1):\",\n \"from_author\": false\n },\n {\n \"body\": \"I would append them to the existing `_custom_objects`.\",\n \"diff_hunk\": \"@@ -646,6 +660,15 @@ def get_state_dict(self, model):\\n \\n return state_dict\\n \\n+ def register_for_checkpointing(self, *objects):\\n+ \\\"\\\"\\\"\\n+ Makes note of `objects` and will save or load them in during `save_state` or `load_state`.\\n+\\n+ Note: These should be utilized when the state is being loaded or saved in the same script. It is not designed\\n+ to be used in different scripts\\n+ \\\"\\\"\\\"\\n+ self._custom_objects = list(objects)\",\n \"from_author\": false\n },\n {\n \"body\": \"You should use a Path or `os.path.join` here otherwise it won't work in Windows.\",\n \"diff_hunk\": \"@@ -132,3 +132,27 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n if is_tpu_available():\\n xm.set_rng_state(states[\\\"xm_seed\\\"])\\n logger.info(\\\"All random states loaded successfully\\\")\\n+\\n+\\n+def save_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Saves the state of `obj` to `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ # Should this be the right way to get a qual_name type value from `obj`?\\n+ save_location = f\\\"{path}/custom_checkpoint_{index}.pkl\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"We don't need a torch.load inside here?\",\n \"diff_hunk\": \"@@ -132,3 +132,27 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n if is_tpu_available():\\n xm.set_rng_state(states[\\\"xm_seed\\\"])\\n logger.info(\\\"All random states loaded successfully\\\")\\n+\\n+\\n+def save_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Saves the state of `obj` to `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ # Should this be the right way to get a qual_name type value from `obj`?\\n+ save_location = f\\\"{path}/custom_checkpoint_{index}.pkl\\\"\\n+ logger.info(f\\\"Saving the state of {str(obj)} to {save_location}\\\")\\n+ if hasattr(obj, \\\"state_dict\\\"):\\n+ obj = obj.state_dict()\\n+ torch.save(obj, save_location)\\n+\\n+\\n+def load_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Loads the state of `obj` at `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ load_location = f\\\"{path}/custom_checkpoint_{index}.pkl\\\"\\n+ if hasattr(obj, \\\"load_state_dict\\\"):\\n+ obj = obj.load_state_dict(load_location)\",\n \"from_author\": false\n },\n {\n \"body\": \"For the custom objects + the saved objected was my thought at the time. But you're write its a bug\",\n \"diff_hunk\": \"@@ -591,6 +597,14 @@ def load_state(self, input_dir: str):\\n raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n logger.info(f\\\"Loading states from {input_dir}\\\")\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+ custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n+ if len(custom_checkpoints) != (len(self._custom_objects) + 1):\",\n \"from_author\": true\n },\n {\n \"body\": \"The warning message does not match what the test is testing :-)\",\n \"diff_hunk\": \"@@ -591,6 +598,13 @@ def load_state(self, input_dir: str):\\n raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n logger.info(f\\\"Loading states from {input_dir}\\\")\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+ custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n+ if len(custom_checkpoints) != len(self._custom_objects):\\n+ logger.warn(\\\"Warning! You are loading a state that does not include registered objects.\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"This is not a proper docstring **but** it will be once #271 is merged, so giving you a free pass ;-)\",\n \"diff_hunk\": \"@@ -646,6 +660,26 @@ def get_state_dict(self, model):\\n \\n return state_dict\\n \\n+ def register_for_checkpointing(self, *objects):\\n+ \\\"\\\"\\\"\\n+ Makes note of `objects` and will save or load them in during `save_state` or `load_state`.\\n+\\n+ These should be utilized when the state is being loaded or saved in the same script. It is not designed to be\\n+ used in different scripts\\n+\\n+ Note: Every `object` must have a `load_state_dict` and `state_dict` function to be stored.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n torch.save(obj.state_dict(), save_location)\\r\\n```\\r\\nCan be combined now.\",\n \"diff_hunk\": \"@@ -132,3 +133,23 @@ def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=\\n if is_tpu_available():\\n xm.set_rng_state(states[\\\"xm_seed\\\"])\\n logger.info(\\\"All random states loaded successfully\\\")\\n+\\n+\\n+def save_custom_state(obj, path, index: int = 0):\\n+ \\\"\\\"\\\"\\n+ Saves the state of `obj` to `{path}/custom_checkpoint_{index}.pkl`\\n+ \\\"\\\"\\\"\\n+ # Should this be the right way to get a qual_name type value from `obj`?\\n+ save_location = Path(path) / f\\\"custom_checkpoint_{index}.pkl\\\"\\n+ logger.info(f\\\"Saving the state of {get_pretty_name(obj)} to {save_location}\\\")\\n+ obj = obj.state_dict()\\n+ torch.save(obj, save_location)\",\n \"from_author\": false\n },\n {\n \"body\": \"Not sure we need a new class for this. Can be included in the current one!\",\n \"diff_hunk\": \"@@ -123,3 +125,43 @@ def test_can_resume_training(self):\\n self.assertEqual(b1, b3)\\n self.assertEqual(opt_state1, opt_state3)\\n self.assertEqual(ground_truth_rands, test_rands)\\n+\\n+\\n+class CustomItemsTest(unittest.TestCase):\",\n \"from_author\": false\n },\n {\n \"body\": \"Can you print the two numbers?\",\n \"diff_hunk\": \"@@ -600,7 +600,9 @@ def load_state(self, input_dir: str):\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n if len(custom_checkpoints) != len(self._custom_objects):\\n- logger.warn(\\\"Warning! You are loading a state that does not include registered objects.\\\")\\n+ logger.warn(\\n+ \\\"Warning! Number of found checkpoints does not match the number of registered objects. Skipping.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"How does \\r\\n```python\\r\\n err = \\\"Warning! Number of found checkpoints does not match the number of registered objects:\\\"\\r\\n err += f\\\"\\\\n\\\\tFound checkpoints: {len(custom_checkpoints)}\\\"\\r\\n err += f\\\"\\\\n\\\\tRegistered objects: {len(self._custom_objects)}\\\\nSkipping.\\\"\\r\\n```\\r\\nSound?\",\n \"diff_hunk\": \"@@ -600,7 +600,9 @@ def load_state(self, input_dir: str):\\n load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n custom_checkpoints = [f for f in os.listdir(input_dir) if \\\"custom_checkpoint\\\" in f]\\n if len(custom_checkpoints) != len(self._custom_objects):\\n- logger.warn(\\\"Warning! You are loading a state that does not include registered objects.\\\")\\n+ logger.warn(\\n+ \\\"Warning! Number of found checkpoints does not match the number of registered objects. Skipping.\\\"\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/270\",\n \"pr_id\": 873453450\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 1254c19e9..f59d3e8bd 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -166,6 +166,10 @@ def __init__(\\n self.device_placement = device_placement\\n self.split_batches = split_batches\\n self.dispatch_batches = dispatch_batches\\n+ if dispatch_batches is True and version.parse(torch.__version__) < version.parse(\\\"1.8.0\\\"):\\n+ raise ImportError(\\n+ \\\"Using `DataLoaderDispatcher` requires PyTorch 1.8.0 minimum. You have {torch.__version__}.\\\"\\n+ )\\n \\n # Mixed precision attributes\\n self.scaler = None\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex b28f24fc6..cc46e5577 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -328,6 +328,10 @@ class DataLoaderDispatcher(DataLoader):\\n def __init__(self, dataset, split_batches: bool = False, **kwargs):\\n super().__init__(dataset, **kwargs)\\n self.split_batches = split_batches\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.8.0\\\"):\\n+ raise ImportError(\\n+ \\\"Using `DataLoaderDispatcher` requires PyTorch 1.8.0 minimum. You have {torch.__version__}.\\\"\\n+ )\\n \\n def __iter__(self):\\n state = AcceleratorState()\\n@@ -474,7 +478,10 @@ def prepare_data_loader(\\n This does not support :obj:`BatchSampler` with varying batch size yet.\\n \\\"\\\"\\\"\\n if dispatch_batches is None:\\n- dispatch_batches = False if not put_on_device else isinstance(dataloader.dataset, IterableDataset)\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.8.0\\\") or not put_on_device:\\n+ dispatch_batches = False\\n+ else:\\n+ dispatch_batches = isinstance(dataloader.dataset, IterableDataset)\\n \\n if dispatch_batches and not put_on_device:\\n raise ValueError(\\\"Using `dispatch_batches=True` requires `put_on_device=True`.\\\")\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/269\",\n \"pr_id\": 873301616\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 2d9937642..62b1291ee 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -63,13 +63,16 @@ class TensorInformation:\\n dtype: torch.dtype\\n \\n \\n-def set_seed(seed: int):\\n+def set_seed(seed: int, device_specific: bool = False):\\n \\\"\\\"\\\"\\n Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch``.\\n \\n Args:\\n seed (:obj:`int`): The seed to set.\\n+ device_specific (:obj:`bool`, `optional`, defaults to :obj:`False`): Whether to differ the seed on each device slightly with `self.process_index`\\n \\\"\\\"\\\"\\n+ if device_specific:\\n+ seed += AcceleratorState().process_index\\n random.seed(seed)\\n np.random.seed(seed)\\n torch.manual_seed(seed)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n device_specific (:obj:`bool`, `optional`, defaults to :obj:`False`): Whether to differ the seed on each device slightly with `self.process_index`\\r\\n```\",\n \"diff_hunk\": \"@@ -63,13 +63,16 @@ class TensorInformation:\\n dtype: torch.dtype\\n \\n \\n-def set_seed(seed: int):\\n+def set_seed(seed: int, device_specific: bool = False):\\n \\\"\\\"\\\"\\n Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch``.\\n \\n Args:\\n seed (:obj:`int`): The seed to set.\\n+ device_specific (:obj:`bool`): Whether to differ the seed on each device slightly with `self.process_index`\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/266\",\n \"pr_id\": 869844938\n },\n {\n \"diff\": \"diff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex a029acfae..e8c910e19 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -256,11 +256,6 @@ def __init__(\\n \\n def __repr__(self):\\n mixed_precision = self.mixed_precision\\n- if self.distributed_type == DistributedType.DEEPSPEED:\\n- if self.deepspeed_plugin.fp16:\\n- mixed_precision = \\\"fp16\\\"\\n- if self.deepspeed_plugin.bflaot16:\\n- mixed_precision = \\\"bf16\\\"\\n \\n repr = (\\n f\\\"Distributed environment: {self.distributed_type}{(' Backend: ' + self.backend) if self.backend else ''}\\\\n\\\"\\n@@ -271,5 +266,5 @@ def __repr__(self):\\n f\\\"Mixed precision type: {mixed_precision}\\\\n\\\"\\n )\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- repr += f\\\"ds_config: {self.deepspeed_plugin.ds_config}\\\\n\\\"\\n+ repr += f\\\"ds_config: {self.deepspeed_plugin.deepspeed_config}\\\\n\\\"\\n return repr\\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex ecd8e4f02..f9a99e22f 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -59,6 +59,8 @@ def dl_preparation_check():\\n for batch in dl:\\n result.append(gather(batch))\\n result = torch.cat(result)\\n+\\n+ print(state.process_index, result, type(dl))\\n assert torch.equal(result.cpu(), torch.arange(0, length).long()), \\\"Wrong non-shuffled dataloader result.\\\"\\n \\n dl = DataLoader(range(length), batch_size=8)\\n@@ -327,6 +329,10 @@ def main():\\n dl_preparation_check()\\n central_dl_preparation_check()\\n \\n+ # Trainings are not exactly the same in DeepSpeed and CPU mode\\n+ if state.distributed_type == DistributedType.DEEPSPEED:\\n+ return\\n+\\n if state.local_process_index == 0:\\n print(\\\"\\\\n**Training integration test**\\\")\\n training_check()\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 83a40bf86..de5978802 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -91,7 +91,7 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona\\n state = AcceleratorState()\\n if state.distributed_type == DistributedType.TPU:\\n rng_state = xm.mesh_reduce(\\\"random_seed\\\", rng_state, lambda x: x[0])\\n- elif state.distributed_type == DistributedType.MULTI_GPU:\\n+ elif state.distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n rng_state = rng_state.to(state.device)\\n torch.distributed.broadcast(rng_state, 0)\\n rng_state = rng_state.cpu()\\n@@ -343,7 +343,7 @@ def gather(tensor):\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n return _tpu_gather(tensor, name=\\\"accelerate.utils.gather\\\")\\n- elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ elif AcceleratorState().distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n return _gpu_gather(tensor)\\n elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n return _cpu_gather(tensor)\\n@@ -376,7 +376,7 @@ def gather_object(object: Any):\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n raise NotImplementedError(\\\"gather objects in TPU is not supported\\\")\\n- elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ elif AcceleratorState().distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n return _gpu_gather_object(object)\\n elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n return _cpu_gather_object(object)\\n@@ -415,7 +415,7 @@ def broadcast(tensor, from_process: int = 0):\\n \\\"\\\"\\\"\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n return _tpu_broadcast(tensor, src=from_process, name=\\\"accelerate.utils.broadcast\\\")\\n- elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ elif AcceleratorState().distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n return _gpu_broadcast(tensor, src=from_process)\\n elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n return _gpu_broadcast(tensor, src=from_process)\\n@@ -439,7 +439,7 @@ def broadcast_object_list(object_list, from_process: int = 0):\\n if AcceleratorState().distributed_type == DistributedType.TPU:\\n for i, obj in enumerate(object_list):\\n object_list[i] = xm.mesh_reduce(\\\"accelerate.utils.broadcast_object_list\\\", obj, lambda x: x[from_process])\\n- elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ elif AcceleratorState().distributed_type in [DistributedType.DEEPSPEED, DistributedType.MULTI_GPU]:\\n torch.distributed.broadcast_object_list(object_list, src=from_process)\\n elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n torch.distributed.broadcast_object_list(object_list, src=from_process)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/264\",\n \"pr_id\": 868226627\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex 534ea1526..15eaaecb6 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -52,6 +52,17 @@ def get_cluster_input():\\n lambda x: int(x),\\n )\\n \\n+ if distributed_type == DistributedType.NO:\\n+ use_cpu = _ask_field(\\n+ \\\"Do you want to run your training on CPU only (even if a GPU is available)? [no]:\\\",\\n+ lambda x: bool(x),\\n+ default=False,\\n+ )\\n+ elif distributed_type == DistributedType.MULTI_CPU:\\n+ use_cpu = True\\n+ else:\\n+ use_cpu = False\\n+\\n deepspeed_config = None\\n if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n use_deepspeed = _ask_field(\\n@@ -122,4 +133,5 @@ def get_cluster_input():\\n main_process_port=main_process_port,\\n main_training_function=main_training_function,\\n deepspeed_config=deepspeed_config,\\n+ use_cpu=use_cpu,\\n )\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 891580ab5..5af912fc3 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -67,6 +67,7 @@ class BaseConfig:\\n compute_environment: ComputeEnvironment\\n distributed_type: Union[DistributedType, SageMakerDistributedType]\\n mixed_precision: str\\n+ use_cpu: bool\\n \\n def to_dict(self):\\n result = self.__dict__\\n@@ -87,6 +88,8 @@ def from_json_file(cls, json_file=None):\\n config_dict[\\\"mixed_precision\\\"] = \\\"fp16\\\" if (\\\"fp16\\\" in config_dict and config_dict[\\\"fp16\\\"]) else \\\"no\\\"\\n if \\\"fp16\\\" in config_dict: # Convert the config to the new format.\\n del config_dict[\\\"fp16\\\"]\\n+ if \\\"use_cpu\\\" not in config_dict:\\n+ config_dict[\\\"use_cpu\\\"] = False\\n return cls(**config_dict)\\n \\n def to_json_file(self, json_file):\\n@@ -106,6 +109,8 @@ def from_yaml_file(cls, yaml_file=None):\\n config_dict[\\\"mixed_precision\\\"] = \\\"fp16\\\" if (\\\"fp16\\\" in config_dict and config_dict[\\\"fp16\\\"]) else \\\"no\\\"\\n if \\\"fp16\\\" in config_dict: # Convert the config to the new format.\\n del config_dict[\\\"fp16\\\"]\\n+ if \\\"use_cpu\\\" not in config_dict:\\n+ config_dict[\\\"use_cpu\\\"] = False\\n \\n return cls(**config_dict)\\n \\ndiff --git a/src/accelerate/launchers.py b/src/accelerate/launchers.py\\nindex a8429db96..a47eb9a4c 100644\\n--- a/src/accelerate/launchers.py\\n+++ b/src/accelerate/launchers.py\\n@@ -171,6 +171,7 @@ def debug_launcher(function, args=(), num_processes=2):\\n master_port=\\\"29500\\\",\\n mixed_precision=\\\"no\\\",\\n accelerate_debug_rdv_file=tmp_file.name,\\n+ use_cpu=\\\"yes\\\",\\n ):\\n launcher = PrepareForLaunch(function, debug=True)\\n start_processes(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 59aebef2d..a029acfae 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -153,6 +153,8 @@ def __init__(\\n **kwargs,\\n ):\\n self.__dict__ = self._shared_state\\n+ if parse_flag_from_env(\\\"USE_CPU\\\"):\\n+ cpu = True\\n if not getattr(self, \\\"initialized\\\", False):\\n self.backend = None\\n self.deepspeed_plugin = None\\n@@ -217,14 +219,7 @@ def __init__(\\n rank = get_int_from_env([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n size = get_int_from_env([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n local_rank = get_int_from_env(\\n- [\\n- \\\"LOCAL_RANK\\\",\\n- \\\"CPU_LOCAL_RANK\\\",\\n- \\\"MPI_LOCALRANKID\\\",\\n- \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\",\\n- \\\"MV2_COMM_WORLD_LOCAL_RANK\\\",\\n- ],\\n- 0,\\n+ [\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0\\n )\\n local_size = get_int_from_env(\\n [\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 6eba4b295..83a40bf86 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -614,8 +614,6 @@ def __call__(self, index, *args):\\n store=torch.distributed.FileStore(rdv_file, world_size),\\n world_size=world_size,\\n )\\n- # Prepare the environment for torch.distributed\\n- os.environ[\\\"CPU_LOCAL_RANK\\\"] = str(index)\\n elif self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n # Prepare the environment for torch.distributed\\n os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/263\",\n \"pr_id\": 868155001\n },\n {\n \"diff\": \"diff --git a/src/accelerate/__init__.py b/src/accelerate/__init__.py\\nindex e0b96cd10..f77a26a56 100644\\n--- a/src/accelerate/__init__.py\\n+++ b/src/accelerate/__init__.py\\n@@ -6,6 +6,6 @@\\n \\n from .accelerator import Accelerator\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs\\n-from .notebook_launcher import notebook_launcher\\n+from .launchers import debug_launcher, notebook_launcher\\n from .state import DistributedType\\n from .utils import DeepSpeedPlugin, synchronize_rng_states\\ndiff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/launchers.py\\nsimilarity index 75%\\nrename from src/accelerate/notebook_launcher.py\\nrename to src/accelerate/launchers.py\\nindex 90b4f826a..a8429db96 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/launchers.py\\n@@ -14,6 +14,7 @@\\n \\n import os\\n import sys\\n+import tempfile\\n import warnings\\n \\n import torch\\n@@ -21,7 +22,7 @@\\n from packaging import version\\n \\n from .state import AcceleratorState\\n-from .utils import PrepareForLaunch\\n+from .utils import PrepareForLaunch, patch_environment\\n \\n \\n def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mixed_precision=\\\"no\\\", use_port=\\\"29500\\\"):\\n@@ -106,12 +107,6 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mix\\n \\\"function.\\\"\\n )\\n \\n- # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n- # process here (the other ones will be set be the launcher).\\n- os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n- os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n- os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\n-\\n mixed_precision = mixed_precision.lower()\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n raise ValueError(\\n@@ -122,17 +117,15 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mix\\n warnings.warn('use_fp16=True is deprecated. Use mixed_precision=\\\"fp16\\\" instead.', DeprecationWarning)\\n mixed_precision = \\\"fp16\\\"\\n \\n- os.environ[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ with patch_environment(\\n+ world_size=num_processes, master_addr=\\\"127.0.01\\\", master_port=use_port, mixed_precision=mixed_precision\\n+ ):\\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n \\n- launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n- try:\\n print(f\\\"Launching training on {num_processes} GPUs.\\\")\\n start_processes(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n- finally:\\n- # Clean up the environment variables set.\\n- del os.environ[\\\"WORLD_SIZE\\\"]\\n- del os.environ[\\\"MASTER_ADDR\\\"]\\n- del os.environ[\\\"MASTER_PORT\\\"]\\n \\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n@@ -141,3 +134,43 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mix\\n else:\\n print(\\\"Launching training on CPU.\\\")\\n function(*args)\\n+\\n+\\n+def debug_launcher(function, args=(), num_processes=2):\\n+ \\\"\\\"\\\"\\n+ Launches a training function using several processes on CPU for debugging purposes.\\n+\\n+ .. warning::\\n+\\n+ This function is provided for internal testing and debugging, but it's not intended for real trainings. It will\\n+ only use the CPU.\\n+\\n+\\n+ Args:\\n+ function (:obj:`Callable`):\\n+ The training function to execute.\\n+ args (:obj:`Tuple`):\\n+ Tuple of arguments to pass to the function (it will receive :obj:`*args`).\\n+ num_processes (:obj:`int`, *optional*, defaults to 2):\\n+ The number of processes to use for training.\\n+ \\\"\\\"\\\"\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.5.0\\\"):\\n+ raise ImportError(\\n+ \\\"Using `debug_launcher` for distributed training on GPUs require torch >= 1.5.0, got \\\"\\n+ f\\\"{torch.__version__}.\\\"\\n+ )\\n+\\n+ from torch.multiprocessing import start_processes\\n+\\n+ with tempfile.NamedTemporaryFile() as tmp_file:\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ with patch_environment(\\n+ world_size=num_processes,\\n+ master_addr=\\\"127.0.01\\\",\\n+ master_port=\\\"29500\\\",\\n+ mixed_precision=\\\"no\\\",\\n+ accelerate_debug_rdv_file=tmp_file.name,\\n+ ):\\n+ launcher = PrepareForLaunch(function, debug=True)\\n+ start_processes(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 6693a34ca..59aebef2d 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -217,7 +217,14 @@ def __init__(\\n rank = get_int_from_env([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n size = get_int_from_env([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n local_rank = get_int_from_env(\\n- [\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0\\n+ [\\n+ \\\"LOCAL_RANK\\\",\\n+ \\\"CPU_LOCAL_RANK\\\",\\n+ \\\"MPI_LOCALRANKID\\\",\\n+ \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\",\\n+ \\\"MV2_COMM_WORLD_LOCAL_RANK\\\",\\n+ ],\\n+ 0,\\n )\\n local_size = get_int_from_env(\\n [\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 36eaea592..443c55622 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -16,6 +16,7 @@\\n import os\\n import random\\n from collections.abc import Mapping\\n+from contextlib import contextmanager\\n from dataclasses import dataclass, field\\n from enum import Enum\\n from typing import Any, List, Optional, Union\\n@@ -594,14 +595,28 @@ class PrepareForLaunch:\\n The function to launch.\\n distributed_type (:class:`~accelerate.state.DistributedType`):\\n The distributed type to prepare for.\\n+ debug (:obj:`bool`, *optional*, defaults to :obj:`False`):\\n+ Whether or not this is a debug launch.\\n \\\"\\\"\\\"\\n \\n- def __init__(self, launcher, distributed_type=\\\"NO\\\"):\\n+ def __init__(self, launcher, distributed_type=\\\"NO\\\", debug=False):\\n self.launcher = launcher\\n self.distributed_type = DistributedType(distributed_type)\\n+ self.debug = debug\\n \\n def __call__(self, index, *args):\\n- if self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n+ if self.debug:\\n+ world_size = int(os.environ.get(\\\"WORLD_SIZE\\\"))\\n+ rdv_file = os.environ.get(\\\"ACCELERATE_DEBUG_RDV_FILE\\\")\\n+ torch.distributed.init_process_group(\\n+ \\\"gloo\\\",\\n+ rank=index,\\n+ store=torch.distributed.FileStore(rdv_file, world_size),\\n+ world_size=world_size,\\n+ )\\n+ # Prepare the environment for torch.distributed\\n+ os.environ[\\\"CPU_LOCAL_RANK\\\"] = str(index)\\n+ elif self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n # Prepare the environment for torch.distributed\\n os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n os.environ[\\\"RANK\\\"] = str(index)\\n@@ -654,3 +669,19 @@ def __post_init__(self):\\n \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n \\\"zero_allow_untested_optimizer\\\": True,\\n }\\n+\\n+\\n+@contextmanager\\n+def patch_environment(**kwargs):\\n+ \\\"\\\"\\\"\\n+ A context manager that will add each keyword argument passed to ``os.environ`` and remove them when exiting.\\n+\\n+ Will convert the values in :obj:`kwargs` to strings and upper-case all the keys.\\n+ \\\"\\\"\\\"\\n+ for key, value in kwargs.items():\\n+ os.environ[key.upper()] = str(value)\\n+\\n+ yield\\n+\\n+ for key in kwargs:\\n+ del os.environ[key.upper()]\\ndiff --git a/tests/test_cpu.py b/tests/test_cpu.py\\nnew file mode 100644\\nindex 000000000..72a8b2e7d\\n--- /dev/null\\n+++ b/tests/test_cpu.py\\n@@ -0,0 +1,23 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+\\n+from accelerate import debug_launcher\\n+from accelerate.test_utils import test_script\\n+\\n+\\n+class MultiTPUTester(unittest.TestCase):\\n+ def test_cpu(self):\\n+ debug_launcher(test_script.main)\\ndiff --git a/tests/test_utils.py b/tests/test_utils.py\\nindex e515df8fe..a31c45d31 100644\\n--- a/tests/test_utils.py\\n+++ b/tests/test_utils.py\\n@@ -12,12 +12,13 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import os\\n import unittest\\n from collections import UserDict, namedtuple\\n \\n import torch\\n \\n-from accelerate.utils import send_to_device\\n+from accelerate.utils import patch_environment, send_to_device\\n \\n \\n TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b c\\\")\\n@@ -62,3 +63,11 @@ def test_send_to_device(self):\\n self.assertTrue(torch.equal(result4[\\\"b\\\"][0].cpu(), tensor))\\n self.assertTrue(torch.equal(result4[\\\"b\\\"][1].cpu(), tensor))\\n self.assertEqual(result4[\\\"c\\\"], 1)\\n+\\n+ def test_patch_environment(self):\\n+ with patch_environment(aa=1, BB=2):\\n+ self.assertEqual(os.environ.get(\\\"AA\\\"), \\\"1\\\")\\n+ self.assertEqual(os.environ.get(\\\"BB\\\"), \\\"2\\\")\\n+\\n+ self.assertNotIn(\\\"AA\\\", os.environ)\\n+ self.assertNotIn(\\\"BB\\\", os.environ)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/259\",\n \"pr_id\": 862497675\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 77db4546b..ff1b148f4 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -92,6 +92,17 @@ def launch_command_parser(subparsers=None):\\n default=None,\\n help=\\\"The name of the main function to be executed in your script (only for TPU training).\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"-m\\\",\\n+ \\\"--module\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Change each process to interpret the launch script as a Python module, executing with the same behavior as 'python -m'.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--no_python\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.\\\",\\n+ )\\n parser.add_argument(\\n \\\"--aws_access_key_id\\\",\\n type=str,\\n@@ -140,7 +151,14 @@ def launch_command_parser(subparsers=None):\\n \\n \\n def simple_launcher(args):\\n- cmd = [sys.executable, args.training_script]\\n+ cmd = []\\n+ if args.no_python and args.module:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ if not args.no_python:\\n+ cmd.append(sys.executable)\\n+ if args.module:\\n+ cmd.append(\\\"-m\\\")\\n+ cmd.append(args.training_script)\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n@@ -163,8 +181,7 @@ def simple_launcher(args):\\n \\n \\n def multi_gpu_launcher(args):\\n- cmd = [sys.executable, \\\"-m\\\", \\\"torch.distributed.launch\\\"]\\n- cmd.extend([\\\"--use_env\\\"])\\n+ cmd = [sys.executable, \\\"-m\\\", \\\"torch.distributed.launch\\\", \\\"--use_env\\\"]\\n if args.num_machines > 1:\\n cmd.extend(\\n [\\n@@ -184,6 +201,13 @@ def multi_gpu_launcher(args):\\n cmd.extend([\\\"--nproc_per_node\\\", str(args.num_processes)])\\n if args.main_process_port is not None:\\n cmd.extend([\\\"--master_port\\\", str(args.main_process_port)])\\n+\\n+ if args.module and args.no_python:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ elif args.module:\\n+ cmd.append(\\\"--module\\\")\\n+ elif args.no_python:\\n+ cmd.append(\\\"--no_python\\\")\\n cmd.append(args.training_script)\\n cmd.extend(args.training_script_args)\\n \\n@@ -206,7 +230,6 @@ def multi_gpu_launcher(args):\\n \\n \\n def deepspeed_launcher(args):\\n-\\n cmd = [\\\"deepspeed\\\"]\\n if args.num_machines > 1:\\n cmd.extend(\\n@@ -226,6 +249,12 @@ def deepspeed_launcher(args):\\n else:\\n cmd.extend([\\\"--num_gpus\\\", str(args.num_processes)])\\n \\n+ if args.module and args.no_python:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ elif args.module:\\n+ cmd.append(\\\"--module\\\")\\n+ elif args.no_python:\\n+ cmd.append(\\\"--no_python\\\")\\n cmd.append(args.training_script)\\n cmd.extend(args.training_script_args)\\n \\n@@ -254,21 +283,28 @@ def deepspeed_launcher(args):\\n def tpu_launcher(args):\\n import torch_xla.distributed.xla_multiprocessing as xmp\\n \\n- # Import training_script as a module.\\n- script_path = Path(args.training_script)\\n- sys.path.append(str(script_path.parent.resolve()))\\n- mod_name = script_path.stem\\n+ if args.no_python:\\n+ raise ValueError(\\\"--no_python cannot be used with TPU launcher\\\")\\n+\\n+ if args.module:\\n+ mod_name = args.training_script\\n+ else:\\n+ # Import training_script as a module\\n+ script_path = Path(args.training_script)\\n+ sys.path.append(str(script_path.parent.resolve()))\\n+ mod_name = script_path.stem\\n+\\n mod = importlib.import_module(mod_name)\\n if not hasattr(mod, args.main_training_function):\\n raise ValueError(\\n f\\\"Your training script should have a function named {args.main_training_function}, or you should pass a \\\"\\n \\\"different value to `--main_training_function`.\\\"\\n )\\n- main_function = getattr(mod, args.main_training_function)\\n \\n # Patch sys.argv\\n- sys.argv = [args.training_script] + args.training_script_args\\n+ sys.argv = [mod.__file__] + args.training_script_args\\n \\n+ main_function = getattr(mod, args.main_training_function)\\n xmp.spawn(PrepareForLaunch(main_function), args=(), nprocs=args.num_processes)\\n \\n \\n@@ -319,6 +355,11 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n raise ImportError(\\n \\\"Please install sagemaker to be able to launch training on Amazon SageMaker with `pip install accelerate[sagemaker]`\\\"\\n )\\n+ if args.module or args.no_python:\\n+ raise ValueError(\\n+ \\\"SageMaker requires a python training script file and cannot be used with --module or --no_python\\\"\\n+ )\\n+\\n from sagemaker.huggingface import HuggingFace\\n \\n # configure environment\\n\",\n \"code_comments\": [\n {\n \"body\": \"Since both can't be true at the same time, the test should not be nested.\\r\\n```suggestion\\r\\n elif args.module:\\r\\n cmd.append(\\\"-m\\\")\\r\\n```\",\n \"diff_hunk\": \"@@ -140,7 +151,14 @@ def launch_command_parser(subparsers=None):\\n \\n \\n def simple_launcher(args):\\n- cmd = [sys.executable, args.training_script]\\n+ cmd = []\\n+ if args.no_python and args.module:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ if not args.no_python:\\n+ cmd.append(sys.executable)\\n+ if args.module:\\n+ cmd.append(\\\"-m\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n elif args.module:\\r\\n cmd.append(\\\"--module\\\")\\r\\n elif args.no_python:\\r\\n```\",\n \"diff_hunk\": \"@@ -184,6 +201,13 @@ def multi_gpu_launcher(args):\\n cmd.extend([\\\"--nproc_per_node\\\", str(args.num_processes)])\\n if args.main_process_port is not None:\\n cmd.extend([\\\"--master_port\\\", str(args.main_process_port)])\\n+\\n+ if args.module and args.no_python:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ if args.module:\\n+ cmd.append(\\\"--module\\\")\\n+ if args.no_python:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if args.module and args.no_python:\\r\\n raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\r\\n elif args.module:\\r\\n cmd.append(\\\"--module\\\")\\r\\n elif args.no_python:\\r\\n```\",\n \"diff_hunk\": \"@@ -226,6 +249,12 @@ def deepspeed_launcher(args):\\n else:\\n cmd.extend([\\\"--num_gpus\\\", str(args.num_processes)])\\n \\n+ if args.module and args.no_python:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ if args.module:\\n+ cmd.append(\\\"--module\\\")\\n+ if args.no_python:\",\n \"from_author\": false\n },\n {\n \"body\": \"Good catch, thanks. I think after the un-indent, it still has to stay an `if` and not an `elif`, otherwise it won't get evaluated because the `if not args.no_python` above would always be evaluated `True` first.\\r\\n\\r\\n```suggestion\\r\\n if args.module:\\r\\n cmd.append(\\\"-m\\\")\\r\\n```\",\n \"diff_hunk\": \"@@ -140,7 +151,14 @@ def launch_command_parser(subparsers=None):\\n \\n \\n def simple_launcher(args):\\n- cmd = [sys.executable, args.training_script]\\n+ cmd = []\\n+ if args.no_python and args.module:\\n+ raise ValueError(\\\"--module and --no_python cannot be used together\\\")\\n+ if not args.no_python:\\n+ cmd.append(sys.executable)\\n+ if args.module:\\n+ cmd.append(\\\"-m\\\")\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"Thanks again for working on this!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/258\",\n \"pr_id\": 861047307\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex b841bc809..1254c19e9 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -22,6 +22,7 @@\\n \\n from packaging import version\\n \\n+from .checkpointing import load_accelerator_state, save_accelerator_state\\n from .data_loader import prepare_data_loader\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n@@ -40,6 +41,7 @@\\n \\n if is_deepspeed_available():\\n import deepspeed\\n+\\n from .deepspeed_utils import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper\\n \\n import logging\\n@@ -560,6 +562,36 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scaler, and RNG generators.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+ weights = [self.get_state_dict(m) for m in self._models]\\n+ return save_accelerator_state(output_dir, weights, self._optimizers, self.state.process_index, self.scaler)\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scaler, and RNG generators.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder all relevant weights and states were saved in.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ input_dir = os.path.expanduser(input_dir)\\n+ if not os.path.isdir(input_dir):\\n+ raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n+ logger.info(f\\\"Loading states from {input_dir}\\\")\\n+ load_accelerator_state(input_dir, self._models, self._optimizers, self.state.process_index, self.scaler)\\n+\\n def free_memory(self):\\n \\\"\\\"\\\"\\n Will release all references to the internal objects stored and call the garbage collector. You should call this\\ndiff --git a/src/accelerate/checkpointing.py b/src/accelerate/checkpointing.py\\nnew file mode 100644\\nindex 000000000..37d68b90c\\n--- /dev/null\\n+++ b/src/accelerate/checkpointing.py\\n@@ -0,0 +1,134 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the models, optimizers, scaler, and RNG generators to a given directory.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`List[torch.nn.Module]`):\\n+ A list of model states\\n+ optimizers (:obj:`List[torch.optim.Optimizer]`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`torch.cuda.amp.GradScaler`, `optional`):\\n+ An optional gradient scaler instance to save\\n+ \\\"\\\"\\\"\\n+ # Model states\\n+ for i, state in enumerate(model_states):\\n+ weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScaler state\\n+ if scaler is not None:\\n+ state = scaler.state_dict()\\n+ output_scaler_file = os.path.join(output_dir, SCALER_NAME)\\n+ torch.save(state, output_scaler_file)\\n+ logger.info(f\\\"Gradient scaler state saved in {output_scaler_file}\\\")\\n+ # Random number generator states\\n+ states = {}\\n+ states_name = f\\\"{RNG_STATE_NAME}_{process_index}.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state_all()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+ return output_dir\\n+\\n+\\n+def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=None):\\n+ \\\"\\\"\\\"\\n+ Loads states of the models, optimizers, scaler, and RNG generators from a given directory.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to load all relevant weights and states.\\n+ model_stmodelsates (:obj:`List[torch.nn.Module]`):\\n+ A list of model instances\\n+ optimizers (:obj:`List[torch.optim.Optimizer]`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`torch.cuda.amp.GradScaler`, `optional`):\\n+ An optional `GradScaler` instance to load\\n+ \\\"\\\"\\\"\\n+ # Model states\\n+ for i, model in enumerate(models):\\n+ weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n+ input_model_file = os.path.join(input_dir, weights_name)\\n+ models[i].load_state_dict(torch.load(input_model_file))\\n+ logger.info(\\\"All model weights loaded successfully\\\")\\n+\\n+ # Optimizer states\\n+ for i, opt in enumerate(optimizers):\\n+ optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n+ input_optimizer_file = os.path.join(input_dir, optimizer_name)\\n+ optimizers[i].load_state_dict(torch.load(input_optimizer_file))\\n+ logger.info(\\\"All optimizer states loaded successfully\\\")\\n+\\n+ # GradScaler state\\n+ if scaler is not None:\\n+ input_scaler_file = os.path.join(input_dir, SCALER_NAME)\\n+ scaler.load_state_dict(torch.load(input_scaler_file))\\n+ logger.info(\\\"GradScaler state loaded successfully\\\")\\n+\\n+ # Random states\\n+ states = torch.load(os.path.join(input_dir, f\\\"{RNG_STATE_NAME}_{process_index}.pkl\\\"))\\n+ random.setstate(states[\\\"random_state\\\"])\\n+ np.random.set_state(states[\\\"numpy_random_seed\\\"])\\n+ torch.set_rng_state(states[\\\"torch_manual_seed\\\"])\\n+ torch.cuda.set_rng_state_all(states[\\\"torch_cuda_manual_seed\\\"])\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ xm.set_rng_state(states[\\\"xm_seed\\\"])\\n+ logger.info(\\\"All random states loaded successfully\\\")\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 3af792f1f..abd5152ae 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -43,6 +43,11 @@ def is_sagemaker_available():\\n if is_deepspeed_available():\\n from deepspeed import DeepSpeedEngine\\n \\n+SCALER_NAME = \\\"scaler.pt\\\"\\n+MODEL_NAME = \\\"pytorch_model\\\"\\n+RNG_STATE_NAME = \\\"random_states\\\"\\n+OPTIMIZER_NAME = \\\"optimizer\\\"\\n+\\n \\n class RNGType(Enum):\\n TORCH = \\\"torch\\\"\\ndiff --git a/tests/test_state_checkpointing.py b/tests/test_state_checkpointing.py\\nnew file mode 100644\\nindex 000000000..a74dcb724\\n--- /dev/null\\n+++ b/tests/test_state_checkpointing.py\\n@@ -0,0 +1,125 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import logging\\n+import os\\n+import random\\n+import tempfile\\n+import unittest\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+def train(num_epochs, model, dataloader, optimizer, accelerator):\\n+ \\\"Trains for `num_epochs`\\\"\\n+ rands = []\\n+ for epoch in range(num_epochs):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ rands.append(random.random()) # Introduce some randomness\\n+ return rands\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+class CheckpointTest(unittest.TestCase):\\n+ def test_can_resume_training(self):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator()\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ (a, b) = model.a.item(), model.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ ground_truth_rands = train(3, model, train_dataloader, optimizer, accelerator)\\n+ (a1, b1) = model.a.item(), model.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ accelerator = Accelerator()\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ accelerator.load_state(initial)\\n+ (a2, b2) = model.a.item(), model.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ self.assertEqual(a, a2)\\n+ self.assertEqual(b, b2)\\n+ self.assertEqual(opt_state, opt_state2)\\n+\\n+ test_rands = train(2, model, train_dataloader, optimizer, accelerator)\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ test_rands += train(1, model, train_dataloader, optimizer, accelerator)\\n+ (a3, b3) = model.a.item(), model.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ self.assertEqual(a1, a3)\\n+ self.assertEqual(b1, b3)\\n+ self.assertEqual(opt_state1, opt_state3)\\n+ self.assertEqual(ground_truth_rands, test_rands)\\n\",\n \"code_comments\": [\n {\n \"body\": \"As much as possible, I would prefer to have everything in another module and have `accelerator` be a thin wrapper. I think we could have a new `checkpointing.py` file where a function that does all of this (taking `models`, `optimizers`, `scaler`). Same for the loading.\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if i != 0:\\r\\n weights_name += f\\\"_{i}\\\"\\r\\n```\\r\\nIs it a typo? I think it's for every model **but** the first one.\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Should be `accelerator.save` here (otherwise won't work for TPUs).\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here:\\r\\n```suggestion\\r\\n accelerator.save(state, output_optimizer_file)\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if i != 0:\\r\\n optimizer_name += f\\\"_{i}\\\"\\r\\n```\\r\\nAs above!\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n scaler_name = \\\"scaler.pt\\\"\\r\\n```\\r\\nLet's use the same name as in the `Trainer`.\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n logger.info(f\\\"Gradient scaler state saved in {output_scaler_file}\\\")\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n output_scaler_file = os.path.join(output_dir, scaler_name)\\r\\n torch.save(state, output_scaler_file)\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\",\n \"from_author\": false\n },\n {\n \"body\": \"I realize we are missing the learning rate scheduler -> we should thus add it as an optional argument to the `save_state` function, or add a `register_for_checkpoints` method to the Accelerator object that would take objects not passed to the `prepare` method but the user still wants to save.\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n # Random number generator states\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\",\n \"from_author\": false\n },\n {\n \"body\": \"We use `rng_state.pth` in the Trainer, so we should do so here as well for consistency across libs.\\r\\n\\r\\nAlso, we need to save the states on each process as they might be different (in `rng_state_{i}.pth` for process i)\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\\n+ states = {}\\n+ states_name = \\\"random_states.pkl\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if i != 0:\\r\\n weights_name += f\\\"_{i}\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\\n+ states = {}\\n+ states_name = \\\"random_states.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state_all()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scalar, and RNG generators from `folder_name`.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder all relevant weights and states were saved in.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ input_dir = os.path.expanduser(input_dir)\\n+ if not os.path.isdir(input_dir):\\n+ raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n+ logger.info(f\\\"Loading states from {input_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if i != 0:\\r\\n optimizer_name += f\\\"_{i}\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\\n+ states = {}\\n+ states_name = \\\"random_states.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state_all()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scalar, and RNG generators from `folder_name`.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder all relevant weights and states were saved in.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ input_dir = os.path.expanduser(input_dir)\\n+ if not os.path.isdir(input_dir):\\n+ raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n+ logger.info(f\\\"Loading states from {input_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ input_model_file = os.path.join(input_dir, weights_name)\\n+ self._models[i].load_state_dict(torch.load(input_model_file))\\n+ logger.info(\\\"All model weights loaded successfully\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"The names should probably be constants, so we only have to change them in one place ;-)\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\\n+ states = {}\\n+ states_name = \\\"random_states.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state_all()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scalar, and RNG generators from `folder_name`.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder all relevant weights and states were saved in.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ input_dir = os.path.expanduser(input_dir)\\n+ if not os.path.isdir(input_dir):\\n+ raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n+ logger.info(f\\\"Loading states from {input_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ input_model_file = os.path.join(input_dir, weights_name)\\n+ self._models[i].load_state_dict(torch.load(input_model_file))\\n+ logger.info(\\\"All model weights loaded successfully\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ input_optimizer_file = os.path.join(input_dir, optimizer_name)\\n+ self._optimizers[i].load_state_dict(torch.load(input_optimizer_file))\\n+ logger.info(\\\"All optimizer states loaded successfully\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ scaler_name = \\\"scaler.bin\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Same ehre + one for each process.\",\n \"diff_hunk\": \"@@ -560,6 +566,109 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scalar, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ state = self.get_state_dict(model)\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ torch.save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ state = self.scaler.state_dict()\\n+ scalar_name = \\\"scaler.bin\\\"\\n+ output_scalar_file = os.path.join(output_dir, scalar_name)\\n+ torch.save(state, output_scalar_file)\\n+ logger.info(f\\\"GradScalar state saved in {output_scalar_file}\\\")\\n+ # Random states\\n+ states = {}\\n+ states_name = \\\"random_states.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state_all()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scalar, and RNG generators from `folder_name`.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder all relevant weights and states were saved in.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ input_dir = os.path.expanduser(input_dir)\\n+ if not os.path.isdir(input_dir):\\n+ raise ValueError(f\\\"Tried to find {input_dir} but folder does not exist\\\")\\n+ logger.info(f\\\"Loading states from {input_dir}\\\")\\n+\\n+ # Model states\\n+ for i, model in enumerate(self._models):\\n+ weights_name = \\\"pytorch_model\\\"\\n+ if i == 0:\\n+ weights_name += f\\\"_{i}\\\"\\n+ weights_name += \\\".bin\\\"\\n+ input_model_file = os.path.join(input_dir, weights_name)\\n+ self._models[i].load_state_dict(torch.load(input_model_file))\\n+ logger.info(\\\"All model weights loaded successfully\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(self._optimizers):\\n+ optimizer_name = \\\"optimizer\\\"\\n+ if i == 0:\\n+ optimizer_name += f\\\"_{i}\\\"\\n+ optimizer_name += \\\".pt\\\"\\n+ input_optimizer_file = os.path.join(input_dir, optimizer_name)\\n+ self._optimizers[i].load_state_dict(torch.load(input_optimizer_file))\\n+ logger.info(\\\"All optimizer states loaded successfully\\\")\\n+ # GradScalar state\\n+ if self.scaler is not None:\\n+ scaler_name = \\\"scaler.bin\\\"\\n+ input_scaler_file = os.path.join(input_dir, scaler_name)\\n+ self.scaler.load_state_dict(torch.load(input_scaler_file))\\n+ logger.info(\\\"GradScalar state loaded successfully\\\")\\n+ # Random states\\n+ states = torch.load(os.path.join(input_dir, \\\"random_states.pkl\\\"))\",\n \"from_author\": false\n },\n {\n \"body\": \"We could wrap all of this in some train function that does the training.\",\n \"diff_hunk\": \"@@ -0,0 +1,148 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import tempfile\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+def test_can_resume_training(args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(\\n+ fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True\\n+ )\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ for epoch in range(3):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\",\n \"from_author\": false\n },\n {\n \"body\": \"Nit: we should use `unittest` here with `self.assertEqual` and `self.assertEqualDict` instead of those asserts.\",\n \"diff_hunk\": \"@@ -0,0 +1,148 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import tempfile\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+def test_can_resume_training(args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(\\n+ fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True\\n+ )\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ for epoch in range(3):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ assert a == a2\\n+ assert b == b2\\n+ assert opt_state == opt_state2\",\n \"from_author\": false\n },\n {\n \"body\": \"Same as above.\",\n \"diff_hunk\": \"@@ -0,0 +1,148 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import tempfile\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+def test_can_resume_training(args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(\\n+ fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True\\n+ )\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ for epoch in range(3):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ assert a == a2\\n+ assert b == b2\\n+ assert opt_state == opt_state2\\n+\\n+ for epoch in range(2):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ for epoch in range(1):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a3, b3) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ assert a1 == a3\\n+ assert b1 == b3\\n+ assert opt_state1 == opt_state3\",\n \"from_author\": false\n },\n {\n \"body\": \"This one being deprecated, I wouldn't pass it/create it.\",\n \"diff_hunk\": \"@@ -0,0 +1,148 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import tempfile\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+def test_can_resume_training(args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(\\n+ fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True\\n+ )\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ for epoch in range(3):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ assert a == a2\\n+ assert b == b2\\n+ assert opt_state == opt_state2\\n+\\n+ for epoch in range(2):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ for epoch in range(1):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a3, b3) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ assert a1 == a3\\n+ assert b1 == b3\\n+ assert opt_state1 == opt_state3\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"I'd like some advice on how to convert my script -> a proper test. I tried looking in `test_multigpu` but still doesn't quite line up with how the testing workflow operates\",\n \"diff_hunk\": \"@@ -0,0 +1,148 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import tempfile\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+def test_can_resume_training(args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(\\n+ fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True\\n+ )\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+ for epoch in range(3):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ assert a == a2\\n+ assert b == b2\\n+ assert opt_state == opt_state2\\n+\\n+ for epoch in range(2):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ for epoch in range(1):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a3, b3) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ assert a1 == a3\\n+ assert b1 == b3\\n+ assert opt_state1 == opt_state3\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n Saves the current states of the model, optimizer, scaler, and RNG generators.\\r\\n```\\r\\nIt's actually output_dir but since we document it just after, no need to mention it up there I believe.\",\n \"diff_hunk\": \"@@ -560,6 +562,36 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scaler, and RNG generators to `folder_name`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n Loads the current states of the model, optimizer, scaler, and RNG generators.\\r\\n```\",\n \"diff_hunk\": \"@@ -560,6 +562,36 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def save_state(self, output_dir: str):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the model, optimizer, scaler, and RNG generators to `folder_name`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ \\\"\\\"\\\"\\n+ # Check if folder exists\\n+ output_dir = os.path.expanduser(output_dir)\\n+ os.makedirs(output_dir, exist_ok=True)\\n+ logger.info(f\\\"Saving current state to {output_dir}\\\")\\n+ weights = [self.get_state_dict(m) for m in self._models]\\n+ return save_accelerator_state(output_dir, weights, self._optimizers, self.state.process_index, self.scaler)\\n+\\n+ def load_state(self, input_dir: str):\\n+ \\\"\\\"\\\"\\n+ Loads the current states of the model, optimizer, scaler, and RNG generators from `folder_name`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n# Copyright 2022 The HuggingFace Team. All rights reserved.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n Saves the current states of the models, optimizers, scaler, and RNG generators to a given directory.\\r\\n```\\r\\nLet's leave the argument names for the arg descriptions and be moe \\\"English\\\" in the description (or if you want them, you need to put them in double backticks or add an `:obj:` to have them code-formatted)\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n scaler (:obj:`torch.cuda.amp.GradScaler`, `optional`):\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n An optional gradient scaler instance to save\\r\\n```\\r\\n(The type is already described)\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\\n+ An optional `GradScaler` instance to save\",\n \"from_author\": false\n },\n {\n \"body\": \"This also needs to use the `save` function (especially for TPUs).\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\\n+ An optional `GradScaler` instance to save\\n+ \\\"\\\"\\\"\\n+ # Model states\\n+ for i, state in enumerate(model_states):\\n+ weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n model_states (:obj:`List[torch.nn.Module]`):\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n optimizers (:obj:`List[torch.optim.Optimizer]`):\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\",\n \"from_author\": false\n },\n {\n \"body\": \"Fix those as above.\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\\n+ An optional `GradScaler` instance to save\\n+ \\\"\\\"\\\"\\n+ # Model states\\n+ for i, state in enumerate(model_states):\\n+ weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScaler state\\n+ if scaler is not None:\\n+ state = scaler.state_dict()\\n+ output_scaler_file = os.path.join(output_dir, SCALER_NAME)\\n+ torch.save(state, output_scaler_file)\\n+ logger.info(f\\\"Gradient scaler state saved in {output_scaler_file}\\\")\\n+ # Random number generator states\\n+ states = {}\\n+ states_name = f\\\"{RNG_STATE_NAME}_{process_index}.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+ return output_dir\\n+\\n+\\n+def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=None):\\n+ \\\"\\\"\\\"\\n+ Loads states of the `models`, `optimizers`, scaler, and RNG generators from `input_dir`.\\n+\\n+ Args:\\n+ input_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to load all relevant weights and states.\\n+ model_stmodelsates (:obj:`list`):\\n+ A list of model instances\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n Loads states of the models, optimizers, scaler, and RNG generators from a given directory.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import random\\n+from typing import List\\n+\\n+import numpy as np\\n+import torch\\n+from torch.cuda.amp import GradScaler\\n+\\n+from .state import is_tpu_available\\n+from .utils import MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SCALER_NAME, save\\n+\\n+\\n+if is_tpu_available():\\n+ import torch_xla.core.xla_model as xm\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n+\\n+\\n+def save_accelerator_state(\\n+ output_dir: str, model_states: List[dict], optimizers: list, process_index: int, scaler: GradScaler = None\\n+):\\n+ \\\"\\\"\\\"\\n+ Saves the current states of the `models`, `optimizers`, scaler, and RNG generators to `output_dir`.\\n+\\n+ Args:\\n+ output_dir (:obj:`str` or :obj:`os.PathLike`):\\n+ The name of the folder to save all relevant weights and states.\\n+ model_states (:obj:`list`):\\n+ A list of model states\\n+ optimizers (:obj:`list`):\\n+ A list of optimizer instances\\n+ process_index (:obj:`int`):\\n+ The current process index in the Accelerator state\\n+ scaler (:obj:`GradScaler`), Optional:\\n+ An optional `GradScaler` instance to save\\n+ \\\"\\\"\\\"\\n+ # Model states\\n+ for i, state in enumerate(model_states):\\n+ weights_name = f\\\"{MODEL_NAME}.bin\\\" if i == 0 else f\\\"{MODEL_NAME}_{i}.bin\\\"\\n+ output_model_file = os.path.join(output_dir, weights_name)\\n+ save(state, output_model_file)\\n+ logger.info(f\\\"Model weights saved in {output_model_file}\\\")\\n+ # Optimizer states\\n+ for i, opt in enumerate(optimizers):\\n+ state = opt.state_dict()\\n+ optimizer_name = f\\\"{OPTIMIZER_NAME}.bin\\\" if i == 0 else f\\\"{OPTIMIZER_NAME}_{i}.bin\\\"\\n+ output_optimizer_file = os.path.join(output_dir, optimizer_name)\\n+ torch.save(state, output_optimizer_file)\\n+ logger.info(f\\\"Optimizer state saved in {output_optimizer_file}\\\")\\n+ # GradScaler state\\n+ if scaler is not None:\\n+ state = scaler.state_dict()\\n+ output_scaler_file = os.path.join(output_dir, SCALER_NAME)\\n+ torch.save(state, output_scaler_file)\\n+ logger.info(f\\\"Gradient scaler state saved in {output_scaler_file}\\\")\\n+ # Random number generator states\\n+ states = {}\\n+ states_name = f\\\"{RNG_STATE_NAME}_{process_index}.pkl\\\"\\n+ states[\\\"random_state\\\"] = random.getstate()\\n+ states[\\\"numpy_random_seed\\\"] = np.random.get_state()\\n+ states[\\\"torch_manual_seed\\\"] = torch.get_rng_state()\\n+ states[\\\"torch_cuda_manual_seed\\\"] = torch.cuda.get_rng_state()\\n+ # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ states[\\\"xm_seed\\\"] = torch.tensor(xm.get_rng_state())\\n+ output_states_file = os.path.join(output_dir, states_name)\\n+ torch.save(states, output_states_file)\\n+ logger.info(f\\\"Random states saved in {output_states_file}\\\")\\n+ return output_dir\\n+\\n+\\n+def load_accelerator_state(input_dir, models, optimizers, process_index, scaler=None):\\n+ \\\"\\\"\\\"\\n+ Loads states of the `models`, `optimizers`, scaler, and RNG generators from `input_dir`.\",\n \"from_author\": false\n },\n {\n \"body\": \"gt stands for? An expanded name would be easier to read :-)\\r\\nSince we have `test` below it's probably ground truth, so `ground_truth_rands` or if you wnat shorter `expected_rands`?\",\n \"diff_hunk\": \"@@ -0,0 +1,144 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import random\\n+import tempfile\\n+import unittest\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+def train(num_epochs, model, dataloader, optimizer, accelerator):\\n+ \\\"Trains for `num_epochs`\\\"\\n+ rands = []\\n+ for epoch in range(num_epochs):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ rands.append(random.random()) # Introduce some randomness\\n+ return rands\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+class CheckpointTest(unittest.TestCase):\\n+ def test_can_resume_training(self, args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True)\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+\\n+ gt_rands = train(3, model, train_dataloader, optimizer, accelerator)\",\n \"from_author\": false\n },\n {\n \"body\": \"No need to make this an executable, pytest will do that on its own. I think we can remove the `args` from the `test_can_resume_training` method.\",\n \"diff_hunk\": \"@@ -0,0 +1,144 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import random\\n+import tempfile\\n+import unittest\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+def train(num_epochs, model, dataloader, optimizer, accelerator):\\n+ \\\"Trains for `num_epochs`\\\"\\n+ rands = []\\n+ for epoch in range(num_epochs):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ rands.append(random.random()) # Introduce some randomness\\n+ return rands\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+class CheckpointTest(unittest.TestCase):\\n+ def test_can_resume_training(self, args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True)\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+\\n+ gt_rands = train(3, model, train_dataloader, optimizer, accelerator)\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ self.assertEqual(a, a2)\\n+ self.assertEqual(b, b2)\\n+ self.assertEqual(opt_state, opt_state2)\\n+ set_seed(42)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Ensure all numbers align\\n+\\n+ test_rands = train(2, model, train_dataloader, optimizer, accelerator)\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ test_rands += train(1, model, train_dataloader, optimizer, accelerator)\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a3, b3) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ self.assertEqual(a1, a3)\\n+ self.assertEqual(b1, b3)\\n+ self.assertEqual(opt_state1, opt_state3)\\n+ self.assertEqual(gt_rands, test_rands)\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ args = parser.parse_args()\\n+ CheckpointTest().test_can_resume_training(args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\",\n \"from_author\": false\n },\n {\n \"body\": \"@sgugger how would we delegate the tests to be ran on cpu, mixed precision, etc then in that case? \",\n \"diff_hunk\": \"@@ -0,0 +1,144 @@\\n+# Copyright 2022 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+import random\\n+import tempfile\\n+import unittest\\n+\\n+import torch\\n+from torch import nn\\n+from torch.utils.data import DataLoader, TensorDataset\\n+\\n+from accelerate import Accelerator\\n+from accelerate.utils import set_seed\\n+\\n+\\n+def dummy_dataloaders(a=2, b=3, batch_size=16, n_train_batches: int = 10, n_valid_batches: int = 2):\\n+ \\\"Generates a tuple of dummy DataLoaders to test with\\\"\\n+\\n+ def get_dataset(n_batches):\\n+ x = torch.randn(batch_size * n_batches, 1)\\n+ return TensorDataset(x, a * x + b + 0.1 * torch.randn(batch_size * n_batches, 1))\\n+\\n+ train_dataset = get_dataset(n_train_batches)\\n+ valid_dataset = get_dataset(n_valid_batches)\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ valid_dataloader = DataLoader(valid_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+ return (train_dataloader, valid_dataloader)\\n+\\n+\\n+def train(num_epochs, model, dataloader, optimizer, accelerator):\\n+ \\\"Trains for `num_epochs`\\\"\\n+ rands = []\\n+ for epoch in range(num_epochs):\\n+ # Train quickly\\n+ model.train()\\n+ for step, batch in enumerate(dataloader):\\n+ x, y = batch\\n+ outputs = model(x)\\n+ loss = torch.nn.functional.mse_loss(outputs, y)\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ optimizer.zero_grad()\\n+ rands.append(random.random()) # Introduce some randomness\\n+ return rands\\n+\\n+\\n+class DummyModel(nn.Module):\\n+ \\\"Simple model to do y=mx+b\\\"\\n+\\n+ def __init__(self):\\n+ super().__init__()\\n+ self.a = nn.Parameter(torch.randn(1))\\n+ self.b = nn.Parameter(torch.randn(1))\\n+\\n+ def forward(self, x):\\n+ return x * self.a + self.b\\n+\\n+\\n+class CheckpointTest(unittest.TestCase):\\n+ def test_can_resume_training(self, args):\\n+ with tempfile.TemporaryDirectory() as tmpdir:\\n+ set_seed(42)\\n+ model = DummyModel()\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-3)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Train baseline\\n+ accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, device_placement=True)\\n+ model, optimizer, train_dataloader, valid_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, valid_dataloader\\n+ )\\n+ # Save initial\\n+ initial = os.path.join(tmpdir, \\\"initial\\\")\\n+ accelerator.save_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a, b) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state = optimizer.state_dict()\\n+\\n+ gt_rands = train(3, model, train_dataloader, optimizer, accelerator)\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a1, b1) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state1 = optimizer.state_dict()\\n+\\n+ # Train partially\\n+ accelerator.load_state(initial)\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a2, b2) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state2 = optimizer.state_dict()\\n+ self.assertEqual(a, a2)\\n+ self.assertEqual(b, b2)\\n+ self.assertEqual(opt_state, opt_state2)\\n+ set_seed(42)\\n+ train_dataloader, valid_dataloader = dummy_dataloaders()\\n+ # Ensure all numbers align\\n+\\n+ test_rands = train(2, model, train_dataloader, optimizer, accelerator)\\n+ # Save everything\\n+ checkpoint = os.path.join(tmpdir, \\\"checkpoint\\\")\\n+ accelerator.save_state(checkpoint)\\n+\\n+ # Load everything back in and make sure all states work\\n+ accelerator.load_state(checkpoint)\\n+ test_rands += train(1, model, train_dataloader, optimizer, accelerator)\\n+\\n+ model_unwrapped = accelerator.unwrap_model(model)\\n+ (a3, b3) = model_unwrapped.a.item(), model_unwrapped.b.item()\\n+ opt_state3 = optimizer.state_dict()\\n+ self.assertEqual(a1, a3)\\n+ self.assertEqual(b1, b3)\\n+ self.assertEqual(opt_state1, opt_state3)\\n+ self.assertEqual(gt_rands, test_rands)\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ args = parser.parse_args()\\n+ CheckpointTest().test_can_resume_training(args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/255\",\n \"pr_id\": 855956281\n },\n {\n \"diff\": \"diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md\\nnew file mode 100644\\nindex 000000000..66b0a8538\\n--- /dev/null\\n+++ b/CONTRIBUTING.md\\n@@ -0,0 +1,235 @@\\n+<!---\\n+Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to π€ Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+Some of the ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_congig.yml`)\\n+\\n+### Do you want a new feature?\\n+\\n+A good feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Submitting a pull request (PR)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+π€ Accelerate. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote. The following command\\n+ assumes you have your public SSH key uploaded to GitHub. See the following guide for more\\n+ [information](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes, and do this for every new PR you work on.\\n+\\n+ Start by synchronizing your `main` branch with the `upstream/main` branch (ore details in the [GitHub Docs](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork)):\\n+\\n+ ```bash\\n+ $ git checkout main\\n+ $ git fetch upstream\\n+ $ git merge upstream/main\\n+ ```\\n+\\n+ Once your `main` branch is synchronized, create a new branch from it:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[quality]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+ \\n+ > For the following commands leveraging the `make` utility, we recommend using the WSL system when running on\\n+ > Windows. More information [here](https://docs.microsoft.com/en-us/windows/wsl/about).\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\\n+ ```\\n+\\n+ Push the changes to your account using:\\n+\\n+ ```bash\\n+ $ git push -u origin a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+6. Once you are satisfied (**and the checklist below is happy too**), go to the\\n+ webpage of your fork on GitHub. Click on 'Pull request' to send your changes\\n+ to the project maintainers for review.\\n+\\n+7. It's ok if maintainers ask you for changes. It happens to core contributors\\n+ too! So everyone can see the changes in the Pull request, work in your local\\n+ branch and push the changes to your fork. They will automatically appear in\\n+ the pull request.\\n+\\n+\\n+### Checklist\\n+\\n+1. The title of your pull request should be a summary of its contribution;\\n+2. If your pull request addresses an issue, please mention the issue number in\\n+ the pull request description to make sure they are linked (and people\\n+ consulting the issue know you are working on it);\\n+3. To indicate a work in progress please prefix the title with `[WIP]`, or mark\\n+ the PR as a draft PR. These are useful to avoid duplicated work, and to differentiate\\n+ it from PRs ready to be merged;\\n+4. Make sure existing tests pass;\\n+5. Add high-coverage tests. No quality testing = no merge.\\n+\\n+See an example of a good PR here: https://github.com/huggingface/accelerate/pull/255\\n+\\n+### Tests\\n+\\n+An extensive test suite is included to test the library behavior and several examples. Library tests can be found in\\n+the [tests folder](https://github.com/huggingface/accelerate/tree/master/tests).\\n+\\n+We use `pytest` in order to run the tests. From the root of the\\n+repository, here's how to run tests with `pytest` for the library:\\n+\\n+```bash\\n+$ python -m pytest -sv ./tests\\n+```\\n+\\n+In fact, that's how `make test` is implemented (sans the `pip install` line)!\\n+\\n+You can specify a smaller set of tests in order to test only the feature\\n+you're working on.\\n\\\\ No newline at end of file\\n\",\n \"code_comments\": [\n {\n \"body\": \"Not sure if that's important given you're watching the repo.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\",\n \"from_author\": true\n },\n {\n \"body\": \"Yeah we can remove that part ;-)\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\",\n \"from_author\": false\n },\n {\n \"body\": \"Missing the emoji here.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n* Provide us with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_congig.yml`)\\r\\n* Provide the command you used to launch your script (for instance `accelerate launch train_script.py`)\\r\\n* Provide the *full* traceback if an exception is raised.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n### Do you want a new feature?\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nπ€ Accelerate. `git` is not the easiest tool to use but it has the greatest\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n $ pip install -e \\\".[quality]\\\"\\r\\n```\\r\\nThere is no dev install for now ;-)\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"shouldn't this go under `LICENSE` file instead?\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nSome of the ways you can contribute to Accelerate:\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\",\n \"from_author\": false\n },\n {\n \"body\": \"Some or most of this information could also go to an issue template. The templates also support _form_ format ([example](https://github.com/scikit-learn/scikit-learn/issues/new?assignees=&labels=Bug%2CNeeds+Triage&template=bug_report.yml)) and people reporting a bug are probably not reading this document, but they would see that form or that template.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\",\n \"from_author\": false\n },\n {\n \"body\": \"we found that having a `get_versions()` which returns all relevant versions is helpful. Users would just paste the output of that in the issue.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nA good feature request addresses the following points:\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n## Submitting a pull request (PR)\\r\\n```\\r\\n\\r\\n\\\"Start contributing\\\" implies the other ones were not contributions.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\",\n \"from_author\": false\n },\n {\n \"body\": \"this assumes the user has their public ssh key uploaded to github, it deserves a note.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n3. Create a new branch to hold your development changes, and do this for every new PR you work on:\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\",\n \"from_author\": false\n },\n {\n \"body\": \"either checkout from `upstream/master`, or have them sync those two first, e.g.:\\r\\n\\r\\n- Synchronize your ``main`` branch with the ``upstream/main`` branch,\\r\\n more details on `GitHub Docs <https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork>`_:\\r\\n\\r\\n .. prompt:: bash $\\r\\n\\r\\n git checkout main\\r\\n git fetch upstream\\r\\n git merge upstream/main\\r\\n\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\",\n \"from_author\": false\n },\n {\n \"body\": \"on a windows machine they'd need a git bash or similar to run this I think.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\",\n \"from_author\": false\n },\n {\n \"body\": \"you could also add them as git hooks, which have helped us with users' contributions.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\",\n \"from_author\": false\n },\n {\n \"body\": \"in longer PRs (time-wise), rebase can be very tricky for beginner users, merge usually makes it much easier for them, and if you're squash and merging, the merge commit wouldn't show up in your history.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\",\n \"from_author\": false\n },\n {\n \"body\": \"or create a _draft_ PR?\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\\n+ ```\\n+\\n+ Push the changes to your account using:\\n+\\n+ ```bash\\n+ $ git push -u origin a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+6. Once you are satisfied (**and the checklist below is happy too**), go to the\\n+ webpage of your fork on GitHub. Click on 'Pull request' to send your changes\\n+ to the project maintainers for review.\\n+\\n+7. It's ok if maintainers ask you for changes. It happens to core contributors\\n+ too! So everyone can see the changes in the Pull request, work in your local\\n+ branch and push the changes to your fork. They will automatically appear in\\n+ the pull request.\\n+\\n+\\n+### Checklist\\n+\\n+1. The title of your pull request should be a summary of its contribution;\\n+2. If your pull request addresses an issue, please mention the issue number in\\n+ the pull request description to make sure they are linked (and people\\n+ consulting the issue know you are working on it);\\n+3. To indicate a work in progress please prefix the title with `[WIP]`. These\\n+ are useful to avoid duplicated work, and to differentiate it from PRs ready\\n+ to be merged;\",\n \"from_author\": false\n },\n {\n \"body\": \"adding a link to a _good_ PR may help them by seeing a good example.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\\n+ ```\\n+\\n+ Push the changes to your account using:\\n+\\n+ ```bash\\n+ $ git push -u origin a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+6. Once you are satisfied (**and the checklist below is happy too**), go to the\\n+ webpage of your fork on GitHub. Click on 'Pull request' to send your changes\\n+ to the project maintainers for review.\\n+\\n+7. It's ok if maintainers ask you for changes. It happens to core contributors\\n+ too! So everyone can see the changes in the Pull request, work in your local\\n+ branch and push the changes to your fork. They will automatically appear in\\n+ the pull request.\\n+\\n+\\n+### Checklist\",\n \"from_author\": false\n },\n {\n \"body\": \"There is also a `LICENSE` at the root of the repo. We have an additional license at the top of every file, with the appropriate copyrights for the code in that specific file. If some code was taken from somewhere else or from another org, we add a mention to that org in the copyright here.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\",\n \"from_author\": true\n },\n {\n \"body\": \"Sounds good. Ideally this would be done in a follow-up PR.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\",\n \"from_author\": true\n },\n {\n \"body\": \"Nice! That's what we use in `transformers`, with `transformers-cli env`. I agree it would be nice to port it to `accelerate`.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\",\n \"from_author\": true\n },\n {\n \"body\": \"I won't have the bandwidth right now to spin a tutorial about adding git hooks for our checks, but I agree that it would definitely have its place here. \\r\\n\\r\\nFeel free to push a commit directly to the `contributing-guide` branch with it, otherwise happy to do it in a follow-up PR when I have the bandwidth.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\",\n \"from_author\": true\n },\n {\n \"body\": \"What we've seen is that merging can cause a lot of issues with github not understanding what was done with the branch, and users ending up with all the commits on their branch (which of course came with all file changes accompanying these commits).\\r\\n\\r\\nWe then ask the users to close the PR and to open a new one with the same branch which generally solves the issue, but it adds more friction than necessary, so up to now we've mostly asked users to rebase their branches.\\r\\n\\r\\nIf you feel strongly, happy to add an additional mention for merge.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\nCopyright 2022 The HuggingFace Team. All rights reserved.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,235 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\",\n \"from_author\": false\n },\n {\n \"body\": \"If you mean including the git hooks in the repository itself, I think a lot of us in the team are averse to having them in our own setups so it would be polarising :)\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\",\n \"from_author\": true\n },\n {\n \"body\": \"Yeah I saw. We can follow up on that later.\",\n \"diff_hunk\": \"@@ -0,0 +1,220 @@\\n+<!---\\n+Copyright 2020 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+There are 4 ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+Please ping @sgugger on your contribution.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the *full* traceback if an exception is raised.\\n+\\n+### Do you want a new feature (that is not a model)?\\n+\\n+A world-class feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Start contributing! (Pull Requests)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+`accelerate`. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote:\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a virtual environment:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[dev]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\",\n \"from_author\": false\n },\n {\n \"body\": \"Just a little thing, it's `git rebase upstream/main`\",\n \"diff_hunk\": \"@@ -0,0 +1,235 @@\\n+<!---\\n+Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to π€ Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+Some of the ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_congig.yml`)\\n+\\n+### Do you want a new feature?\\n+\\n+A good feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Submitting a pull request (PR)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+π€ Accelerate. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote. The following command\\n+ assumes you have your public SSH key uploaded to GitHub. See the following guide for more\\n+ [information](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes, and do this for every new PR you work on.\\n+\\n+ Start by synchronizing your `main` branch with the `upstream/main` branch (ore details in the [GitHub Docs](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork)):\\n+\\n+ ```bash\\n+ $ git checkout main\\n+ $ git fetch upstream\\n+ $ git merge upstream/main\\n+ ```\\n+\\n+ Once your `main` branch is synchronized, create a new branch from it:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[quality]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+ \\n+ > For the following commands leveraging the `make` utility, we recommend using the WSL system when running on\\n+ > Windows. More information [here](https://docs.microsoft.com/en-us/windows/wsl/about).\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\",\n \"from_author\": false\n },\n {\n \"body\": \"Good catch! Do you want to make a PR to fix this?\",\n \"diff_hunk\": \"@@ -0,0 +1,235 @@\\n+<!---\\n+Copyright 2022 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# How to contribute to π€ Accelerate?\\n+\\n+Everyone is welcome to contribute, and we value everybody's contribution. Code\\n+is thus not the only way to help the community. Answering questions, helping\\n+others, reaching out and improving the documentations are immensely valuable to\\n+the community.\\n+\\n+It also helps us if you spread the word: reference the library from blog posts\\n+on the awesome projects it made possible, shout out on Twitter every time it has\\n+helped you, or simply star the repo to say \\\"thank you\\\".\\n+\\n+Whichever way you choose to contribute, please be mindful to respect our\\n+[code of conduct](https://github.com/huggingface/accelerate/blob/master/CODE_OF_CONDUCT.md).\\n+\\n+## You can contribute in so many ways!\\n+\\n+Some of the ways you can contribute to Accelerate:\\n+* Fixing outstanding issues with the existing code;\\n+* Contributing to the examples or to the documentation;\\n+* Submitting issues related to bugs or desired new features.\\n+\\n+## Submitting a new issue or feature request\\n+\\n+Do your best to follow these guidelines when submitting an issue or a feature\\n+request. It will make it easier for us to come back to you quickly and with good\\n+feedback.\\n+\\n+### Did you find a bug?\\n+\\n+The π€ Accelerate library is robust and reliable thanks to the users who notify us of\\n+the problems they encounter. So thank you for reporting an issue.\\n+\\n+First, we would really appreciate it if you could **make sure the bug was not\\n+already reported** (use the search bar on Github under Issues).\\n+\\n+Did not find it? :( So we can act quickly on it, please follow these steps:\\n+\\n+* Include your **OS type and version**, the versions of **Python** and **PyTorch**.\\n+* A short, self-contained, code snippet that allows us to reproduce the bug in\\n+ less than 30s;\\n+* Provide the with your Accelerate configuration (located by default in `~/.cache/huggingface/accelerate/default_congig.yml`)\\n+\\n+### Do you want a new feature?\\n+\\n+A good feature request addresses the following points:\\n+\\n+1. Motivation first:\\n+* Is it related to a problem/frustration with the library? If so, please explain\\n+ why. Providing a code snippet that demonstrates the problem is best.\\n+* Is it related to something you would need for a project? We'd love to hear\\n+ about it!\\n+* Is it something you worked on and think could benefit the community?\\n+ Awesome! Tell us what problem it solved for you.\\n+2. Write a *full paragraph* describing the feature;\\n+3. Provide a **code snippet** that demonstrates its future use;\\n+4. In case this is related to a paper, please attach a link;\\n+5. Attach any additional information (drawings, screenshots, etc.) you think may help.\\n+\\n+If your issue is well written we're already 80% of the way there by the time you\\n+post it.\\n+\\n+## Submitting a pull request (PR)\\n+\\n+Before writing code, we strongly advise you to search through the existing PRs or\\n+issues to make sure that nobody is already working on the same thing. If you are\\n+unsure, it is always a good idea to open an issue to get some feedback.\\n+\\n+You will need basic `git` proficiency to be able to contribute to\\n+π€ Accelerate. `git` is not the easiest tool to use but it has the greatest\\n+manual. Type `git --help` in a shell and enjoy. If you prefer books, [Pro\\n+Git](https://git-scm.com/book/en/v2) is a very good reference.\\n+\\n+Follow these steps to start contributing:\\n+\\n+1. Fork the [repository](https://github.com/huggingface/accelerate) by\\n+ clicking on the 'Fork' button on the repository's page. This creates a copy of the code\\n+ under your GitHub user account.\\n+\\n+2. Clone your fork to your local disk, and add the base repository as a remote. The following command\\n+ assumes you have your public SSH key uploaded to GitHub. See the following guide for more\\n+ [information](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).\\n+\\n+ ```bash\\n+ $ git clone git@github.com:<your Github handle>/accelerate.git\\n+ $ cd accelerate\\n+ $ git remote add upstream https://github.com/huggingface/accelerate.git\\n+ ```\\n+\\n+3. Create a new branch to hold your development changes, and do this for every new PR you work on.\\n+\\n+ Start by synchronizing your `main` branch with the `upstream/main` branch (ore details in the [GitHub Docs](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork)):\\n+\\n+ ```bash\\n+ $ git checkout main\\n+ $ git fetch upstream\\n+ $ git merge upstream/main\\n+ ```\\n+\\n+ Once your `main` branch is synchronized, create a new branch from it:\\n+\\n+ ```bash\\n+ $ git checkout -b a-descriptive-name-for-my-changes\\n+ ```\\n+\\n+ **Do not** work on the `master` branch.\\n+\\n+4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:\\n+\\n+ ```bash\\n+ $ pip install -e \\\".[quality]\\\"\\n+ ```\\n+\\n+ (If accelerate was already installed in the virtual environment, remove\\n+ it with `pip uninstall accelerate` before reinstalling it in editable\\n+ mode with the `-e` flag.)\\n+\\n+5. Develop the features on your branch.\\n+\\n+ As you work on the features, you should make sure that the test suite\\n+ passes. You should run the tests impacted by your changes like this (see \\n+ below an explanation regarding the environment variable):\\n+\\n+ ```bash\\n+ $ pytest tests/<TEST_TO_RUN>.py\\n+ ```\\n+ \\n+ > For the following commands leveraging the `make` utility, we recommend using the WSL system when running on\\n+ > Windows. More information [here](https://docs.microsoft.com/en-us/windows/wsl/about).\\n+\\n+ You can also run the full suite with the following command.\\n+\\n+ ```bash\\n+ $ make test\\n+ ```\\n+\\n+ `accelerate` relies on `black` and `isort` to format its source code\\n+ consistently. After you make changes, apply automatic style corrections and code verifications\\n+ that can't be automated in one go with:\\n+\\n+ This target is also optimized to only work with files modified by the PR you're working on.\\n+\\n+ If you prefer to run the checks one after the other, the following command apply the\\n+ style corrections:\\n+\\n+ ```bash\\n+ $ make style\\n+ ```\\n+\\n+ `accelerate` also uses `flake8` and a few custom scripts to check for coding mistakes. Quality\\n+ control runs in CI, however you can also run the same checks with:\\n+\\n+ ```bash\\n+ $ make quality\\n+ ```\\n+\\n+ Once you're happy with your changes, add changed files using `git add` and\\n+ make a commit with `git commit` to record your changes locally:\\n+\\n+ ```bash\\n+ $ git add modified_file.py\\n+ $ git commit\\n+ ```\\n+\\n+ Please write [good commit messages](https://chris.beams.io/posts/git-commit/).\\n+\\n+ It is a good idea to sync your copy of the code with the original\\n+ repository regularly. This way you can quickly account for changes:\\n+\\n+ ```bash\\n+ $ git fetch upstream\\n+ $ git rebase upstream/master\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Will merge it like that, with the following action items:\\r\\n- Work on adding an issue template (for both `huggingface_hub` and `accelerate`)\\r\\n- Have a similar method to `transformers-cli env` for `accelerate` (can be a `get_versions()` like Adrin mentions)\\r\\n\\r\\n@sgugger, ok for you if I open issues for that on `accelerate`?\",\n \"from_author\": true\n },\n {\n \"body\": \"Fine by me! It can be a good first issue!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/254\",\n \"pr_id\": 855857944\n },\n {\n \"diff\": \"diff --git a/setup.py b/setup.py\\nindex f06ab3c99..bec3b9805 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -16,7 +16,7 @@\\n from setuptools import find_packages\\n \\n extras = {}\\n-extras[\\\"quality\\\"] = [\\\"black == 21.4b0\\\", \\\"isort >= 5.5.4\\\", \\\"flake8 >= 3.8.3\\\"]\\n+extras[\\\"quality\\\"] = [\\\"black ~= 22.0\\\", \\\"isort >= 5.5.4\\\", \\\"flake8 >= 3.8.3\\\"]\\n extras[\\\"docs\\\"] = [\\n \\\"docutils==0.16.0\\\",\\n \\\"recommonmark\\\",\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/250\",\n \"pr_id\": 843135021\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex cbc23ed10..c27131808 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -210,8 +210,11 @@ You shouldn't use π€ Accelerate if you don't want to write a training loop you\\n \\n If you like the simplicity of π€ Accelerate but would prefer a higher-level abstraction around your training loop, some frameworks that are built on top of π€ Accelerate are listed below:\\n \\n-* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centred around a general-purpose [Trainer](https://pytorch-accelerated.readthedocs.io/en/latest/trainer.html), that places a huge emphasis on simplicity and transparency; enabling users to understand exactly what is going on under the hood, but without having to write and maintain the boilerplate themselves!\\n+* [Animus](https://github.com/Scitator/animus) is a minimalistic framework to run machine learning experiments. Animus highlights common \\\"breakpoints\\\" in ML experiments and provides a unified interface for them within [IExperiment](https://github.com/Scitator/animus/blob/main/animus/core.py#L76).\\n+* [Catalyst](https://github.com/catalyst-team/catalyst#getting-started) is a PyTorch framework for Deep Learning Research and Development. It focuses on reproducibility, rapid experimentation, and codebase reuse so you can create something new rather than write yet another train loop. Catalyst provides a [Runner](https://catalyst-team.github.io/catalyst/api/core.html#runner) to connect all parts of the experiment: hardware backend, data transformations, model train, and inference logic.\\n * [Kornia](https://kornia.readthedocs.io/en/latest/get-started/introduction.html) is a differentiable library that allows classical computer vision to be integrated into deep learning models. Kornia provides a [Trainer](https://kornia.readthedocs.io/en/latest/x.html#kornia.x.Trainer) with the specific purpose to train and fine-tune the supported deep learning algorithms within the library.\\n+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centred around a general-purpose [Trainer](https://pytorch-accelerated.readthedocs.io/en/latest/trainer.html), that places a huge emphasis on simplicity and transparency; enabling users to understand exactly what is going on under the hood, but without having to write and maintain the boilerplate themselves!\\n+\\n \\n ## Installation\\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"btw, it would be great if you could comment on my \\\"Accelerator mixin\\\" - [Engine](https://github.com/Scitator/animus/blob/main/animus/torch/engine.py) in terms of \\\"a bit more user-friendly Accelerator API\\\". I found it useful for me to run pipelines within notebooks or python scripts without CLI.\",\n \"from_author\": true\n },\n {\n \"body\": \"Ah thanks! I am wrapping up some things in Transformers and will go back to Accelerate pretty soon (haven't forgotten #215 !)\\r\\n\\r\\nYou mixins look great! Having one per kind of distributed setup is a bit against the philosophy of Accelerate (where the same exact code runs on any setup) but I like the abstraction.\\r\\n\\r\\nTo run things in notebooks, we also have `notebook_launcher`, I don't know if you tried it or not.\",\n \"from_author\": false\n },\n {\n \"body\": \"yeah, I found `notebook_launcher` an interesting functional alternative... nevertheless, from my previous experience I knew a few limitations of pure functional way, so... a small class-based API was created ;)\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/249\",\n \"pr_id\": 842502625\n },\n {\n \"diff\": \"diff --git a/.gitignore b/.gitignore\\nindex 3b89c957d..f41377320 100644\\n--- a/.gitignore\\n+++ b/.gitignore\\n@@ -130,3 +130,6 @@ dmypy.json\\n \\n # VSCode\\n .vscode\\n+\\n+# IntelliJ\\n+.idea\\n\\\\ No newline at end of file\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex f4164613f..bb7c7f5b1 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -73,7 +73,7 @@ def __getitem__(self, idx):\\n \\n def training_function(config, args):\\n # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu)\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mix_precision)\\n \\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n@@ -187,6 +187,15 @@ def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n parser.add_argument(\\\"--data_dir\\\", required=True, help=\\\"The data folder on disk.\\\")\\n parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 3e-2, \\\"num_epochs\\\": 3, \\\"seed\\\": 42, \\\"batch_size\\\": 64, \\\"image_size\\\": 224}\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex a1f310271..2f869bd0f 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -51,7 +51,7 @@\\n \\n def training_function(config, args):\\n # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu)\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu, mixed_precision=args.mixed_precision)\\n \\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n@@ -163,6 +163,15 @@ def collate_fn(examples):\\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ type=str,\\n+ default=\\\"no\\\",\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether to use mixed precision. Choose\\\"\\n+ \\\"between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.\\\"\\n+ \\\"and an Nvidia Ampere GPU.\\\",\\n+ )\\n parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 76c3067a3..ed3b2acb7 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -14,6 +14,7 @@\\n \\n import gc\\n import os\\n+import warnings\\n from contextlib import contextmanager\\n from typing import List, Optional, Union\\n \\n@@ -60,10 +61,11 @@ class Accelerator:\\n :obj:`True` the actual batch size used will be the same on any kind of distributed processes, but it must\\n be a round multiple of the :obj:`num_processes` you are using. If :obj:`False`, actual batch size used will\\n be the one set in your script multiplied by the number of processes.\\n- fp16 (:obj:`bool`, `optional`):\\n- Whether or not to use mixed precision training. Will default to the value in the environment variable\\n- :obj:`USE_FP16`, which will use the default value in the accelerate config of the current system or the\\n- flag passed with the :obj:`accelerate.launch` command.\\n+ mixed_precision (:obj:`str`, `optional`):\\n+ Whether or not to use mixed precision training (fp16 or bfloat16). Choose from 'no','fp16','bf16'. Will\\n+ default to the value in the environment variable :obj:`MIXED_PRECISION`, which will use the default value\\n+ in the accelerate config of the current system or the flag passed with the :obj:`accelerate.launch`\\n+ command. 'fp16' requires pytorch 1.6 or higher. 'bf16' requires pytorch 1.10 or higher.\\n cpu (:obj:`bool`, `optional`):\\n Whether or not to force the script to execute on CPU. Will ignore GPU available if set to :obj:`True` and\\n force the execution on one process only.\\n@@ -101,12 +103,25 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = None,\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+\\n+ if mixed_precision is not None:\\n+ mixed_precision = mixed_precision.lower()\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+ )\\n+\\n+ if fp16:\\n+ warnings.warn('fp16=True is deprecated. Use mixed_precision=\\\"fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n if deepspeed_plugin is None: # init from env variables\\n deepspeed_plugin = DeepSpeedPlugin() if os.environ.get(\\\"USE_DEEPSPEED\\\", \\\"false\\\") == \\\"true\\\" else None\\n else:\\n@@ -139,7 +154,11 @@ def __init__(\\n \\n kwargs = self.init_handler.to_kwargs() if self.init_handler is not None else {}\\n self.state = AcceleratorState(\\n- fp16=fp16, cpu=cpu, deepspeed_plugin=deepspeed_plugin, _from_accelerator=True, **kwargs\\n+ mixed_precision=mixed_precision,\\n+ cpu=cpu,\\n+ deepspeed_plugin=deepspeed_plugin,\\n+ _from_accelerator=True,\\n+ **kwargs,\\n )\\n \\n self.device_placement = device_placement\\n@@ -149,8 +168,18 @@ def __init__(\\n # Mixed precision attributes\\n self.scaler = None\\n self.native_amp = False\\n- if self.state.use_fp16:\\n+ if self.state.mixed_precision == \\\"fp16\\\":\\n self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.6\\\")\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.6\\\"):\\n+ raise ValueError(\\\"fp16 mixed precision requires PyTorch >= 1.6\\\")\\n+\\n+ kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}\\n+ self.scaler = torch.cuda.amp.GradScaler(**kwargs)\\n+ elif self.state.mixed_precision == \\\"bf16\\\":\\n+ self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.10\\\")\\n+ if mixed_precision == \\\"bf16\\\" and version.parse(torch.__version__) < version.parse(\\\"1.10\\\"):\\n+ raise ValueError(\\\"bf16 mixed precision requires PyTorch >= 1.10\\\")\\n+\\n kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}\\n self.scaler = torch.cuda.amp.GradScaler(**kwargs)\\n \\n@@ -195,11 +224,20 @@ def is_local_main_process(self):\\n \\n @property\\n def use_fp16(self):\\n+ return self.mixed_precision != \\\"no\\\"\\n+\\n+ @property\\n+ def mixed_precision(self):\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- use_fp16 = self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]\\n+ if self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]:\\n+ mixed_precision = \\\"fp16\\\"\\n+ elif self.state.deepspeed_plugin.deepspeed_config[\\\"bf16\\\"][\\\"enabled\\\"]:\\n+ mixed_precision = \\\"bf16\\\"\\n+ else:\\n+ mixed_precision = \\\"no\\\"\\n else:\\n- use_fp16 = self.state.use_fp16\\n- return use_fp16\\n+ mixed_precision = self.state.mixed_precision\\n+ return mixed_precision\\n \\n @contextmanager\\n def local_main_process_first(self):\\n@@ -311,7 +349,12 @@ def prepare_model(self, model):\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n if self.native_amp:\\n- model.forward = torch.cuda.amp.autocast()(model.forward)\\n+ if self.mixed_precision == \\\"fp16\\\" and version.parse(torch.__version__) >= version.parse(\\\"1.10\\\"):\\n+ model.forward = torch.cuda.amp.autocast(dtype=torch.float16)(model.forward)\\n+ elif self.mixed_precision == \\\"bf16\\\":\\n+ model.forward = torch.cuda.amp.autocast(dtype=torch.bfloat16)(model.forward)\\n+ else:\\n+ model.forward = torch.cuda.amp.autocast()(model.forward)\\n model.forward = convert_outputs_to_fp32(model.forward)\\n return model\\n \\n@@ -577,7 +620,13 @@ def autocast(self):\\n different will happen otherwise.\\n \\\"\\\"\\\"\\n if self.native_amp:\\n- autocast_context = torch.cuda.amp.autocast()\\n+ if self.mixed_precision == \\\"fp16\\\" and version.parse(torch.__version__) >= version.parse(\\\"1.10\\\"):\\n+ autocast_context = torch.cuda.amp.autocast(dtype=torch.float16)\\n+ elif self.mixed_precision == \\\"bf16\\\":\\n+ autocast_context = torch.cuda.amp.autocast(dtype=torch.bfloat16)\\n+ else:\\n+ autocast_context = torch.cuda.amp.autocast()\\n+\\n autocast_context.__enter__()\\n yield\\n autocast_context.__exit__()\\ndiff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex eaaad20f2..534ea1526 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -103,20 +103,19 @@ def get_cluster_input():\\n )\\n \\n if distributed_type != DistributedType.TPU:\\n- fp16 = _ask_field(\\n- \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n- _convert_yes_no_to_bool,\\n- default=False,\\n- error_message=\\\"Please enter yes or no.\\\",\\n+ mixed_precision = _ask_field(\\n+ \\\"Do you wish to use FP16 or BF16 (mixed precision)? [NO/fp16/bf16]: \\\",\\n+ lambda x: str(x).lower(),\\n+ default=\\\"no\\\",\\n )\\n else:\\n- fp16 = False\\n+ mixed_precision = \\\"no\\\"\\n \\n return ClusterConfig(\\n compute_environment=ComputeEnvironment.LOCAL_MACHINE,\\n distributed_type=distributed_type,\\n num_processes=num_processes,\\n- fp16=fp16,\\n+ mixed_precision=mixed_precision,\\n machine_rank=machine_rank,\\n num_machines=num_machines,\\n main_process_ip=main_process_ip,\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 39c00c280..891580ab5 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -66,7 +66,7 @@ def load_config_from_file(config_file):\\n class BaseConfig:\\n compute_environment: ComputeEnvironment\\n distributed_type: Union[DistributedType, SageMakerDistributedType]\\n- fp16: bool\\n+ mixed_precision: str\\n \\n def to_dict(self):\\n result = self.__dict__\\n@@ -83,6 +83,10 @@ def from_json_file(cls, json_file=None):\\n config_dict = json.load(f)\\n if \\\"compute_environment\\\" not in config_dict:\\n config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ if \\\"mixed_precision\\\" not in config_dict:\\n+ config_dict[\\\"mixed_precision\\\"] = \\\"fp16\\\" if (\\\"fp16\\\" in config_dict and config_dict[\\\"fp16\\\"]) else \\\"no\\\"\\n+ if \\\"fp16\\\" in config_dict: # Convert the config to the new format.\\n+ del config_dict[\\\"fp16\\\"]\\n return cls(**config_dict)\\n \\n def to_json_file(self, json_file):\\n@@ -97,6 +101,12 @@ def from_yaml_file(cls, yaml_file=None):\\n config_dict = yaml.safe_load(f)\\n if \\\"compute_environment\\\" not in config_dict:\\n config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+\\n+ if \\\"mixed_precision\\\" not in config_dict:\\n+ config_dict[\\\"mixed_precision\\\"] = \\\"fp16\\\" if (\\\"fp16\\\" in config_dict and config_dict[\\\"fp16\\\"]) else \\\"no\\\"\\n+ if \\\"fp16\\\" in config_dict: # Convert the config to the new format.\\n+ del config_dict[\\\"fp16\\\"]\\n+\\n return cls(**config_dict)\\n \\n def to_yaml_file(self, yaml_file):\\ndiff --git a/src/accelerate/commands/config/sagemaker.py b/src/accelerate/commands/config/sagemaker.py\\nindex feff0aecf..3b0fc78dd 100644\\n--- a/src/accelerate/commands/config/sagemaker.py\\n+++ b/src/accelerate/commands/config/sagemaker.py\\n@@ -20,7 +20,7 @@\\n from accelerate.utils import is_boto3_available\\n \\n from .config_args import SageMakerConfig\\n-from .config_utils import _ask_field, _convert_sagemaker_distributed_mode, _convert_yes_no_to_bool\\n+from .config_utils import _ask_field, _convert_sagemaker_distributed_mode\\n \\n \\n if is_boto3_available():\\n@@ -139,11 +139,11 @@ def get_sagemaker_input():\\n lambda x: int(x),\\n default=2,\\n )\\n- fp16 = _ask_field(\\n- \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n- _convert_yes_no_to_bool,\\n- default=False,\\n- error_message=\\\"Please enter yes or no.\\\",\\n+\\n+ mixed_precision = _ask_field(\\n+ \\\"Do you wish to use FP16 or BF16 (mixed precision)? [No/FP16/BF16]: \\\",\\n+ lambda x: str(x),\\n+ default=\\\"No\\\",\\n )\\n \\n return SageMakerConfig(\\n@@ -153,6 +153,6 @@ def get_sagemaker_input():\\n profile=aws_profile,\\n region=aws_region,\\n iam_role_name=iam_role_name,\\n- fp16=fp16,\\n+ mixed_precision=mixed_precision,\\n num_machines=num_machines,\\n )\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 4f392d6fa..77db4546b 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -19,6 +19,7 @@\\n import os\\n import subprocess\\n import sys\\n+import warnings\\n from ast import literal_eval\\n from pathlib import Path\\n from typing import Dict, List\\n@@ -53,6 +54,16 @@ def launch_command_parser(subparsers=None):\\n parser.add_argument(\\n \\\"--tpu\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not this should launch a TPU training.\\\"\\n )\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ default=\\\"no\\\",\\n+ type=str,\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether or not to use mixed precision training. \\\"\\n+ \\\"Choose between FP16 and BF16 (bfloat16) training. \\\"\\n+ \\\"BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.\\\",\\n+ )\\n+\\n parser.add_argument(\\n \\\"--fp16\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not to use mixed precision training.\\\"\\n )\\n@@ -134,7 +145,16 @@ def simple_launcher(args):\\n \\n current_env = os.environ.copy()\\n current_env[\\\"USE_CPU\\\"] = str(args.cpu)\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+\\n+ mixed_precision = args.mixed_precision.lower()\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+\\n+ if args.fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n+ current_env[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n \\n process = subprocess.Popen(cmd, env=current_env)\\n process.wait()\\n@@ -168,7 +188,16 @@ def multi_gpu_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+\\n+ if args.fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n+ current_env[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n \\n process = subprocess.Popen(cmd, env=current_env)\\n process.wait()\\n@@ -201,7 +230,16 @@ def deepspeed_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n+\\n+ if args.fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n+ current_env[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n current_env[\\\"USE_DEEPSPEED\\\"] = \\\"true\\\"\\n current_env[\\\"DEEPSPEED_ZERO_STAGE\\\"] = str(args.zero_stage)\\n current_env[\\\"GRADIENT_ACCUMULATION_STEPS\\\"] = str(args.gradient_accumulation_steps)\\n@@ -309,8 +347,17 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n print(\\\"Converting Arguments to Hyperparameters\\\")\\n hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n \\n- environment = {\\\"USE_FP16\\\": args.fp16} # Environment variables to be set for use during training job\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(f\\\"Unknown mixed_precision mode: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\")\\n \\n+ if args.fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n+ # Environment variables to be set for use during training job\\n+ environment = {\\\"MIXED_PRECISION\\\": str(mixed_precision)}\\n # configure distribution set up\\n distribution = None # TODO: not yet implemented\\n \\n@@ -360,13 +407,16 @@ def launch_command(args):\\n \\n # Those args are handled separately\\n if (\\n- name not in [\\\"compute_environment\\\", \\\"fp16\\\", \\\"distributed_type\\\"]\\n+ name not in [\\\"compute_environment\\\", \\\"fp16\\\", \\\"mixed_precision\\\", \\\"distributed_type\\\"]\\n and getattr(args, name, None) is None\\n ):\\n setattr(args, name, attr)\\n \\n- if not args.fp16:\\n- args.fp16 = defaults.fp16\\n+ if not args.mixed_precision:\\n+ if args.fp16:\\n+ args.mixed_precision = \\\"fp16\\\"\\n+ else:\\n+ args.mixed_precision = defaults.mixed_precision\\n else:\\n if args.num_processes is None:\\n args.num_processes = 1\\ndiff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex b848e13d4..90b4f826a 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -14,6 +14,7 @@\\n \\n import os\\n import sys\\n+import warnings\\n \\n import torch\\n \\n@@ -23,7 +24,7 @@\\n from .utils import PrepareForLaunch\\n \\n \\n-def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use_port=\\\"29500\\\"):\\n+def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, mixed_precision=\\\"no\\\", use_port=\\\"29500\\\"):\\n \\\"\\\"\\\"\\n Launches a training function, using several processes if it's possible in the current environment (TPU with\\n multiple cores for instance).\\n@@ -37,8 +38,8 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n num_processes (:obj:`int`, `optional`):\\n The number of processes to use for training. Will default to 8 in Colab/Kaggle if a TPU is available, to\\n the number of GPUs available otherwise.\\n- use_fp16 (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n- If :obj:`True`, will use mixed precision training on multi-GPU.\\n+ mixed_precision (:obj:`str`, `optional`, defaults to :obj:`no`):\\n+ If :obj:`fp16` or :obj:`bf16`, will use mixed precision training on multi-GPU.\\n use_port (:obj:`str`, `optional`, defaults to :obj:`\\\"29500\\\"`):\\n The port to use to communicate between processes when launching a multi-GPU training.\\n \\\"\\\"\\\"\\n@@ -110,7 +111,18 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\n- os.environ[\\\"USE_FP16\\\"] = str(use_fp16)\\n+\\n+ mixed_precision = mixed_precision.lower()\\n+ if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\n+ raise ValueError(\\n+ f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+ )\\n+\\n+ if use_fp16:\\n+ warnings.warn('use_fp16=True is deprecated. Use mixed_precision=\\\"fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n+\\n+ os.environ[\\\"MIXED_PRECISION\\\"] = str(mixed_precision)\\n \\n launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n try:\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex e4d536e14..6693a34ca 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -66,6 +66,11 @@ def parse_flag_from_env(key, default=False):\\n return strtobool(value) == 1 # As its name indicates `strtobool` actually returns an int...\\n \\n \\n+def parse_choice_from_env(key, default=\\\"no\\\"):\\n+ value = os.environ.get(key, str(default))\\n+ return value\\n+\\n+\\n class DistributedType(str, Enum):\\n \\\"\\\"\\\"\\n Represents a type of distributed environment.\\n@@ -133,18 +138,25 @@ class AcceleratorState:\\n - **num_processes** (:obj:`int`) -- The number of processes currently launched in parallel.\\n - **process_index** (:obj:`int`) -- The index of the current process.\\n - **local_process_index** (:obj:`int`) -- The index of the current process on the current server.\\n- - **use_fp16** (:obj:`bool`) -- Whether or not the current script will use mixed precision.\\n+ - **mixed_precision** (:obj:`str`) -- Whether or not the current script will use mixed precision. If you are\\n+ using mixed precision, define if you want to use FP16 or BF16 (bfloat16) as the floating point.\\n \\\"\\\"\\\"\\n \\n _shared_state = {}\\n \\n def __init__(\\n- self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False, **kwargs\\n+ self,\\n+ mixed_precision: str = None,\\n+ cpu: bool = False,\\n+ deepspeed_plugin=None,\\n+ _from_accelerator: bool = False,\\n+ **kwargs,\\n ):\\n self.__dict__ = self._shared_state\\n if not getattr(self, \\\"initialized\\\", False):\\n self.backend = None\\n self.deepspeed_plugin = None\\n+ mixed_precision = mixed_precision.lower() if mixed_precision else None\\n if not _from_accelerator:\\n raise ValueError(\\n \\\"Please make sure to properly initialize your accelerator via `accelerator = Accelerator()` \\\"\\n@@ -156,7 +168,7 @@ def __init__(\\n self.process_index = xm.get_ordinal()\\n self.local_process_index = xm.get_local_ordinal()\\n self.device = xm.xla_device()\\n- self.use_fp16 = False\\n+ self.mixed_precision = \\\"no\\\"\\n elif os.environ.get(\\\"USE_DEEPSPEED\\\", \\\"false\\\") == \\\"true\\\" and not cpu:\\n assert (\\n is_deepspeed_available()\\n@@ -170,9 +182,14 @@ def __init__(\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n- self.use_fp16 = False # deepspeed handles fp16 using deepspeed_config\\n- fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n- deepspeed_plugin.deepspeed_config.update({\\\"fp16\\\": {\\\"enabled\\\": fp16}})\\n+ self.mixed_precision = \\\"no\\\" # deepspeed handles mixed_precision using deepspeed_config\\n+ mixed_precision = (\\n+ parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n+ )\\n+ if mixed_precision == \\\"fp16\\\":\\n+ deepspeed_plugin.deepspeed_config.update({\\\"fp16\\\": {\\\"enabled\\\": True}})\\n+ elif mixed_precision == \\\"bf16\\\":\\n+ deepspeed_plugin.deepspeed_config.update({\\\"bfloat16\\\": {\\\"enabled\\\": True}})\\n self.deepspeed_plugin = deepspeed_plugin\\n elif int(os.environ.get(\\\"LOCAL_RANK\\\", -1)) != -1 and not cpu:\\n self.distributed_type = DistributedType.MULTI_GPU\\n@@ -184,7 +201,10 @@ def __init__(\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n- self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ self.mixed_precision = (\\n+ parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n+ )\\n+\\n elif get_int_from_env([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"], 1) > 1:\\n self.distributed_type = DistributedType.MULTI_CPU\\n if is_ccl_available() and get_int_from_env([\\\"CCL_WORKER_COUNT\\\"], 0) > 0:\\n@@ -221,24 +241,32 @@ def __init__(\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = local_rank\\n self.device = torch.device(\\\"cpu\\\")\\n- self.use_fp16 = False\\n+ self.mixed_precision = \\\"no\\\"\\n else:\\n self.distributed_type = DistributedType.NO\\n self.num_processes = 1\\n self.process_index = self.local_process_index = 0\\n self.device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() and not cpu else \\\"cpu\\\")\\n- self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ self.mixed_precision = (\\n+ parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision is None else mixed_precision\\n+ )\\n self.initialized = True\\n \\n def __repr__(self):\\n- use_fp16 = self.deepspeed_plugin.fp16 if self.distributed_type == DistributedType.DEEPSPEED else self.use_fp16\\n+ mixed_precision = self.mixed_precision\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ if self.deepspeed_plugin.fp16:\\n+ mixed_precision = \\\"fp16\\\"\\n+ if self.deepspeed_plugin.bflaot16:\\n+ mixed_precision = \\\"bf16\\\"\\n+\\n repr = (\\n f\\\"Distributed environment: {self.distributed_type}{(' Backend: ' + self.backend) if self.backend else ''}\\\\n\\\"\\n f\\\"Num processes: {self.num_processes}\\\\n\\\"\\n f\\\"Process index: {self.process_index}\\\\n\\\"\\n f\\\"Local process index: {self.local_process_index}\\\\n\\\"\\n f\\\"Device: {self.device}\\\\n\\\"\\n- f\\\"Use FP16 precision: {use_fp16}\\\\n\\\"\\n+ f\\\"Mixed precision type: {mixed_precision}\\\\n\\\"\\n )\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n repr += f\\\"ds_config: {self.deepspeed_plugin.ds_config}\\\\n\\\"\\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex 41efcf61c..ecd8e4f02 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -245,6 +245,29 @@ def training_check():\\n accelerator.print(\\\"Training yielded the same results on one CPU or distributes setup with batch split.\\\")\\n \\n # Mostly a test that FP16 doesn't crash as the operation inside the model is not converted to FP16\\n+ print(\\\"FP16 training check.\\\")\\n+ accelerator = Accelerator(mixed_precision=\\\"fp16\\\")\\n+ train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n+ model = RegressionModel()\\n+ optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n+\\n+ train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)\\n+ set_seed(42)\\n+ generator.manual_seed(42)\\n+ for _ in range(3):\\n+ for batch in train_dl:\\n+ model.zero_grad()\\n+ output = model(batch[\\\"x\\\"])\\n+ loss = torch.nn.functional.mse_loss(output, batch[\\\"y\\\"])\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+\\n+ model = accelerator.unwrap_model(model).cpu()\\n+ assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+ assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+\\n+ # TEST that previous fp16 flag still works\\n+ print(\\\"Legacy FP16 training check.\\\")\\n accelerator = Accelerator(fp16=True)\\n train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n model = RegressionModel()\\n@@ -265,6 +288,28 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n+ # Mostly a test that BF16 doesn't crash as the operation inside the model is not converted to BF16\\n+ print(\\\"BF16 training check.\\\")\\n+ accelerator = Accelerator(mixed_precision=\\\"bf16\\\")\\n+ train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n+ model = RegressionModel()\\n+ optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n+\\n+ train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)\\n+ set_seed(42)\\n+ generator.manual_seed(42)\\n+ for _ in range(3):\\n+ for batch in train_dl:\\n+ model.zero_grad()\\n+ output = model(batch[\\\"x\\\"])\\n+ loss = torch.nn.functional.mse_loss(output, batch[\\\"y\\\"])\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+\\n+ model = accelerator.unwrap_model(model).cpu()\\n+ assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+ assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+\\n \\n def main():\\n accelerator = Accelerator()\\ndiff --git a/src/accelerate/test_utils/training.py b/src/accelerate/test_utils/training.py\\nindex 3cdea4517..2ea86fbb1 100644\\n--- a/src/accelerate/test_utils/training.py\\n+++ b/src/accelerate/test_utils/training.py\\n@@ -36,6 +36,10 @@ def __init__(self, a=0, b=0, double_output=False):\\n super().__init__()\\n self.a = torch.nn.Parameter(torch.tensor(a).float())\\n self.b = torch.nn.Parameter(torch.tensor(b).float())\\n+ self.first_batch = True\\n \\n def forward(self, x=None):\\n+ if self.first_batch:\\n+ print(f\\\"Model dtype: {self.a.dtype}, {self.b.dtype}. Input dtype: {x.dtype}\\\")\\n+ self.first_batch = False\\n return x * self.a + self.b\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 991997282..3af792f1f 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -23,6 +23,8 @@\\n import numpy as np\\n import torch\\n \\n+from packaging import version\\n+\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available, is_tpu_available\\n \\n \\n@@ -240,23 +242,26 @@ def _initialize_tensor(tensor_info):\\n \\n def convert_to_fp32(tensor):\\n \\\"\\\"\\\"\\n- Recursively converts the elements nested list/tuple/dictionary of tensors in FP16 precision to FP32.\\n+ Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.\\n \\n Args:\\n tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n- The data to convert from FP16 to FP32.\\n+ The data to convert from FP16/BF16 to FP32.\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors that were in FP16 precision converted to FP32.\\n+ The same data structure as :obj:`tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n \\\"\\\"\\\"\\n \\n def _convert_to_fp32(tensor):\\n return tensor.float()\\n \\n- def _is_fp16_tensor(tensor):\\n- return hasattr(tensor, \\\"dtype\\\") and tensor.dtype == torch.float16\\n+ def _is_fp16_bf16_tensor(tensor):\\n+ return hasattr(tensor, \\\"dtype\\\") and (\\n+ tensor.dtype == torch.float16\\n+ or (version.parse(torch.__version__) >= version.parse(\\\"1.10\\\") and tensor.dtype == torch.bfloat16)\\n+ )\\n \\n- return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_tensor)\\n+ return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_bf16_tensor)\\n \\n \\n def convert_outputs_to_fp32(model_forward):\\n\",\n \"code_comments\": [\n {\n \"body\": \"Default here should be `None`, and then get the value of `MIXED_PRECISION` (as is done for `fp16`).\",\n \"diff_hunk\": \"@@ -101,12 +106,24 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = \\\"no\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\r\\n```\\r\\nWe're not inside a script, so I would adapt to use arguments: `fp16=True`is deprecated, use `mixed_precision=\\\"fp16\\\"` instead.\",\n \"diff_hunk\": \"@@ -101,12 +106,24 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = \\\"no\\\",\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ mixed_precision = mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+\\n+ if fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\",\n \"from_author\": false\n },\n {\n \"body\": \"Rephrase as a test and raise a ValueError:\\r\\n```\\r\\nif mixed_precision not in [...]:\\r\\n raise ValueError(...)\\r\\n```\",\n \"diff_hunk\": \"@@ -101,12 +106,24 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = \\\"no\\\",\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ mixed_precision = mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n return self.mixed_precision != \\\"no\\\":\\r\\n```\\r\\nSeems easier this way.\",\n \"diff_hunk\": \"@@ -195,11 +220,23 @@ def is_local_main_process(self):\\n \\n @property\\n def use_fp16(self):\\n+ if self.mixed_precision != \\\"no\\\":\\n+ return True\\n+ else:\\n+ return False\",\n \"from_author\": false\n },\n {\n \"body\": \"We have to be a bit more careful here and add a version test, as the argument `dtype` was only introduce in PyTorch 1.10. So this first test should include\\r\\n```\\r\\nand version.parse(torch.__version__) >= version.parse(\\\"1.10\\\")\\r\\n```\\r\\notherwise we will fall in the else branch at the end.\",\n \"diff_hunk\": \"@@ -311,7 +348,12 @@ def prepare_model(self, model):\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n if self.native_amp:\\n- model.forward = torch.cuda.amp.autocast()(model.forward)\\n+ if self.mixed_precision == \\\"fp16\\\":\\n+ model.forward = torch.cuda.amp.autocast(dtype=torch.float16)(model.forward)\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -577,7 +619,13 @@ def autocast(self):\\n different will happen otherwise.\\n \\\"\\\"\\\"\\n if self.native_amp:\\n- autocast_context = torch.cuda.amp.autocast()\\n+ if self.mixed_precision == \\\"fp16\\\":\",\n \"from_author\": false\n },\n {\n \"body\": \"It should also be added in the `from_json_file` method above for backward compatibility, and I think we should remove the fp16 key as well, to fully convert the config to the new format.\",\n \"diff_hunk\": \"@@ -97,6 +98,12 @@ def from_yaml_file(cls, yaml_file=None):\\n config_dict = yaml.safe_load(f)\\n if \\\"compute_environment\\\" not in config_dict:\\n config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ if \\\"mixed_precision\\\" not in config_dict:\",\n \"from_author\": false\n },\n {\n \"body\": \"As before, use a test and raise a ValueError here.\",\n \"diff_hunk\": \"@@ -134,7 +146,19 @@ def simple_launcher(args):\\n \\n current_env = os.environ.copy()\\n current_env[\\\"USE_CPU\\\"] = str(args.cpu)\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+\\n+ mixed_precision = args.mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -168,7 +192,18 @@ def multi_gpu_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Same here.\",\n \"diff_hunk\": \"@@ -201,7 +236,18 @@ def deepspeed_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"And same here.\",\n \"diff_hunk\": \"@@ -309,8 +355,20 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n print(\\\"Converting Arguments to Hyperparameters\\\")\\n hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n \\n- environment = {\\\"USE_FP16\\\": args.fp16} # Environment variables to be set for use during training job\\n+ mixed_precision = args.mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Nit, put the comment before and have the dict on one line:\\r\\n```suggestion\\r\\n # Environment variables to be set for use during training job\\r\\n environment = {\\\"MIXED_PRECISION\\\": str(mixed_precision)}\\r\\n```\",\n \"diff_hunk\": \"@@ -309,8 +355,20 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n print(\\\"Converting Arguments to Hyperparameters\\\")\\n hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n \\n- environment = {\\\"USE_FP16\\\": args.fp16} # Environment variables to be set for use during training job\\n+ mixed_precision = args.mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\\n+\\n+ if args.fp16:\\n+ warnings.warn('--fp16 flag is deprecated. Use \\\"--mixed_precision fp16\\\" instead.', DeprecationWarning)\\n+ mixed_precision = \\\"fp16\\\"\\n \\n+ environment = {\\n+ \\\"MIXED_PRECISION\\\": str(mixed_precision)\\n+ } # Environment variables to be set for use during training job\",\n \"from_author\": false\n },\n {\n \"body\": \"As before, raise a value error here.\",\n \"diff_hunk\": \"@@ -110,7 +113,19 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\n- os.environ[\\\"USE_FP16\\\"] = str(use_fp16)\\n+\\n+ mixed_precision = mixed_precision.lower()\\n+ assert mixed_precision in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ], f\\\"Unknown mixed_precision: {mixed_precision}. Choose between 'no', 'fp16' and 'bf16'.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Should be `None` here\",\n \"diff_hunk\": \"@@ -133,18 +138,25 @@ class AcceleratorState:\\n - **num_processes** (:obj:`int`) -- The number of processes currently launched in parallel.\\n - **process_index** (:obj:`int`) -- The index of the current process.\\n - **local_process_index** (:obj:`int`) -- The index of the current process on the current server.\\n- - **use_fp16** (:obj:`bool`) -- Whether or not the current script will use mixed precision.\\n+ - **mixed_precision** (:obj:`str`) -- Whether or not the current script will use mixed precision. If\\n+ you are using mixed precision, define if you want to use FP16 or BF16 (bfloat16) as the floating point.\\n \\\"\\\"\\\"\\n \\n _shared_state = {}\\n \\n def __init__(\\n- self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False, **kwargs\\n+ self,\\n+ mixed_precision: str = \\\"no\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"Test for None before lowering there.\",\n \"diff_hunk\": \"@@ -133,18 +138,25 @@ class AcceleratorState:\\n - **num_processes** (:obj:`int`) -- The number of processes currently launched in parallel.\\n - **process_index** (:obj:`int`) -- The index of the current process.\\n - **local_process_index** (:obj:`int`) -- The index of the current process on the current server.\\n- - **use_fp16** (:obj:`bool`) -- Whether or not the current script will use mixed precision.\\n+ - **mixed_precision** (:obj:`str`) -- Whether or not the current script will use mixed precision. If\\n+ you are using mixed precision, define if you want to use FP16 or BF16 (bfloat16) as the floating point.\\n \\\"\\\"\\\"\\n \\n _shared_state = {}\\n \\n def __init__(\\n- self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False, **kwargs\\n+ self,\\n+ mixed_precision: str = \\\"no\\\",\\n+ cpu: bool = False,\\n+ deepspeed_plugin=None,\\n+ _from_accelerator: bool = False,\\n+ **kwargs,\\n ):\\n self.__dict__ = self._shared_state\\n if not getattr(self, \\\"initialized\\\", False):\\n self.backend = None\\n self.deepspeed_plugin = None\\n+ mixed_precision = mixed_precision.lower()\",\n \"from_author\": false\n },\n {\n \"body\": \"Get the env variable when `mixed_precision` is None\",\n \"diff_hunk\": \"@@ -170,9 +182,14 @@ def __init__(\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n- self.use_fp16 = False # deepspeed handles fp16 using deepspeed_config\\n- fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n- deepspeed_plugin.deepspeed_config.update({\\\"fp16\\\": {\\\"enabled\\\": fp16}})\\n+ self.mixed_precision = \\\"no\\\" # deepspeed handles mixed_precision using deepspeed_config\\n+ mixed_precision = (\\n+ parse_choice_from_env(\\\"MIXED_PRECISION\\\", \\\"no\\\") if mixed_precision == \\\"no\\\" else mixed_precision\",\n \"from_author\": false\n },\n {\n \"body\": \"This would also need a version check, as I'm not sure the `torch.bfloat16` was there in PyTorch 1.6.\",\n \"diff_hunk\": \"@@ -240,23 +240,23 @@ def _initialize_tensor(tensor_info):\\n \\n def convert_to_fp32(tensor):\\n \\\"\\\"\\\"\\n- Recursively converts the elements nested list/tuple/dictionary of tensors in FP16 precision to FP32.\\n+ Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.\\n \\n Args:\\n tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n- The data to convert from FP16 to FP32.\\n+ The data to convert from FP16/BF16 to FP32.\\n \\n Returns:\\n- The same data structure as :obj:`tensor` with all tensors that were in FP16 precision converted to FP32.\\n+ The same data structure as :obj:`tensor` with all tensors that were in FP16/BF16 precision converted to FP32.\\n \\\"\\\"\\\"\\n \\n def _convert_to_fp32(tensor):\\n return tensor.float()\\n \\n- def _is_fp16_tensor(tensor):\\n- return hasattr(tensor, \\\"dtype\\\") and tensor.dtype == torch.float16\\n+ def _is_fp16_bf16_tensor(tensor):\\n+ return hasattr(tensor, \\\"dtype\\\") and (tensor.dtype == torch.float16 or tensor.dtype == torch.bfloat16)\",\n \"from_author\": false\n },\n {\n \"body\": \"Version test added \",\n \"diff_hunk\": \"@@ -311,7 +348,12 @@ def prepare_model(self, model):\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n if self.native_amp:\\n- model.forward = torch.cuda.amp.autocast()(model.forward)\\n+ if self.mixed_precision == \\\"fp16\\\":\\n+ model.forward = torch.cuda.amp.autocast(dtype=torch.float16)(model.forward)\",\n \"from_author\": true\n },\n {\n \"body\": \"I forgot about the \\\"from_json_file\\\" method, i have updated it too and I added a line to delete the fp16 key from old config files\",\n \"diff_hunk\": \"@@ -97,6 +98,12 @@ def from_yaml_file(cls, yaml_file=None):\\n config_dict = yaml.safe_load(f)\\n if \\\"compute_environment\\\" not in config_dict:\\n config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ if \\\"mixed_precision\\\" not in config_dict:\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision is not None:\\r\\n```\\r\\nWe usually prefer explicit tests instead of relying on Python's bool conversion.\",\n \"diff_hunk\": \"@@ -101,12 +106,29 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = None,\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+\\n+ if mixed_precision:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\\r\\nShould fit in one line now.\",\n \"diff_hunk\": \"@@ -101,12 +106,29 @@ def __init__(\\n device_placement: bool = True,\\n split_batches: bool = False,\\n fp16: bool = None,\\n+ mixed_precision: str = None,\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+\\n+ if mixed_precision:\\n+ mixed_precision = mixed_precision.lower()\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n },\n {\n \"body\": \"I realize we are silently not training in mixed precision when:\\r\\n- `mixed_precision=\\\"fp16\\\"` and torch version is < 1.6\\r\\n- `mixed_precision=\\\"bf16\\\"` and torch version is < 1.10\\r\\n\\r\\nI think we should raise an error message in both cases, or at least a warning.\",\n \"diff_hunk\": \"@@ -149,10 +175,14 @@ def __init__(\\n # Mixed precision attributes\\n self.scaler = None\\n self.native_amp = False\\n- if self.state.use_fp16:\\n+ if self.state.mixed_precision == \\\"fp16\\\":\\n self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.6\\\")\\n kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}\\n self.scaler = torch.cuda.amp.GradScaler(**kwargs)\\n+ elif self.state.mixed_precision == \\\"bf16\\\":\\n+ self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.10\\\")\\n+ kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}\\n+ self.scaler = torch.cuda.amp.GradScaler(**kwargs)\",\n \"from_author\": false\n },\n {\n \"body\": \"Nice!\",\n \"diff_hunk\": \"@@ -97,6 +98,12 @@ def from_yaml_file(cls, yaml_file=None):\\n config_dict = yaml.safe_load(f)\\n if \\\"compute_environment\\\" not in config_dict:\\n config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ if \\\"mixed_precision\\\" not in config_dict:\",\n \"from_author\": false\n },\n {\n \"body\": \"No need for this new line I think.\\r\\n```suggestion\\r\\n```\",\n \"diff_hunk\": \"@@ -53,9 +54,20 @@ def launch_command_parser(subparsers=None):\\n parser.add_argument(\\n \\\"--tpu\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not this should launch a TPU training.\\\"\\n )\\n+ parser.add_argument(\\n+ \\\"--mixed_precision\\\",\\n+ default=\\\"no\\\",\\n+ type=str,\\n+ choices=[\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"],\\n+ help=\\\"Whether or not to use mixed precision training. \\\"\\n+ \\\"Choose between FP16 and BF16 (bfloat16) training. \\\"\\n+ \\\"BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.\\\",\\n+ )\\n+\\n parser.add_argument(\\n \\\"--fp16\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not to use mixed precision training.\\\"\\n )\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\",\n \"diff_hunk\": \"@@ -134,7 +146,20 @@ def simple_launcher(args):\\n \\n current_env = os.environ.copy()\\n current_env[\\\"USE_CPU\\\"] = str(args.cpu)\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+\\n+ mixed_precision = args.mixed_precision.lower()\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\",\n \"diff_hunk\": \"@@ -168,7 +193,20 @@ def multi_gpu_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\",\n \"diff_hunk\": \"@@ -201,7 +239,20 @@ def deepspeed_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n- current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\",\n \"diff_hunk\": \"@@ -309,8 +360,21 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n print(\\\"Converting Arguments to Hyperparameters\\\")\\n hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n \\n- environment = {\\\"USE_FP16\\\": args.fp16} # Environment variables to be set for use during training job\\n+ mixed_precision = args.mixed_precision.lower()\\n+\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n },\n {\n \"body\": \"You can remove this from the documentation (we try to avoid documenting deprecated args so users don't start using them).\",\n \"diff_hunk\": \"@@ -39,6 +40,8 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n the number of GPUs available otherwise.\\n use_fp16 (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n If :obj:`True`, will use mixed precision training on multi-GPU.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if mixed_precision not in [\\\"no\\\", \\\"fp16\\\", \\\"bf16\\\"]:\\r\\n```\",\n \"diff_hunk\": \"@@ -110,7 +113,22 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\n- os.environ[\\\"USE_FP16\\\"] = str(use_fp16)\\n+\\n+ mixed_precision = mixed_precision.lower()\\n+ if mixed_precision not in [\\n+ \\\"no\\\",\\n+ \\\"fp16\\\",\\n+ \\\"bf16\\\",\\n+ ]:\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"I have updated the PR with the fixes you mention \",\n \"from_author\": true\n },\n {\n \"body\": \"Let me know if you need any help with the last standing comments. When you're finished, make sure to run `make style` on your branch so that the quality check passes :-)\",\n \"from_author\": false\n },\n {\n \"body\": \"I think they are solved now. Maybe we should add a warning in 'cluster.py' to warn if the user chooses the \\\"fp16\\\" or \\\"bf16\\\" option but doesn't have the correct version of Pytorch installed?\",\n \"from_author\": true\n },\n {\n \"body\": \"This [comment](https://github.com/huggingface/accelerate/pull/247/files#r800669214) and this [one](https://github.com/huggingface/accelerate/pull/247/files#r800671521) don't seem to have been addressed. Could you take care of them?\\r\\nQuality check is also still failing.\\r\\n\\r\\nWe can also add warnings when the options are chosen, yes!\",\n \"from_author\": false\n },\n {\n \"body\": \"Sorry the previous commit to solve the problem of silently not training in mixed precision was incorrect. I have a question about implementation. If the version is correct we set self.native_amp to True. \\r\\n```Python\\r\\nself.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.6\\\")\\r\\n```\\r\\nIf the version is incorrect we disable mixed precision by setting that variable to False. Is it used for anything else? If we are going to raise an error, should we remove it? \\r\\nShould we raise a error always if the pytorch version is not correct? I'm not sure I understand this part of the code 100% and I don't know if I've implemented right the errors if the pytorch version is not compatible with the chosen mixed precision. \\r\\n\\r\\n\",\n \"from_author\": true\n },\n {\n \"body\": \"We should at least raise a warning, to tell the user that we are not delivering what they asked for.\",\n \"from_author\": false\n },\n {\n \"body\": \"What I mean is that what I have done is adding the following code (same for bf16 but it checks pytorch 1.10). This raises an error if you try to run \\\"fp16\\\" with Pytorch < 1.6. However, the previous line sets self.native_amp=True with the oposite condition. \\r\\nWe will never run the training if native_amp = False because we raise an error. Is this the correct behavior? If it is, should we keep the native_amp variable?\\r\\n\\r\\n```Python\\r\\nif self.state.mixed_precision == \\\"fp16\\\":\\r\\n self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.6\\\")\\r\\n if version.parse(torch.__version__) < version.parse(\\\"1.6\\\"):\\r\\n raise ValueError(\\\"fp16 mixed precision requires PyTorch >= 1.6\\\")\\r\\n```\",\n \"from_author\": true\n },\n {\n \"body\": \"The way you did it is great! Thanks again for your awesome contribution :-)\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/247\",\n \"pr_id\": 840384554\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 76c3067a3..d3e4fa603 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -302,10 +302,7 @@ def prepare_model(self, model):\\n if self.distributed_type == DistributedType.MULTI_GPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(\\n- model,\\n- device_ids=[self.local_process_index],\\n- output_device=self.local_process_index,\\n- **kwargs,\\n+ model, device_ids=[self.local_process_index], output_device=self.local_process_index, **kwargs\\n )\\n elif self.distributed_type == DistributedType.MULTI_CPU:\\n kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n@@ -352,8 +349,12 @@ def _prepare_deepspeed(self, *args):\\n is_adamw = isinstance(optimizer, torch.optim.AdamW)\\n if (is_adam or is_adamw) and deepspeed_plugin.offload_optimizer_device == \\\"cpu\\\":\\n defaults = optimizer.defaults\\n+ params = []\\n+ for group in optimizer.param_groups:\\n+ params.extend(group[\\\"params\\\"])\\n+\\n optimizer = deepspeed.ops.adam.DeepSpeedCPUAdam(\\n- model.parameters(),\\n+ params,\\n lr=defaults[\\\"lr\\\"],\\n bias_correction=True,\\n betas=defaults[\\\"betas\\\"],\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Could you just run `make style` on your branch to fix the quality issue? Thanks!\",\n \"from_author\": false\n },\n {\n \"body\": \"is this okay? it looks like there are a few other lines in there that also got style fixed\",\n \"from_author\": true\n },\n {\n \"body\": \"Looks good, thanks again!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/246\",\n \"pr_id\": 839822455\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 443c55622..6eba4b295 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -118,11 +118,11 @@ def honor_type(obj, generator):\\n \\\"\\\"\\\"\\n Cast a generator to the same type as obj (list, tuple or namedtuple)\\n \\\"\\\"\\\"\\n- # There is no direct check whether an object if of type namedtuple sadly, this is a workaround.\\n- if isinstance(obj, tuple) and hasattr(obj, \\\"_fields\\\"):\\n- # Can instantiate a namedtuple from a generator directly, contrary to a tuple/list.\\n+ try:\\n+ return type(obj)(generator)\\n+ except TypeError:\\n+ # Some objects may not be able to instantiate from a generator directly\\n return type(obj)(*list(generator))\\n- return type(obj)(generator)\\n \\n \\n def is_torch_tensor(tensor):\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Sorry I was on my Chinese new year leave and just get back.\\r\\nYeah I do agree this should raise exact error with enough information for debugging.\",\n \"from_author\": true\n },\n {\n \"body\": \"Could you just run `male style` on your branch so we can merge this?\",\n \"from_author\": false\n },\n {\n \"body\": \"hi, I just noticed the existence of this pr......\\r\\nI've fixed the linting issue related to this pr, but there seems to be more on other code\",\n \"from_author\": true\n },\n {\n \"body\": \"Seems like the checks are all passing now, thanks again!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/241\",\n \"pr_id\": 834108210\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 3af792f1f..36eaea592 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -18,7 +18,7 @@\\n from collections.abc import Mapping\\n from dataclasses import dataclass, field\\n from enum import Enum\\n-from typing import List, Optional, Union\\n+from typing import Any, List, Optional, Union\\n \\n import numpy as np\\n import torch\\n@@ -350,6 +350,39 @@ def gather(tensor):\\n return tensor\\n \\n \\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(AcceleratorState().num_processes)]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return output_objects\\n+\\n+ return recursively_apply(_gpu_gather_object_one, object)\\n+\\n+\\n+_cpu_gather_object = _gpu_gather_object\\n+\\n+\\n+def gather_object(object: Any):\\n+ \\\"\\\"\\\"\\n+ Recursively gather object in a nested list/tuple/dictionary of objects from all devices.\\n+\\n+ Args:\\n+ object (nested list/tuple/dictionary of picklable object):\\n+ The data to gather.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`object` with all the objects sent to every device.\\n+ \\\"\\\"\\\"\\n+ if AcceleratorState().distributed_type == DistributedType.TPU:\\n+ raise NotImplementedError(\\\"gather objects in TPU is not supported\\\")\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ return _gpu_gather_object(object)\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n+ return _cpu_gather_object(object)\\n+ else:\\n+ return object\\n+\\n+\\n def _gpu_broadcast(data, src=0):\\n def _gpu_broadcast_one(tensor, src=0):\\n torch.distributed.broadcast(tensor, src=src)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n object (nested list/tuple/dictionary of any object):\\r\\n```\",\n \"diff_hunk\": \"@@ -345,6 +345,40 @@ def gather(tensor):\\n return tensor\\n \\n \\n+\\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(torch.distributed.get_world_size())]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return [i for j in output_objects for i in j]\\n+\\n+ return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)\\n+\\n+\\n+_cpu_gather_object = _gpu_gather_object\\n+\\n+\\n+def gather_object(object: Any):\\n+ \\\"\\\"\\\"\\n+ Recursively gather object in a nested list/tuple/dictionary of objects from all devices.\\n+\\n+ Args:\\n+ object (nested list/tuple/dictionary of :obj:`Any`):\",\n \"from_author\": false\n },\n {\n \"body\": \"Here we should use the `state.num_processes` instead.\",\n \"diff_hunk\": \"@@ -345,6 +345,40 @@ def gather(tensor):\\n return tensor\\n \\n \\n+\\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(torch.distributed.get_world_size())]\",\n \"from_author\": false\n },\n {\n \"body\": \"I don't understand this line. This presupposes that every element in `output_objects` is iterable, but `object` is supposed to be a primitive object at this point (tensor or other if we remove `error_on_type=True`).\",\n \"diff_hunk\": \"@@ -345,6 +345,40 @@ def gather(tensor):\\n return tensor\\n \\n \\n+\\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(torch.distributed.get_world_size())]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return [i for j in output_objects for i in j]\",\n \"from_author\": false\n },\n {\n \"body\": \"`torch.all_gather_object` works for all picklable objects, so we can skip the `error_on_other_type=True` I believe.\",\n \"diff_hunk\": \"@@ -345,6 +345,40 @@ def gather(tensor):\\n return tensor\\n \\n \\n+\\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(torch.distributed.get_world_size())]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return [i for j in output_objects for i in j]\\n+\\n+ return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n The same data structure as :obj:`object` with all the objects sent to every device.\\r\\n```\\r\\nI think we need to explain where the list arrives (since each tensor is replaced by a list of tensors normally).\",\n \"diff_hunk\": \"@@ -345,6 +345,40 @@ def gather(tensor):\\n return tensor\\n \\n \\n+\\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(torch.distributed.get_world_size())]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return [i for j in output_objects for i in j]\\n+\\n+ return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)\\n+\\n+\\n+_cpu_gather_object = _gpu_gather_object\\n+\\n+\\n+def gather_object(object: Any):\\n+ \\\"\\\"\\\"\\n+ Recursively gather object in a nested list/tuple/dictionary of objects from all devices.\\n+\\n+ Args:\\n+ object (nested list/tuple/dictionary of :obj:`Any`):\\n+ The data to gather.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`Any` with all objects sent to the proper device.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n output_objects = [None for _ in range(AcceleratorState().num_processes)]\\r\\n```\\r\\n`state` is not defined.\",\n \"diff_hunk\": \"@@ -350,6 +350,39 @@ def gather(tensor):\\n return tensor\\n \\n \\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(state.num_processes)]\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n return recursively_apply(_gpu_gather_object_one, object)\\r\\n```\",\n \"diff_hunk\": \"@@ -350,6 +350,39 @@ def gather(tensor):\\n return tensor\\n \\n \\n+def _gpu_gather_object(object: Any):\\n+ def _gpu_gather_object_one(object: Any):\\n+ output_objects = [None for _ in range(state.num_processes)]\\n+ torch.distributed.all_gather_object(output_objects, object)\\n+ return output_objects\\n+\\n+ return recursively_apply(_gpu_gather_one, tensor)\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"> I don't understand this line. This presupposes that every element in output_objects is iterable, but object is supposed to be a primitive object at this point (tensor or other if we remove error_on_type=True).\\r\\n\\r\\nShould we separate `gather_object` to two functions, `gather_object_list` perform `[i for j in output_objects for i in j]` so it works much like original `gather`, while `gather_object` doesn not perform concatenation so it has better support for every objects\\r\\n\\r\\nOr maybe we could add an argument to control it's behavior like\\r\\n\\r\\n```python\\r\\ndef _gpu_gather_object(object: Any, concat: bool = True):\\r\\n def _gpu_gather_object_one(object: Any):\\r\\n output_objects = [None for _ in range(torch.distributed.get_world_size())]\\r\\n torch.distributed.all_gather_object(output_objects, object)\\r\\n if concat:\\r\\n return [i for j in output_objects for i in j]\\r\\n else:\\r\\n return output_objects \\r\\n```\",\n \"from_author\": true\n },\n {\n \"body\": \"It can't really concatenate if the tensors are not of the same size, so `gather_object` should not concatenate IMO.\",\n \"from_author\": false\n },\n {\n \"body\": \"> It can't really concatenate if the tensors are not of the same size, so `gather_object` should not concatenate IMO.\\r\\n\\r\\nYes we can leave it to the user to concat manually. \",\n \"from_author\": true\n },\n {\n \"body\": \"I have resolved all conversations, could you please review it again?\",\n \"from_author\": true\n },\n {\n \"body\": \"> Thanks for addressing all comments, this looks good to merge! Could you just run `make style` on your branch to fix the quality failure?\\r\\n\\r\\nSorry for this late reply.... I believe I've resolved the quality issue.\",\n \"from_author\": true\n },\n {\n \"body\": \"> Here is how to solve the last quality issues (variables not defined).\\r\\n\\r\\nThank you for your kind suggestions! I have resolved these\\r\\n(Sorry I'm recently experiencing some computer issues and `make style` is not giving me full outputs. \",\n \"from_author\": true\n },\n {\n \"body\": \"Hmmmm, is it possible for us to determine the type of input data and auto call corresponding gather function? I just noticed [torchvison](https://github.com/pytorch/vision/blob/main/references/detection/utils.py#L70-L83) uses `gather_object` at all time\",\n \"from_author\": true\n },\n {\n \"body\": \"That's too magical for Accelerate's philosophy, users should pick which function they want to use.\\r\\n\\r\\nAll green now so we can merge your PR :-) Thanks again!\",\n \"from_author\": false\n },\n {\n \"body\": \"> That's too magical for Accelerate's philosophy, users should pick which function they want to use.\\n\\nHaha, thats the reason why i love this repo so much. Users should be trained programmer and should know what they're doing/supposed to do. \\n\\n> All green now so we can merge your PR :-) Thanks again!\\n\\nThank you for all the review and comments~\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/238\",\n \"pr_id\": 832196804\n },\n {\n \"diff\": \"diff --git a/docs/source/installation.md b/docs/source/installation.md\\nindex 6dac579e9..ca2f88286 100644\\n--- a/docs/source/installation.md\\n+++ b/docs/source/installation.md\\n@@ -73,7 +73,7 @@ If you want to constantly use the bleeding edge `master` version of the source c\\n \\n ``` bash\\n git clone https://github.com/huggingface/accelerate.git\\n-cd transformers\\n+cd accelerate\\n pip install -e .\\n ```\\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Sorry I forgot to merge for some reason...\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/234\",\n \"pr_id\": 825368983\n },\n {\n \"diff\": \"diff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex aad2b8b65..a1f310271 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -125,7 +125,7 @@ def collate_fn(examples):\\n lr_scheduler = get_linear_schedule_with_warmup(\\n optimizer=optimizer,\\n num_warmup_steps=100,\\n- num_training_steps=len(train_dataloader) * num_epochs,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n )\\n \\n # Now we train the model\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex f94b2cd99..76c3067a3 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -22,7 +22,7 @@\\n from packaging import version\\n \\n from .data_loader import prepare_data_loader\\n-from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, KwargsHandler\\n+from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n from .utils import (\\n@@ -114,15 +114,10 @@ def __init__(\\n deepspeed_plugin, DeepSpeedPlugin\\n ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\n \\n- self.state = AcceleratorState(fp16=fp16, cpu=cpu, deepspeed_plugin=deepspeed_plugin, _from_accelerator=True)\\n-\\n- self.device_placement = device_placement\\n- self.split_batches = split_batches\\n- self.dispatch_batches = dispatch_batches\\n-\\n # Kwargs handlers\\n self.ddp_handler = None\\n self.scaler_handler = None\\n+ self.init_handler = None\\n if kwargs_handlers is not None:\\n for handler in kwargs_handlers:\\n assert isinstance(handler, KwargsHandler), f\\\"Unsupported kwargs handler passed: {handler}.\\\"\\n@@ -136,6 +131,20 @@ def __init__(\\n raise ValueError(\\\"You can only pass one `GradScalerKwargs` in `kwargs_handler`.\\\")\\n else:\\n self.scaler_handler = handler\\n+ elif isinstance(handler, InitProcessGroupKwargs):\\n+ if self.init_handler is not None:\\n+ raise ValueError(\\\"You can only pass one `InitProcessGroupKwargs` in `kwargs_handler`.\\\")\\n+ else:\\n+ self.init_handler = handler\\n+\\n+ kwargs = self.init_handler.to_kwargs() if self.init_handler is not None else {}\\n+ self.state = AcceleratorState(\\n+ fp16=fp16, cpu=cpu, deepspeed_plugin=deepspeed_plugin, _from_accelerator=True, **kwargs\\n+ )\\n+\\n+ self.device_placement = device_placement\\n+ self.split_batches = split_batches\\n+ self.dispatch_batches = dispatch_batches\\n \\n # Mixed precision attributes\\n self.scaler = None\\ndiff --git a/src/accelerate/kwargs_handlers.py b/src/accelerate/kwargs_handlers.py\\nindex 7f52d6639..51760efdc 100644\\n--- a/src/accelerate/kwargs_handlers.py\\n+++ b/src/accelerate/kwargs_handlers.py\\n@@ -14,6 +14,8 @@\\n \\n import copy\\n from dataclasses import dataclass\\n+from datetime import timedelta\\n+from typing import Optional\\n \\n \\n class KwargsHandler:\\n@@ -71,3 +73,16 @@ class GradScalerKwargs(KwargsHandler):\\n backoff_factor: float = 0.5\\n growth_interval: int = 2000\\n enabled: bool = True\\n+\\n+\\n+@dataclass\\n+class InitProcessGroupKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your :class:`~accelerate.Accelerator` to customize the initialization of the distributed\\n+ processes. Please refer to the documentation of this `method\\n+ <https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group>`__ for more information on\\n+ each argument.\\n+ \\\"\\\"\\\"\\n+\\n+ init_method: Optional[str] = None\\n+ timeout: timedelta = timedelta(seconds=1800)\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 5b349fc38..e4d536e14 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -138,7 +138,9 @@ class AcceleratorState:\\n \\n _shared_state = {}\\n \\n- def __init__(self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False):\\n+ def __init__(\\n+ self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False, **kwargs\\n+ ):\\n self.__dict__ = self._shared_state\\n if not getattr(self, \\\"initialized\\\", False):\\n self.backend = None\\n@@ -161,7 +163,7 @@ def __init__(self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None,\\n ), \\\"DeepSpeed is not available => install it using `pip3 install deepspeed` or build it from source\\\"\\n self.distributed_type = DistributedType.DEEPSPEED\\n if not torch.distributed.is_initialized():\\n- torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ torch.distributed.init_process_group(backend=\\\"nccl\\\", **kwargs)\\n self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n@@ -175,7 +177,7 @@ def __init__(self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None,\\n elif int(os.environ.get(\\\"LOCAL_RANK\\\", -1)) != -1 and not cpu:\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n- torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ torch.distributed.init_process_group(backend=\\\"nccl\\\", **kwargs)\\n self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n@@ -213,7 +215,7 @@ def __init__(self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None,\\n \\\"please try exporting rank 0's hostname as MASTER_ADDR\\\"\\n )\\n if not torch.distributed.is_initialized():\\n- torch.distributed.init_process_group(backend, rank=rank, world_size=size)\\n+ torch.distributed.init_process_group(backend, rank=rank, world_size=size, **kwargs)\\n self.backend = backend\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/228\",\n \"pr_id\": 817943268\n },\n {\n \"diff\": \"diff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex aad2b8b65..a1f310271 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -125,7 +125,7 @@ def collate_fn(examples):\\n lr_scheduler = get_linear_schedule_with_warmup(\\n optimizer=optimizer,\\n num_warmup_steps=100,\\n- num_training_steps=len(train_dataloader) * num_epochs,\\n+ num_training_steps=(len(train_dataloader) * num_epochs) // gradient_accumulation_steps,\\n )\\n \\n # Now we train the model\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \":+1: \",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/227\",\n \"pr_id\": 817932480\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 4269242b4..52217ba6a 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -53,19 +53,27 @@ class AcceleratedOptimizer(torch.optim.Optimizer):\\n def __init__(self, optimizer, device_placement=True, scaler=None):\\n self.optimizer = optimizer\\n self.scaler = scaler\\n- self.state = AcceleratorState()\\n+ self.accelerator_state = AcceleratorState()\\n self.device_placement = device_placement\\n self._is_overflow = False\\n \\n # Handle device placement\\n if device_placement:\\n state_dict = self.optimizer.state_dict()\\n- if self.state.distributed_type == DistributedType.TPU:\\n- xm.send_cpu_data_to_device(state_dict, self.state.device)\\n+ if self.accelerator_state.distributed_type == DistributedType.TPU:\\n+ xm.send_cpu_data_to_device(state_dict, self.accelerator_state.device)\\n else:\\n- state_dict = move_to_device(state_dict, self.state.device)\\n+ state_dict = move_to_device(state_dict, self.accelerator_state.device)\\n self.optimizer.load_state_dict(state_dict)\\n \\n+ @property\\n+ def state(self):\\n+ return self.optimizer.state\\n+\\n+ @state.setter\\n+ def state(self, state):\\n+ self.optimizer.state = state\\n+\\n @property\\n def param_groups(self):\\n return self.optimizer.param_groups\\n@@ -86,8 +94,8 @@ def add_param_group(self, param_group):\\n self.optimizer.add_param_group(param_group)\\n \\n def load_state_dict(self, state_dict):\\n- if self.state.distributed_type == DistributedType.TPU and self.device_placement:\\n- xm.send_cpu_data_to_device(state_dict, self.state.device)\\n+ if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:\\n+ xm.send_cpu_data_to_device(state_dict, self.accelerator_state.device)\\n self.optimizer.load_state_dict(state_dict)\\n \\n def state_dict(self):\\n@@ -113,7 +121,7 @@ def zero_grad(self, set_to_none=None):\\n self.optimizer.zero_grad()\\n \\n def step(self, closure=None):\\n- if self.state.distributed_type == DistributedType.TPU:\\n+ if self.accelerator_state.distributed_type == DistributedType.TPU:\\n optimizer_args = {\\\"closure\\\": closure} if closure is not None else {}\\n xm.optimizer_step(self.optimizer, optimizer_args=optimizer_args)\\n elif self.scaler is not None:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/224\",\n \"pr_id\": 813542932\n },\n {\n \"diff\": \"diff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 73f8ecc0b..b28f24fc6 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -335,6 +335,7 @@ def __iter__(self):\\n # We only iterate through the DataLoader on process 0.\\n main_iterator = super().__iter__()\\n stop_iteration = False\\n+ first_batch = None\\n while not stop_iteration:\\n # On process 0, we gather the batch to dispatch.\\n if state.process_index == 0:\\n@@ -382,7 +383,18 @@ def __iter__(self):\\n # Broadcast the batch before splitting it.\\n batch = broadcast(batch, from_process=0)\\n \\n- batch_size = find_batch_size(batch) // state.num_processes\\n+ if not self.drop_last and first_batch is None:\\n+ # We keep at least num processes elements of the first batch to be able to complete the last batch\\n+ first_batch = slice_tensors(batch, slice(0, state.num_processes))\\n+\\n+ observed_batch_size = find_batch_size(batch)\\n+ batch_size = observed_batch_size // state.num_processes\\n+\\n+ if not self.drop_last and stop_iteration and observed_batch_size % state.num_processes != 0:\\n+ # If the last batch is not complete, let's add the first batch to it.\\n+ batch = concatenate([batch, first_batch], dim=0)\\n+ batch_size += 1\\n+\\n data_slice = slice(state.process_index * batch_size, (state.process_index + 1) * batch_size)\\n \\n if state.distributed_type == DistributedType.TPU:\\n@@ -534,6 +546,7 @@ def prepare_data_loader(\\n \\n # Need to provide batch_size as batch_sampler is None for Iterable dataset\\n if new_batch_sampler is None:\\n+ kwargs[\\\"drop_last\\\"] = dataloader.drop_last\\n kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\n \\n if dispatch_batches:\\n\",\n \"code_comments\": [\n {\n \"body\": \"Will this run twice on the first batch in case `drop_last` is `False`?\",\n \"diff_hunk\": \"@@ -382,7 +383,18 @@ def __iter__(self):\\n # Broadcast the batch before splitting it.\\n batch = broadcast(batch, from_process=0)\\n \\n- batch_size = find_batch_size(batch) // state.num_processes\\n+ if not self.drop_last and first_batch is None:\\n+ # We keep at least num processes elements of the first batch to be able to complete the last batch\\n+ first_batch = slice_tensors(batch, slice(0, state.num_processes))\\n+\\n+ observed_batch_size = find_batch_size(batch)\\n+ batch_size = observed_batch_size // state.num_processes\\n+\\n+ if not self.drop_last and stop_iteration and observed_batch_size % state.num_processes != 0:\\n+ # If the last batch is not complete, let's add the first batch to it.\\n+ batch = concatenate([batch, first_batch], dim=0)\",\n \"from_author\": false\n },\n {\n \"body\": \"Yes, like all the dataloading utils, the batches need to be the same length on all processes, which means we have to add some data from the beginning to completet the last batch when `drop_last=False`.\",\n \"diff_hunk\": \"@@ -382,7 +383,18 @@ def __iter__(self):\\n # Broadcast the batch before splitting it.\\n batch = broadcast(batch, from_process=0)\\n \\n- batch_size = find_batch_size(batch) // state.num_processes\\n+ if not self.drop_last and first_batch is None:\\n+ # We keep at least num processes elements of the first batch to be able to complete the last batch\\n+ first_batch = slice_tensors(batch, slice(0, state.num_processes))\\n+\\n+ observed_batch_size = find_batch_size(batch)\\n+ batch_size = observed_batch_size // state.num_processes\\n+\\n+ if not self.drop_last and stop_iteration and observed_batch_size % state.num_processes != 0:\\n+ # If the last batch is not complete, let's add the first batch to it.\\n+ batch = concatenate([batch, first_batch], dim=0)\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"The `DispatchDataLoader` in general has no test, so we would need to add those before adding a test for the fix. I can do that, but probably not before next week so think we should merge now to at least fix the issue.\",\n \"from_author\": true\n },\n {\n \"body\": \"Sounds good!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/212\",\n \"pr_id\": 801556923\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex ac79d3e0a..f94b2cd99 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -150,7 +150,8 @@ def __init__(\\n self._models = []\\n \\n # RNG Types\\n- if rng_types is None:\\n+ self.rng_types = rng_types\\n+ if self.rng_types is None:\\n self.rng_types = [\\\"torch\\\"] if version.parse(torch.__version__) <= version.parse(\\\"1.5.1\\\") else [\\\"generator\\\"]\\n \\n @property\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/206\",\n \"pr_id\": 797586087\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex f944eea2d..cbc23ed10 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -206,6 +206,13 @@ You should use π€ Accelerate when you want to easily run your training scripts\\n \\n You shouldn't use π€ Accelerate if you don't want to write a training loop yourself. There are plenty of high-level libraries above PyTorch that will offer you that, π€ Accelerate is not one of them.\\n \\n+## Frameworks using π€ Accelerate\\n+\\n+If you like the simplicity of π€ Accelerate but would prefer a higher-level abstraction around your training loop, some frameworks that are built on top of π€ Accelerate are listed below:\\n+\\n+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centred around a general-purpose [Trainer](https://pytorch-accelerated.readthedocs.io/en/latest/trainer.html), that places a huge emphasis on simplicity and transparency; enabling users to understand exactly what is going on under the hood, but without having to write and maintain the boilerplate themselves!\\n+* [Kornia](https://kornia.readthedocs.io/en/latest/get-started/introduction.html) is a differentiable library that allows classical computer vision to be integrated into deep learning models. Kornia provides a [Trainer](https://kornia.readthedocs.io/en/latest/x.html#kornia.x.Trainer) with the specific purpose to train and fine-tune the supported deep learning algorithms within the library.\\n+\\n ## Installation\\n \\n This repository is tested on Python 3.6+ and PyTorch 1.4.0+\\ndiff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex fef2f0c08..b848e13d4 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -114,7 +114,7 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n \\n launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n try:\\n- print(f\\\"Launching a training on {num_processes} GPUs.\\\")\\n+ print(f\\\"Launching training on {num_processes} GPUs.\\\")\\n start_processes(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n finally:\\n # Clean up the environment variables set.\\n\",\n \"code_comments\": [\n {\n \"body\": \"No need for those two new lines here :-)\",\n \"diff_hunk\": \"@@ -220,6 +227,8 @@ Then, you will need to install PyTorch: refer to the [official installation page\\n pip install accelerate\\n ```\\n \\n+\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"Removed.\",\n \"diff_hunk\": \"@@ -220,6 +227,8 @@ Then, you will need to install PyTorch: refer to the [official installation page\\n pip install accelerate\\n ```\\n \\n+\\n+\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"> Thanks for your PR! I was more thinking of having a separate section named \\\"Frameworks using Accelerate\\\" where you could put the same content. There is also kornia using Accelerate internally in their trainer I would add there :-)\\r\\n\\r\\nSure thing, I can create an additional section, migrate the content, and will also look into and add Kornia. \",\n \"from_author\": true\n },\n {\n \"body\": \"@sgugger I have updated the README, hopefully that is closer to what you had in mind. Would you also like to me add a corresponding section to the docs?\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/204\",\n \"pr_id\": 794387842\n },\n {\n \"diff\": \"diff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex 3b1281c84..384db658a 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -69,7 +69,7 @@ Changing it to work with accelerate is really easy and only adds a few lines of\\n loss = my_loss_function(outputs, targets)\\n # Just a small change for the backward instruction\\n - loss.backward()\\n- + accelerate.backward(loss)\\n+ + accelerator.backward(loss)\\n my_optimizer.step()\\n \\n and with this, your script can now run in a distributed environment (multi-GPU, TPU).\\n@@ -97,7 +97,7 @@ especially for TPU training):\\n loss = my_loss_function(outputs, targets)\\n # Just a small change for the backward instruction\\n - loss.backward()\\n- + accelerate.backward(loss)\\n+ + accelerator.backward(loss)\\n my_optimizer.step()\\n \\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/199\",\n \"pr_id\": 779317374\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 37ca78833..4269242b4 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -12,6 +12,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import inspect\\n+\\n import torch\\n \\n from packaging import version\\n@@ -100,9 +102,15 @@ def zero_grad(self, set_to_none=None):\\n )\\n self.optimizer.zero_grad()\\n else:\\n- if set_to_none is None:\\n- set_to_none = False\\n- self.optimizer.zero_grad(set_to_none=set_to_none)\\n+ accept_arg = \\\"set_to_none\\\" in inspect.signature(self.optimizer.zero_grad).parameters\\n+ if accept_arg:\\n+ if set_to_none is None:\\n+ set_to_none = False\\n+ self.optimizer.zero_grad(set_to_none=set_to_none)\\n+ else:\\n+ if set_to_none is not None:\\n+ raise ValueError(\\\"`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.\\\")\\n+ self.optimizer.zero_grad()\\n \\n def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/189\",\n \"pr_id\": 762410224\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 281325bfe..f944eea2d 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -155,6 +155,8 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torch.distributed.launch my_script.py` at your convenance.\\n+\\n ## Launching multi-CPU run using MPI\\n \\n π€ Here is another way to launch multi-CPU run using MPI. You can learn how to install Open MPI on [this page](https://www.open-mpi.org/faq/?category=building#easy-build). You can use Intel MPI or MVAPICH as well.\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/187\",\n \"pr_id\": 761529590\n },\n {\n \"diff\": \"diff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 220c6ddcc..aad2b8b65 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n training_function(config, args)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/183\",\n \"pr_id\": 754539911\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex b8428733b..991997282 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -15,7 +15,7 @@\\n import importlib\\n import os\\n import random\\n-from collections import UserDict\\n+from collections.abc import Mapping\\n from dataclasses import dataclass, field\\n from enum import Enum\\n from typing import List, Optional, Union\\n@@ -163,7 +163,7 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n- elif isinstance(data, UserDict):\\n+ elif isinstance(data, Mapping):\\n return type(data)(\\n {\\n k: recursively_apply(\\n@@ -172,15 +172,6 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for k, v in data.items()\\n }\\n )\\n- elif isinstance(data, dict):\\n- return type(data)(\\n- **{\\n- k: recursively_apply(\\n- func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n- )\\n- for k, v in data.items()\\n- }\\n- )\\n elif test_type(data):\\n return func(data, *args, **kwargs)\\n elif error_on_other_type:\\n@@ -310,7 +301,7 @@ def extract_model_from_parallel(model):\\n def _tpu_gather(tensor, name=\\\"gather tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (_tpu_gather(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n- elif isinstance(tensor, (dict, UserDict)):\\n+ elif isinstance(tensor, Mapping):\\n return type(tensor)({k: _tpu_gather(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n raise TypeError(f\\\"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n@@ -365,7 +356,7 @@ def _gpu_broadcast_one(tensor, src=0):\\n def _tpu_broadcast(tensor, src=0, name=\\\"broadcast tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (_tpu_broadcast(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n- elif isinstance(tensor, (dict, UserDict)):\\n+ elif isinstance(tensor, Mapping):\\n return type(tensor)({k: _tpu_broadcast(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n return xm.mesh_reduce(name, tensor, lambda x: x[src])\\n \\n@@ -448,7 +439,7 @@ def find_batch_size(data):\\n \\\"\\\"\\\"\\n if isinstance(data, (tuple, list)):\\n return find_batch_size(data[0])\\n- elif isinstance(data, (dict, UserDict)):\\n+ elif isinstance(data, Mapping):\\n for k in data.keys():\\n return find_batch_size(data[k])\\n elif not isinstance(data, torch.Tensor):\\n@@ -471,10 +462,8 @@ def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n- elif isinstance(data[0], UserDict):\\n+ elif isinstance(data[0], Mapping):\\n return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n- elif isinstance(data[0], dict):\\n- return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n elif not isinstance(data[0], torch.Tensor):\\n raise TypeError(f\\\"Can only concatenate tensors but got {type(data[0])}\\\")\\n return torch.cat(data, dim=dim)\\n\",\n \"code_comments\": [\n {\n \"body\": \"You would need to remove the `**` for this to work with UserDict I believe.\\r\\n```suggestion\\r\\n {\\r\\n```\",\n \"diff_hunk\": \"@@ -163,16 +163,7 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n- elif isinstance(data, UserDict):\\n- return type(data)(\\n- {\\n- k: recursively_apply(\\n- func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n- )\\n- for k, v in data.items()\\n- }\\n- )\\n- elif isinstance(data, dict):\\n+ elif isinstance(data, Mapping):\\n return type(data)(\\n **{\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\r\\n```\\r\\nSame here\",\n \"diff_hunk\": \"@@ -471,9 +462,7 @@ def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n- elif isinstance(data[0], UserDict):\\n- return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n- elif isinstance(data[0], dict):\\n+ elif isinstance(data[0], Mapping):\\n return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\",\n \"from_author\": false\n },\n {\n \"body\": \"`UserDict` also works with the `**` syntax. You can test this with the following code or by looking at the source [here](https://github.com/python/cpython/blob/2c56c97f015a7ea81719615ddcf3c745fba5b4f3/Lib/collections/__init__.py#L964-L984) (warning you that the code is a bit messy in Python 3.6-3.8 compared to Python 3.9 π):\\r\\n```python\\r\\nfrom collections import UserDict\\r\\nassert UserDict(**{\\\"a\\\": 1, \\\"b\\\": 2}) == UserDict({\\\"a\\\": 1, \\\"b\\\": 2})\\r\\n```\",\n \"diff_hunk\": \"@@ -163,16 +163,7 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n- elif isinstance(data, UserDict):\\n- return type(data)(\\n- {\\n- k: recursively_apply(\\n- func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n- )\\n- for k, v in data.items()\\n- }\\n- )\\n- elif isinstance(data, dict):\\n+ elif isinstance(data, Mapping):\\n return type(data)(\\n **{\",\n \"from_author\": true\n },\n {\n \"body\": \"But not the `BatchEncoding` subclass we are doing all of this for :-)\\r\\n\\r\\nYou can try and see that:\\r\\n```\\r\\nfrom transformers import BatchEncoding\\r\\nassert BatchEncoding(**{\\\"a\\\": 1, \\\"b\\\": 2}) == BatchEncoding({\\\"a\\\": 1, \\\"b\\\": 2})\\r\\n```\\r\\nfails\",\n \"diff_hunk\": \"@@ -163,16 +163,7 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n- elif isinstance(data, UserDict):\\n- return type(data)(\\n- {\\n- k: recursively_apply(\\n- func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n- )\\n- for k, v in data.items()\\n- }\\n- )\\n- elif isinstance(data, dict):\\n+ elif isinstance(data, Mapping):\\n return type(data)(\\n **{\",\n \"from_author\": false\n },\n {\n \"body\": \"Oh, I see. Thanks.\",\n \"diff_hunk\": \"@@ -163,16 +163,7 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n- elif isinstance(data, UserDict):\\n- return type(data)(\\n- {\\n- k: recursively_apply(\\n- func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n- )\\n- for k, v in data.items()\\n- }\\n- )\\n- elif isinstance(data, dict):\\n+ elif isinstance(data, Mapping):\\n return type(data)(\\n **{\",\n \"from_author\": true\n },\n {\n \"body\": \"This one still needs to be changed.\",\n \"diff_hunk\": \"@@ -471,9 +462,7 @@ def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n- elif isinstance(data[0], UserDict):\\n- return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n- elif isinstance(data[0], dict):\\n+ elif isinstance(data[0], Mapping):\\n return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\",\n \"from_author\": false\n },\n {\n \"body\": \"But besides replacing `(dict, UserDict)` with `Mapping` in the `isinstance` checks, the code right now is identical to the code you pushed in the initial PR. However, I see an additional simplification we can use if we abandon the `**` syntax (maybe that is what you are aiming for).\",\n \"diff_hunk\": \"@@ -471,9 +462,7 @@ def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n- elif isinstance(data[0], UserDict):\\n- return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n- elif isinstance(data[0], dict):\\n+ elif isinstance(data[0], Mapping):\\n return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"cc @sgugger \",\n \"from_author\": true\n },\n {\n \"body\": \"@sgugger I've reverted the changes in these two functions, so now the code should work with `BatchEncoding`. However, even though this would add some complexity, maybe a cleaner approach would be to use a specific check for `BatchEncoding`. But for now, I think the current solution is good enough.\",\n \"from_author\": true\n },\n {\n \"body\": \"Thanks again for your contribution!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/180\",\n \"pr_id\": 747888847\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 28a38539a..b8428733b 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -15,6 +15,7 @@\\n import importlib\\n import os\\n import random\\n+from collections import UserDict\\n from dataclasses import dataclass, field\\n from enum import Enum\\n from typing import List, Optional, Union\\n@@ -162,6 +163,15 @@ def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_oth\\n for o in data\\n ),\\n )\\n+ elif isinstance(data, UserDict):\\n+ return type(data)(\\n+ {\\n+ k: recursively_apply(\\n+ func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n+ )\\n+ for k, v in data.items()\\n+ }\\n+ )\\n elif isinstance(data, dict):\\n return type(data)(\\n **{\\n@@ -300,7 +310,7 @@ def extract_model_from_parallel(model):\\n def _tpu_gather(tensor, name=\\\"gather tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (_tpu_gather(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n- elif isinstance(tensor, dict):\\n+ elif isinstance(tensor, (dict, UserDict)):\\n return type(tensor)({k: _tpu_gather(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n raise TypeError(f\\\"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n@@ -355,7 +365,7 @@ def _gpu_broadcast_one(tensor, src=0):\\n def _tpu_broadcast(tensor, src=0, name=\\\"broadcast tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (_tpu_broadcast(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n- elif isinstance(tensor, dict):\\n+ elif isinstance(tensor, (dict, UserDict)):\\n return type(tensor)({k: _tpu_broadcast(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n return xm.mesh_reduce(name, tensor, lambda x: x[src])\\n \\n@@ -438,7 +448,7 @@ def find_batch_size(data):\\n \\\"\\\"\\\"\\n if isinstance(data, (tuple, list)):\\n return find_batch_size(data[0])\\n- elif isinstance(data, dict):\\n+ elif isinstance(data, (dict, UserDict)):\\n for k in data.keys():\\n return find_batch_size(data[k])\\n elif not isinstance(data, torch.Tensor):\\n@@ -461,6 +471,8 @@ def concatenate(data, dim=0):\\n \\\"\\\"\\\"\\n if isinstance(data[0], (tuple, list)):\\n return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n+ elif isinstance(data[0], UserDict):\\n+ return type(data[0])({k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n elif isinstance(data[0], dict):\\n return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n elif not isinstance(data[0], torch.Tensor):\\ndiff --git a/tests/test_utils.py b/tests/test_utils.py\\nindex 9b16aba7b..e515df8fe 100644\\n--- a/tests/test_utils.py\\n+++ b/tests/test_utils.py\\n@@ -13,7 +13,7 @@\\n # limitations under the License.\\n \\n import unittest\\n-from collections import namedtuple\\n+from collections import UserDict, namedtuple\\n \\n import torch\\n \\n@@ -54,3 +54,11 @@ def test_send_to_device(self):\\n self.assertTrue(torch.equal(result3.b[0].cpu(), tensor))\\n self.assertTrue(torch.equal(result3.b[1].cpu(), tensor))\\n self.assertEqual(result3.c, 1)\\n+\\n+ result4 = send_to_device(UserDict({\\\"a\\\": tensor, \\\"b\\\": [tensor, tensor], \\\"c\\\": 1}), device)\\n+ self.assertIsInstance(result4, UserDict)\\n+ self.assertTrue(torch.equal(result4[\\\"a\\\"].cpu(), tensor))\\n+ self.assertIsInstance(result4[\\\"b\\\"], list)\\n+ self.assertTrue(torch.equal(result4[\\\"b\\\"][0].cpu(), tensor))\\n+ self.assertTrue(torch.equal(result4[\\\"b\\\"][1].cpu(), tensor))\\n+ self.assertEqual(result4[\\\"c\\\"], 1)\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"@sgugger @LysandreJik Instead of adding `UserDict` to the `isinstance` class tuple, you can use `collections.abc.Mapping` to cover both the `dict` and the `UserDict` types (e.g. PyTorch DataLoader uses such check in its default `collate_fn` to stack `dict`-like objects). \\r\\n\",\n \"from_author\": false\n },\n {\n \"body\": \"Oh thanks for the tip! I will clean the code to use that when I have a bit of time (unless you want to suggest a PR!)\",\n \"from_author\": true\n },\n {\n \"body\": \"I'm busy currently, so probably won't find time to fix this myself.\",\n \"from_author\": false\n },\n {\n \"body\": \"I did find time to fix this, so I've opened a PR.\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/179\",\n \"pr_id\": 746855253\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex e25b80c49..28a38539a 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -201,7 +201,7 @@ def _send_to_device(t, device):\\n def _has_to_method(t):\\n return hasattr(t, \\\"to\\\")\\n \\n- return recursively_apply(_send_to_device, tensor, device, test_type=_has_to_method, error_on_other_type=True)\\n+ return recursively_apply(_send_to_device, tensor, device, test_type=_has_to_method)\\n \\n \\n def get_data_structure(data):\\ndiff --git a/tests/test_utils.py b/tests/test_utils.py\\nindex ca617634d..9b16aba7b 100644\\n--- a/tests/test_utils.py\\n+++ b/tests/test_utils.py\\n@@ -20,7 +20,7 @@\\n from accelerate.utils import send_to_device\\n \\n \\n-TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b\\\")\\n+TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b c\\\")\\n \\n \\n class UtilsTester(unittest.TestCase):\\n@@ -31,23 +31,26 @@ def test_send_to_device(self):\\n result1 = send_to_device(tensor, device)\\n self.assertTrue(torch.equal(result1.cpu(), tensor))\\n \\n- result2 = send_to_device((tensor, [tensor, tensor]), device)\\n+ result2 = send_to_device((tensor, [tensor, tensor], 1), device)\\n self.assertIsInstance(result2, tuple)\\n self.assertTrue(torch.equal(result2[0].cpu(), tensor))\\n self.assertIsInstance(result2[1], list)\\n self.assertTrue(torch.equal(result2[1][0].cpu(), tensor))\\n self.assertTrue(torch.equal(result2[1][1].cpu(), tensor))\\n+ self.assertEqual(result2[2], 1)\\n \\n- result2 = send_to_device({\\\"a\\\": tensor, \\\"b\\\": [tensor, tensor]}, device)\\n+ result2 = send_to_device({\\\"a\\\": tensor, \\\"b\\\": [tensor, tensor], \\\"c\\\": 1}, device)\\n self.assertIsInstance(result2, dict)\\n self.assertTrue(torch.equal(result2[\\\"a\\\"].cpu(), tensor))\\n self.assertIsInstance(result2[\\\"b\\\"], list)\\n self.assertTrue(torch.equal(result2[\\\"b\\\"][0].cpu(), tensor))\\n self.assertTrue(torch.equal(result2[\\\"b\\\"][1].cpu(), tensor))\\n+ self.assertEqual(result2[\\\"c\\\"], 1)\\n \\n- result3 = send_to_device(TestNamedTuple(a=tensor, b=[tensor, tensor]), device)\\n+ result3 = send_to_device(TestNamedTuple(a=tensor, b=[tensor, tensor], c=1), device)\\n self.assertIsInstance(result3, TestNamedTuple)\\n self.assertTrue(torch.equal(result3.a.cpu(), tensor))\\n self.assertIsInstance(result3.b, list)\\n self.assertTrue(torch.equal(result3.b[0].cpu(), tensor))\\n self.assertTrue(torch.equal(result3.b[1].cpu(), tensor))\\n+ self.assertEqual(result3.c, 1)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/177\",\n \"pr_id\": 745739393\n },\n {\n \"diff\": \"diff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 582066414..73f8ecc0b 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -12,6 +12,7 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import math\\n from typing import List, Optional, Union\\n \\n import torch\\n@@ -388,6 +389,14 @@ def __iter__(self):\\n xm.mark_step()\\n yield slice_tensors(batch, data_slice)\\n \\n+ def __len__(self):\\n+ state = AcceleratorState()\\n+ whole_length = super().__len__()\\n+ if self.drop_last:\\n+ return whole_length // state.num_processes\\n+ else:\\n+ return math.ceil(whole_length / state.num_processes)\\n+\\n \\n def prepare_data_loader(\\n dataloader: DataLoader,\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/175\",\n \"pr_id\": 743530149\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 8df05578a..e25b80c49 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -255,7 +255,7 @@ def _convert_to_fp32(tensor):\\n def _is_fp16_tensor(tensor):\\n return hasattr(tensor, \\\"dtype\\\") and tensor.dtype == torch.float16\\n \\n- return recursively_apply(_is_fp16_tensor, tensor, test_type=_is_fp16_tensor)\\n+ return recursively_apply(_convert_to_fp32, tensor, test_type=_is_fp16_tensor)\\n \\n \\n def convert_outputs_to_fp32(model_forward):\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Thanks for fixing this!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/173\",\n \"pr_id\": 742813523\n },\n {\n \"diff\": \"diff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 03e38baf8..582066414 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -12,7 +12,6 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-import warnings\\n from typing import List, Optional, Union\\n \\n import torch\\n@@ -228,8 +227,8 @@ def __init__(\\n process_index: int = 0,\\n split_batches: bool = False,\\n ):\\n- if split_batches and batch_size % num_processes != 0:\\n- warnings.warn(\\n+ if split_batches and batch_size > 1 and batch_size % num_processes != 0:\\n+ raise ValueError(\\n f\\\"To use `IterableDatasetShard` in `split_batches` mode, the batch size ({batch_size}) \\\"\\n f\\\"needs to be a round multiple of the number of processes ({num_processes}).\\\"\\n )\\n@@ -466,9 +465,9 @@ def prepare_data_loader(\\n process_index = state.process_index\\n \\n # Sanity check\\n- if split_batches and dataloader.batch_size % num_processes != 0:\\n- warnings.warn(\\n- f\\\"To use `IterableDatasetShard` in `split_batches` mode, the batch size ({dataloader.batch_size}) \\\"\\n+ if split_batches and dataloader.batch_size > 1 and dataloader.batch_size % num_processes != 0:\\n+ raise ValueError(\\n+ f\\\"To use a `DataLoader` in `split_batches` mode, the batch size ({dataloader.batch_size}) \\\"\\n f\\\"needs to be a round multiple of the number of processes ({num_processes}).\\\"\\n )\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/170\",\n \"pr_id\": 739375515\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a70ebdaba..ac79d3e0a 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -82,9 +82,10 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n- dispatch_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ dispatch_batches (:obj:`bool`, `optional`):\\n If set to :obj:`True`, the dataloader prepared by the Accelerator is only iterated through on the main\\n- process and then the batches are split and broadcast to each process.\\n+ process and then the batches are split and broadcast to each process. Will default to :obj:`True` for\\n+ :obj:`DataLoader` whose underlying dataset is an :obj:`IterableDataset`, :obj:`False` otherwise.\\n kwargs_handlers (list of kwargs handlers, `optional`)\\n A list of :obj:`KwargHandler` to customize how the objects related to distributed training or mixed\\n precision are created. See :doc:`kwargs` for more information.\\n@@ -103,7 +104,7 @@ def __init__(\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n- dispatch_batches: bool = False,\\n+ dispatch_batches: Optional[bool] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n if deepspeed_plugin is None: # init from env variables\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 1d464c55f..03e38baf8 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -398,7 +398,7 @@ def prepare_data_loader(\\n split_batches: bool = False,\\n put_on_device: bool = False,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n- dispatch_batches: bool = False,\\n+ dispatch_batches: Optional[bool] = None,\\n ) -> DataLoader:\\n \\\"\\\"\\\"\\n Wraps a PyTorch :obj:`DataLoader` to generate batches for one of the processes only.\\n@@ -441,9 +441,10 @@ def prepare_data_loader(\\n - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n- dispatch_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ dispatch_batches (:obj:`bool`, `optional`):\\n If set to :obj:`True`, the datalaoder prepared is only iterated through on the main process and then the\\n- batches are split and broadcast to each process.\\n+ batches are split and broadcast to each process. Will default to :obj:`True` when the underlying dataset is\\n+ an :obj:`IterableDataset`, :obj:`False` otherwise.\\n \\n Returns:\\n :obj:`torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\n@@ -452,6 +453,9 @@ def prepare_data_loader(\\n \\n This does not support :obj:`BatchSampler` with varying batch size yet.\\n \\\"\\\"\\\"\\n+ if dispatch_batches is None:\\n+ dispatch_batches = False if not put_on_device else isinstance(dataloader.dataset, IterableDataset)\\n+\\n if dispatch_batches and not put_on_device:\\n raise ValueError(\\\"Using `dispatch_batches=True` requires `put_on_device=True`.\\\")\\n # Grab defaults from AcceleratorState\\n\",\n \"code_comments\": [\n {\n \"body\": \"Clean!\",\n \"diff_hunk\": \"@@ -452,6 +453,9 @@ def prepare_data_loader(\\n \\n This does not support :obj:`BatchSampler` with varying batch size yet.\\n \\\"\\\"\\\"\\n+ if dispatch_batches is None:\\n+ dispatch_batches = False if not put_on_device else isinstance(new_dataset, IterableDataset)\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/168\",\n \"pr_id\": 737895559\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a35f7e268..a70ebdaba 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -82,6 +82,9 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n+ dispatch_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ If set to :obj:`True`, the dataloader prepared by the Accelerator is only iterated through on the main\\n+ process and then the batches are split and broadcast to each process.\\n kwargs_handlers (list of kwargs handlers, `optional`)\\n A list of :obj:`KwargHandler` to customize how the objects related to distributed training or mixed\\n precision are created. See :doc:`kwargs` for more information.\\n@@ -100,6 +103,7 @@ def __init__(\\n cpu: bool = False,\\n deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n+ dispatch_batches: bool = False,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n if deepspeed_plugin is None: # init from env variables\\n@@ -113,6 +117,7 @@ def __init__(\\n \\n self.device_placement = device_placement\\n self.split_batches = split_batches\\n+ self.dispatch_batches = dispatch_batches\\n \\n # Kwargs handlers\\n self.ddp_handler = None\\n@@ -384,6 +389,7 @@ def prepare_data_loader(self, data_loader):\\n split_batches=self.split_batches,\\n put_on_device=self.device_placement,\\n rng_types=self.rng_types.copy(),\\n+ dispatch_batches=self.dispatch_batches,\\n )\\n \\n def prepare_optimizer(self, optimizer):\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 96648ca65..fd10140b6 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -20,7 +20,18 @@\\n from packaging import version\\n \\n from .state import AcceleratorState, DistributedType, is_tpu_available\\n-from .utils import RNGType, send_to_device, synchronize_rng_states\\n+from .utils import (\\n+ RNGType,\\n+ broadcast,\\n+ broadcast_object_list,\\n+ concatenate,\\n+ find_batch_size,\\n+ get_data_structure,\\n+ initialize_tensors,\\n+ send_to_device,\\n+ slice_tensors,\\n+ synchronize_rng_states,\\n+)\\n \\n \\n if is_tpu_available():\\n@@ -294,6 +305,90 @@ def __iter__(self):\\n yield batch if self.device is None else send_to_device(batch, self.device)\\n \\n \\n+class DataLoaderDispatcher(DataLoader):\\n+ \\\"\\\"\\\"\\n+ Subclass of a PyTorch :obj:`DataLoader` that will iterate and preprocess on process 0 only, then dispatch on each\\n+ process their part of the batch.\\n+\\n+ Args:\\n+ split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ Whether the resulting :obj:`DataLoader` should split the batches of the original data loader across devices\\n+ or yield full batches (in which case it will yield batches starting at the :obj:`process_index`-th and\\n+ advancing of :obj:`num_processes` batches at each iteration).\\n+\\n+ Another way to see this is that the observed batch size will be the same as the initial :obj:`dataloader`\\n+ if this option is set to :obj:`True`, the batch size of the initial :obj:`dataloader` multiplied by\\n+ :obj:`num_processes` otherwise.\\n+\\n+ Setting this option to :obj:`True` requires that the batch size of the :obj:`dataloader` is a round\\n+ multiple of :obj:`batch_size`.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, dataset, split_batches: bool = False, **kwargs):\\n+ super().__init__(dataset, **kwargs)\\n+ self.split_batches = split_batches\\n+\\n+ def __iter__(self):\\n+ state = AcceleratorState()\\n+ if state.process_index == 0:\\n+ # We only iterate through the DataLoader on process 0.\\n+ main_iterator = super().__iter__()\\n+ stop_iteration = False\\n+ while not stop_iteration:\\n+ # On process 0, we gather the batch to dispatch.\\n+ if state.process_index == 0:\\n+ try:\\n+ if self.split_batches:\\n+ # One batch of the main iterator is dispatched and split.\\n+ batch = next(main_iterator)\\n+ else:\\n+ # num_processes batches of the main iterator are concatenated then dispatched and split.\\n+ # We add the batches one by one so we have the remainder available when drop_last=False.\\n+ batches = []\\n+ for _ in range(state.num_processes):\\n+ batches.append(next(main_iterator))\\n+ batch = concatenate(batches, dim=0)\\n+ # In both cases, we need to get the structure of the batch that we will broadcast on other\\n+ # processes to initialize the tensors with the right shape.\\n+ # data_structure, stop_iteration\\n+ batch_info = [get_data_structure(batch), False]\\n+ except StopIteration:\\n+ batch_info = [None, True]\\n+ else:\\n+ batch_info = [None, stop_iteration]\\n+\\n+ # This is inplace, so after this instruction, every process has the same `batch_info` as process 0.\\n+ broadcast_object_list(batch_info)\\n+ stop_iteration = batch_info[1]\\n+ if stop_iteration:\\n+ # If drop_last is False and split_batches is False, we may have a remainder to take care of.\\n+ if not self.split_batches and not self.drop_last:\\n+ if state.process_index == 0 and len(batches) > 0:\\n+ batch = concatenate(batches, dim=0)\\n+ batch_info = [get_data_structure(batch), False]\\n+ else:\\n+ batch_info = [None, True]\\n+ broadcast_object_list(batch_info)\\n+ if batch_info[1]:\\n+ continue\\n+ else:\\n+ continue\\n+\\n+ if state.process_index != 0:\\n+ # Initialize tensors on other processes than process 0.\\n+ batch = initialize_tensors(batch_info[0])\\n+ batch = send_to_device(batch, state.device)\\n+ # Broadcast the batch before splitting it.\\n+ batch = broadcast(batch, from_process=0)\\n+\\n+ batch_size = find_batch_size(batch) // state.num_processes\\n+ data_slice = slice(state.process_index * batch_size, (state.process_index + 1) * batch_size)\\n+\\n+ if state.distributed_type == DistributedType.TPU:\\n+ xm.mark_step()\\n+ yield slice_tensors(batch, data_slice)\\n+\\n+\\n def prepare_data_loader(\\n dataloader: DataLoader,\\n device: Optional[torch.device] = None,\\n@@ -302,6 +397,7 @@ def prepare_data_loader(\\n split_batches: bool = False,\\n put_on_device: bool = False,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n+ dispatch_batches: bool = False,\\n ) -> DataLoader:\\n \\\"\\\"\\\"\\n Wraps a PyTorch :obj:`DataLoader` to generate batches for one of the processes only.\\n@@ -344,6 +440,10 @@ def prepare_data_loader(\\n - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n+ dispatch_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ If set to :obj:`True`, the datalaoder prepared is only iterated through on the main process and then the\\n+ batches are split and broadcast to each process.\\n+\\n Returns:\\n :obj:`torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\n \\n@@ -351,6 +451,8 @@ def prepare_data_loader(\\n \\n This does not support :obj:`BatchSampler` with varying batch size yet.\\n \\\"\\\"\\\"\\n+ if dispatch_batches and not put_on_device:\\n+ raise ValueError(\\\"Using `dispatch_batches=True` requires `put_on_device=True`.\\\")\\n # Grab defaults from AcceleratorState\\n state = AcceleratorState()\\n if num_processes is None:\\n@@ -370,7 +472,7 @@ def prepare_data_loader(\\n new_batch_sampler = dataloader.batch_sampler if not isinstance(new_dataset, IterableDataset) else None\\n generator = getattr(dataloader, \\\"generator\\\", None)\\n # No change if no multiprocess\\n- if num_processes != 1:\\n+ if num_processes != 1 and not dispatch_batches:\\n if isinstance(new_dataset, IterableDataset):\\n if getattr(dataloader.dataset, \\\"generator\\\", None) is not None:\\n generator = dataloader.dataset.generator\\n@@ -421,6 +523,11 @@ def prepare_data_loader(\\n if new_batch_sampler is None:\\n kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\n \\n+ if dispatch_batches:\\n+ return DataLoaderDispatcher(\\n+ new_dataset, split_batches=split_batches, batch_sampler=new_batch_sampler, **kwargs\\n+ )\\n+\\n return DataLoaderShard(\\n new_dataset,\\n device=device if put_on_device else None,\\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex 2e5095533..41efcf61c 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -36,14 +36,14 @@ def init_state_check():\\n def rng_sync_check():\\n state = AcceleratorState()\\n synchronize_rng_states([\\\"torch\\\"])\\n- assert are_the_same_tensors(torch.get_rng_state())\\n+ assert are_the_same_tensors(torch.get_rng_state()), \\\"RNG states improperly synchronized on CPU.\\\"\\n if state.distributed_type == DistributedType.MULTI_GPU:\\n synchronize_rng_states([\\\"cuda\\\"])\\n- assert are_the_same_tensors(torch.cuda.get_rng_state())\\n+ assert are_the_same_tensors(torch.cuda.get_rng_state()), \\\"RNG states improperly synchronized on GPU.\\\"\\n if version.parse(torch.__version__) >= version.parse(\\\"1.6.0\\\"):\\n generator = torch.Generator()\\n synchronize_rng_states([\\\"generator\\\"], generator=generator)\\n- assert are_the_same_tensors(generator.get_state())\\n+ assert are_the_same_tensors(generator.get_state()), \\\"RNG states improperly synchronized in generator.\\\"\\n \\n if state.local_process_index == 0:\\n print(\\\"All rng are properly synched.\\\")\\n@@ -59,7 +59,7 @@ def dl_preparation_check():\\n for batch in dl:\\n result.append(gather(batch))\\n result = torch.cat(result)\\n- assert torch.equal(result.cpu(), torch.arange(0, length).long())\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long()), \\\"Wrong non-shuffled dataloader result.\\\"\\n \\n dl = DataLoader(range(length), batch_size=8)\\n dl = prepare_data_loader(\\n@@ -74,7 +74,7 @@ def dl_preparation_check():\\n for batch in dl:\\n result.append(gather(batch))\\n result = torch.cat(result)\\n- assert torch.equal(result.cpu(), torch.arange(0, length).long())\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long()), \\\"Wrong non-shuffled dataloader result.\\\"\\n \\n if state.process_index == 0:\\n print(\\\"Non-shuffled dataloader passing.\\\")\\n@@ -86,7 +86,7 @@ def dl_preparation_check():\\n result.append(gather(batch))\\n result = torch.cat(result).tolist()\\n result.sort()\\n- assert result == list(range(length))\\n+ assert result == list(range(length)), \\\"Wrong shuffled dataloader result.\\\"\\n \\n dl = DataLoader(range(length), batch_size=8, shuffle=True)\\n dl = prepare_data_loader(\\n@@ -102,12 +102,77 @@ def dl_preparation_check():\\n result.append(gather(batch))\\n result = torch.cat(result).tolist()\\n result.sort()\\n- assert result == list(range(length))\\n+ assert result == list(range(length)), \\\"Wrong shuffled dataloader result.\\\"\\n \\n if state.local_process_index == 0:\\n print(\\\"Shuffled dataloader passing.\\\")\\n \\n \\n+def central_dl_preparation_check():\\n+ state = AcceleratorState()\\n+ length = 32 * state.num_processes\\n+\\n+ dl = DataLoader(range(length), batch_size=8)\\n+ dl = prepare_data_loader(\\n+ dl, state.device, state.num_processes, state.process_index, put_on_device=True, dispatch_batches=True\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result)\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long()), \\\"Wrong non-shuffled dataloader result.\\\"\\n+\\n+ dl = DataLoader(range(length), batch_size=8)\\n+ dl = prepare_data_loader(\\n+ dl,\\n+ state.device,\\n+ state.num_processes,\\n+ state.process_index,\\n+ put_on_device=True,\\n+ split_batches=True,\\n+ dispatch_batches=True,\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result)\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long()), \\\"Wrong non-shuffled dataloader result.\\\"\\n+\\n+ if state.process_index == 0:\\n+ print(\\\"Non-shuffled central dataloader passing.\\\")\\n+\\n+ dl = DataLoader(range(length), batch_size=8, shuffle=True)\\n+ dl = prepare_data_loader(\\n+ dl, state.device, state.num_processes, state.process_index, put_on_device=True, dispatch_batches=True\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result).tolist()\\n+ result.sort()\\n+ assert result == list(range(length)), \\\"Wrong shuffled dataloader result.\\\"\\n+\\n+ dl = DataLoader(range(length), batch_size=8, shuffle=True)\\n+ dl = prepare_data_loader(\\n+ dl,\\n+ state.device,\\n+ state.num_processes,\\n+ state.process_index,\\n+ put_on_device=True,\\n+ split_batches=True,\\n+ dispatch_batches=True,\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result).tolist()\\n+ result.sort()\\n+ assert result == list(range(length)), \\\"Wrong shuffled dataloader result.\\\"\\n+\\n+ if state.local_process_index == 0:\\n+ print(\\\"Shuffled central dataloader passing.\\\")\\n+\\n+\\n def mock_training(length, batch_size, generator):\\n set_seed(42)\\n generator.manual_seed(42)\\n@@ -132,8 +197,8 @@ def training_check():\\n length = batch_size * 4 * state.num_processes\\n \\n train_set, old_model = mock_training(length, batch_size * state.num_processes, generator)\\n- assert are_the_same_tensors(old_model.a)\\n- assert are_the_same_tensors(old_model.b)\\n+ assert are_the_same_tensors(old_model.a), \\\"Did not obtain the same model on both processes.\\\"\\n+ assert are_the_same_tensors(old_model.b), \\\"Did not obtain the same model on both processes.\\\"\\n \\n accelerator = Accelerator()\\n train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n@@ -152,8 +217,8 @@ def training_check():\\n optimizer.step()\\n \\n model = accelerator.unwrap_model(model).cpu()\\n- assert torch.allclose(old_model.a, model.a)\\n- assert torch.allclose(old_model.b, model.b)\\n+ assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+ assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n accelerator.print(\\\"Training yielded the same results on one CPU or distributed setup with no batch split.\\\")\\n \\n@@ -174,8 +239,8 @@ def training_check():\\n optimizer.step()\\n \\n model = accelerator.unwrap_model(model).cpu()\\n- assert torch.allclose(old_model.a, model.a)\\n- assert torch.allclose(old_model.b, model.b)\\n+ assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+ assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n accelerator.print(\\\"Training yielded the same results on one CPU or distributes setup with batch split.\\\")\\n \\n@@ -197,8 +262,8 @@ def training_check():\\n optimizer.step()\\n \\n model = accelerator.unwrap_model(model).cpu()\\n- assert torch.allclose(old_model.a, model.a)\\n- assert torch.allclose(old_model.b, model.b)\\n+ assert torch.allclose(old_model.a, model.a), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n+ assert torch.allclose(old_model.b, model.b), \\\"Did not obtain the same model on CPU or distributed training.\\\"\\n \\n \\n def main():\\n@@ -215,6 +280,7 @@ def main():\\n if state.local_process_index == 0:\\n print(\\\"\\\\n**DataLoader integration test**\\\")\\n dl_preparation_check()\\n+ central_dl_preparation_check()\\n \\n if state.local_process_index == 0:\\n print(\\\"\\\\n**Training integration test**\\\")\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 026ab9501..8df05578a 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -48,6 +48,12 @@ class RNGType(Enum):\\n GENERATOR = \\\"generator\\\"\\n \\n \\n+@dataclass\\n+class TensorInformation:\\n+ shape: torch.Size\\n+ dtype: torch.dtype\\n+\\n+\\n def set_seed(seed: int):\\n \\\"\\\"\\\"\\n Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch``.\\n@@ -115,6 +121,66 @@ def honor_type(obj, generator):\\n return type(obj)(generator)\\n \\n \\n+def is_torch_tensor(tensor):\\n+ return isinstance(tensor, torch.Tensor)\\n+\\n+\\n+def is_tensor_information(tensor_info):\\n+ return isinstance(tensor_info, TensorInformation)\\n+\\n+\\n+def recursively_apply(func, data, *args, test_type=is_torch_tensor, error_on_other_type=False, **kwargs):\\n+ \\\"\\\"\\\"\\n+ Recursively apply a function on a data structure that is a nested list/tuple/dictionary of a given base type.\\n+\\n+ Args:\\n+ func (:obj:`callable`):\\n+ The function to recursively apply.\\n+ data (nested list/tuple/dictionary of :obj:`main_type`):\\n+ The data on which to apply :obj:`func`\\n+ *args:\\n+ Positional arguments that will be passed to :obj:`func` when applied on the unpacked data.\\n+ main_type (:obj:`type`, `optional`, defaults to :obj:`torch.Tensor`):\\n+ The base type of the objects to which apply :obj:`func`.\\n+ error_on_other_type (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ Whether to return an error or not if after unpacking :obj:`data`, we get on an object that is not of type\\n+ :obj:`main_type`. If :obj:`False`, the function will leave objects of types different than :obj:`main_type`\\n+ unchanged.\\n+ **kwargs:\\n+ Keyword arguments that will be passed to :obj:`func` when applied on the unpacked data.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`data` with :obj:`func` applied to every object of type :obj:`main_type`.\\n+ \\\"\\\"\\\"\\n+ if isinstance(data, (tuple, list)):\\n+ return honor_type(\\n+ data,\\n+ (\\n+ recursively_apply(\\n+ func, o, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n+ )\\n+ for o in data\\n+ ),\\n+ )\\n+ elif isinstance(data, dict):\\n+ return type(data)(\\n+ **{\\n+ k: recursively_apply(\\n+ func, v, *args, test_type=test_type, error_on_other_type=error_on_other_type, **kwargs\\n+ )\\n+ for k, v in data.items()\\n+ }\\n+ )\\n+ elif test_type(data):\\n+ return func(data, *args, **kwargs)\\n+ elif error_on_other_type:\\n+ raise TypeError(\\n+ f\\\"Can't apply {func.__name__} on object of type {type(data)}, only of nested list/tuple/dicts of objects \\\"\\n+ f\\\"that satisfy {test_type.__name__}.\\\"\\n+ )\\n+ return data\\n+\\n+\\n def send_to_device(tensor, device):\\n \\\"\\\"\\\"\\n Recursively sends the elements in a nested list/tuple/dictionary of tensors to a given device.\\n@@ -128,18 +194,52 @@ def send_to_device(tensor, device):\\n Returns:\\n The same data structure as :obj:`tensor` with all tensors sent to the proper device.\\n \\\"\\\"\\\"\\n- if isinstance(tensor, (list, tuple)):\\n- return honor_type(tensor, (send_to_device(t, device) for t in tensor))\\n- elif isinstance(tensor, dict):\\n- return type(tensor)({k: send_to_device(v, device) for k, v in tensor.items()})\\n- elif not hasattr(tensor, \\\"to\\\"):\\n- return tensor\\n- return tensor.to(device)\\n+\\n+ def _send_to_device(t, device):\\n+ return t.to(device)\\n+\\n+ def _has_to_method(t):\\n+ return hasattr(t, \\\"to\\\")\\n+\\n+ return recursively_apply(_send_to_device, tensor, device, test_type=_has_to_method, error_on_other_type=True)\\n+\\n+\\n+def get_data_structure(data):\\n+ \\\"\\\"\\\"\\n+ Recursively gathers the information needed to rebuild a nested list/tuple/dictionary of tensors.\\n+\\n+ Args:\\n+ data (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to send to analyze.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`data` with :class:`~accelerate.utils.TensorInformation` instead of tensors.\\n+ \\\"\\\"\\\"\\n+\\n+ def _get_data_structure(tensor):\\n+ return TensorInformation(shape=tensor.shape, dtype=tensor.dtype)\\n+\\n+ return recursively_apply(_get_data_structure, data)\\n+\\n+\\n+def initialize_tensors(data_structure):\\n+ \\\"\\\"\\\"\\n+ Recursively initializes tensors from a nested list/tuple/dictionary of\\n+ :class:`~accelerate.utils.TensorInformation`.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`data` with tensors instead of :class:`~accelerate.utils.TensorInformation`.\\n+ \\\"\\\"\\\"\\n+\\n+ def _initialize_tensor(tensor_info):\\n+ return torch.empty(*tensor_info.shape, dtype=tensor_info.dtype)\\n+\\n+ return recursively_apply(_initialize_tensor, data_structure, test_type=is_tensor_information)\\n \\n \\n def convert_to_fp32(tensor):\\n \\\"\\\"\\\"\\n- Recursively converts the lements nested list/tuple/dictionary of tensors in FP16 precision to FP32.\\n+ Recursively converts the elements nested list/tuple/dictionary of tensors in FP16 precision to FP32.\\n \\n Args:\\n tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n@@ -148,13 +248,14 @@ def convert_to_fp32(tensor):\\n Returns:\\n The same data structure as :obj:`tensor` with all tensors that were in FP16 precision converted to FP32.\\n \\\"\\\"\\\"\\n- if isinstance(tensor, (list, tuple)):\\n- return honor_type(tensor, (convert_to_fp32(t) for t in tensor))\\n- elif isinstance(tensor, dict):\\n- return type(tensor)(**{k: convert_to_fp32(v) for k, v in tensor.items()})\\n- elif not hasattr(tensor, \\\"dtype\\\") or tensor.dtype != torch.float16:\\n- return tensor\\n- return tensor.float()\\n+\\n+ def _convert_to_fp32(tensor):\\n+ return tensor.float()\\n+\\n+ def _is_fp16_tensor(tensor):\\n+ return hasattr(tensor, \\\"dtype\\\") and tensor.dtype == torch.float16\\n+\\n+ return recursively_apply(_is_fp16_tensor, tensor, test_type=_is_fp16_tensor)\\n \\n \\n def convert_outputs_to_fp32(model_forward):\\n@@ -196,7 +297,7 @@ def extract_model_from_parallel(model):\\n return model\\n \\n \\n-def _tpu_gather(tensor, name=\\\"tensor\\\"):\\n+def _tpu_gather(tensor, name=\\\"gather tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (_tpu_gather(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n elif isinstance(tensor, dict):\\n@@ -209,17 +310,14 @@ def _tpu_gather(tensor, name=\\\"tensor\\\"):\\n \\n \\n def _gpu_gather(tensor):\\n- if isinstance(tensor, (list, tuple)):\\n- return honor_type(tensor, (_gpu_gather(t) for t in tensor))\\n- elif isinstance(tensor, dict):\\n- return type(tensor)({k: _gpu_gather(v) for k, v in tensor.items()})\\n- elif not isinstance(tensor, torch.Tensor):\\n- raise TypeError(f\\\"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n- if tensor.ndim == 0:\\n- tensor = tensor.clone()[None]\\n- output_tensors = [tensor.clone() for _ in range(torch.distributed.get_world_size())]\\n- torch.distributed.all_gather(output_tensors, tensor)\\n- return torch.cat(output_tensors, dim=0)\\n+ def _gpu_gather_one(tensor):\\n+ if tensor.ndim == 0:\\n+ tensor = tensor.clone()[None]\\n+ output_tensors = [tensor.clone() for _ in range(torch.distributed.get_world_size())]\\n+ torch.distributed.all_gather(output_tensors, tensor)\\n+ return torch.cat(output_tensors, dim=0)\\n+\\n+ return recursively_apply(_gpu_gather_one, tensor, error_on_other_type=True)\\n \\n \\n _cpu_gather = _gpu_gather\\n@@ -246,6 +344,130 @@ def gather(tensor):\\n return tensor\\n \\n \\n+def _gpu_broadcast(data, src=0):\\n+ def _gpu_broadcast_one(tensor, src=0):\\n+ torch.distributed.broadcast(tensor, src=src)\\n+ return tensor\\n+\\n+ return recursively_apply(_gpu_broadcast_one, data, error_on_other_type=True, src=src)\\n+\\n+\\n+def _tpu_broadcast(tensor, src=0, name=\\\"broadcast tensor\\\"):\\n+ if isinstance(tensor, (list, tuple)):\\n+ return honor_type(tensor, (_tpu_broadcast(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n+ elif isinstance(tensor, dict):\\n+ return type(tensor)({k: _tpu_broadcast(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n+ return xm.mesh_reduce(name, tensor, lambda x: x[src])\\n+\\n+\\n+def broadcast(tensor, from_process: int = 0):\\n+ \\\"\\\"\\\"\\n+ Recursively broadcast tensor in a nested list/tuple/dictionary of tensors to all devices.\\n+\\n+ Args:\\n+ tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to gather.\\n+ from_process (:obj:`int`, `optional`, defaults to 0):\\n+ The process from which to send the data\\n+\\n+ Returns:\\n+ The same data structure as :obj:`tensor` with all tensors broadcasted to the proper device.\\n+ \\\"\\\"\\\"\\n+ if AcceleratorState().distributed_type == DistributedType.TPU:\\n+ return _tpu_broadcast(tensor, src=from_process, name=\\\"accelerate.utils.broadcast\\\")\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ return _gpu_broadcast(tensor, src=from_process)\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n+ return _gpu_broadcast(tensor, src=from_process)\\n+ else:\\n+ return tensor\\n+\\n+\\n+def broadcast_object_list(object_list, from_process: int = 0):\\n+ \\\"\\\"\\\"\\n+ Broadcast a list of picklable objects form one process to the others.\\n+\\n+ Args:\\n+ object_list (list of picklable objects):\\n+ The list of objects to broadcast. This list will be modified inplace.\\n+ from_process (:obj:`int`, `optional`, defaults to 0):\\n+ The process from which to send the data.\\n+\\n+ Returns:\\n+ The same list containing the objects from process 0.\\n+ \\\"\\\"\\\"\\n+ if AcceleratorState().distributed_type == DistributedType.TPU:\\n+ for i, obj in enumerate(object_list):\\n+ object_list[i] = xm.mesh_reduce(\\\"accelerate.utils.broadcast_object_list\\\", obj, lambda x: x[from_process])\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ torch.distributed.broadcast_object_list(object_list, src=from_process)\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n+ torch.distributed.broadcast_object_list(object_list, src=from_process)\\n+ return object_list\\n+\\n+\\n+def slice_tensors(data, tensor_slice):\\n+ \\\"\\\"\\\"\\n+ Recursively takes a slice in a nested list/tuple/dictionary of tensors.\\n+\\n+ Args:\\n+ data (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to slice.\\n+ tensor_slice (:obj:`slice`):\\n+ The slice to take.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`data` with all the tensors slices.\\n+ \\\"\\\"\\\"\\n+\\n+ def _slice_tensor(tensor, tensor_slice):\\n+ return tensor[tensor_slice]\\n+\\n+ return recursively_apply(_slice_tensor, data, tensor_slice)\\n+\\n+\\n+def find_batch_size(data):\\n+ \\\"\\\"\\\"\\n+ Recursively finds the batch size in a nested list/tuple/dictionary of lists of tensors.\\n+\\n+ Args:\\n+ data (nested list/tuple/dictionary of :obj:`torch.Tensor`): The data from which to find the batch size.\\n+\\n+ Returns:\\n+ :obj:`int`: The batch size.\\n+ \\\"\\\"\\\"\\n+ if isinstance(data, (tuple, list)):\\n+ return find_batch_size(data[0])\\n+ elif isinstance(data, dict):\\n+ for k in data.keys():\\n+ return find_batch_size(data[k])\\n+ elif not isinstance(data, torch.Tensor):\\n+ raise TypeError(f\\\"Can only find the batch size of tensors but got {type(data)}.\\\")\\n+ return data.shape[0]\\n+\\n+\\n+def concatenate(data, dim=0):\\n+ \\\"\\\"\\\"\\n+ Recursively concatenate the tensors in a nested list/tuple/dictionary of lists of tensors with the same shape.\\n+\\n+ Args:\\n+ data (nested list/tuple/dictionary of lists of tensors :obj:`torch.Tensor`):\\n+ The data to concatenate.\\n+ dim (:obj:`int`, `optional`, defaults to 0):\\n+ The dimension on which to concatenate.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`data` with all the tensors concatenated.\\n+ \\\"\\\"\\\"\\n+ if isinstance(data[0], (tuple, list)):\\n+ return honor_type(data[0], (concatenate([d[i] for d in data], dim=dim) for i in range(len(data[0]))))\\n+ elif isinstance(data[0], dict):\\n+ return type(data[0])(**{k: concatenate([d[k] for d in data], dim=dim) for k in data[0].keys()})\\n+ elif not isinstance(data[0], torch.Tensor):\\n+ raise TypeError(f\\\"Can only concatenate tensors but got {type(data[0])}\\\")\\n+ return torch.cat(data, dim=dim)\\n+\\n+\\n def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n \\\"\\\"\\\"\\n Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so they\\n@@ -261,36 +483,35 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n pad_first (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n Whether to pad at the beginning or the end.\\n \\\"\\\"\\\"\\n- if isinstance(tensor, (list, tuple)):\\n- return honor_type(tensor, (pad_across_processes(t, dim=dim, pad_index=pad_index) for t in tensor))\\n- elif isinstance(tensor, dict):\\n- return type(tensor)({k: pad_across_processes(v, dim=dim, pad_index=pad_index) for k, v in tensor.items()})\\n- elif not isinstance(tensor, torch.Tensor):\\n- raise TypeError(f\\\"Can't pad the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n \\n- if dim >= len(tensor.shape):\\n- return tensor\\n-\\n- # Gather all sizes\\n- size = torch.tensor(tensor.shape, device=tensor.device)[None]\\n- sizes = gather(size).cpu()\\n- # Then pad to the maximum size\\n- max_size = max(s[dim] for s in sizes)\\n- if max_size == tensor.shape[dim]:\\n- return tensor\\n-\\n- old_size = tensor.shape\\n- new_size = list(old_size)\\n- new_size[dim] = max_size\\n- new_tensor = tensor.new_zeros(tuple(new_size)) + pad_index\\n- if pad_first:\\n- indices = tuple(\\n- slice(max_size - old_size[dim], max_size) if i == dim else slice(None) for i in range(len(new_size))\\n- )\\n- else:\\n- indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(new_size)))\\n- new_tensor[indices] = tensor\\n- return new_tensor\\n+ def _pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n+ if dim >= len(tensor.shape):\\n+ return tensor\\n+\\n+ # Gather all sizes\\n+ size = torch.tensor(tensor.shape, device=tensor.device)[None]\\n+ sizes = gather(size).cpu()\\n+ # Then pad to the maximum size\\n+ max_size = max(s[dim] for s in sizes)\\n+ if max_size == tensor.shape[dim]:\\n+ return tensor\\n+\\n+ old_size = tensor.shape\\n+ new_size = list(old_size)\\n+ new_size[dim] = max_size\\n+ new_tensor = tensor.new_zeros(tuple(new_size)) + pad_index\\n+ if pad_first:\\n+ indices = tuple(\\n+ slice(max_size - old_size[dim], max_size) if i == dim else slice(None) for i in range(len(new_size))\\n+ )\\n+ else:\\n+ indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(new_size)))\\n+ new_tensor[indices] = tensor\\n+ return new_tensor\\n+\\n+ return recursively_apply(\\n+ _pad_across_processes, tensor, error_on_other_type=True, dim=dim, pad_index=pad_index, pad_first=pad_first\\n+ )\\n \\n \\n def wait_for_everyone():\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n If set to :obj:`True`, the dataloader prepared by the Accelerator is only iterated through on the main\\r\\n```\",\n \"diff_hunk\": \"@@ -82,6 +82,9 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n+ central_dataloader (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ If set to :obj:`True`, the datalaoder prepared by the Accelerator is only iterated through on the main\",\n \"from_author\": false\n },\n {\n \"body\": \"I don't like `central` as I don't really understand what it means from a quick read, but I spent 10 minutes trying to find a better name without success, so fine to leave it like it is :)\",\n \"diff_hunk\": \"@@ -82,6 +82,9 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n+ central_dataloader (:obj:`bool`, `optional`, defaults to :obj:`False`):\",\n \"from_author\": false\n },\n {\n \"body\": \"What is this `my_batch_size` used for?\",\n \"diff_hunk\": \"@@ -421,6 +524,13 @@ def prepare_data_loader(\\n if new_batch_sampler is None:\\n kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\n \\n+ if central_dataloader:\\n+ data_loader = DataLoaderDispatcher(\\n+ new_dataset, split_batches=split_batches, batch_sampler=new_batch_sampler, **kwargs\\n+ )\\n+ data_loader.my_batch_size = dataloader.batch_size\",\n \"from_author\": false\n },\n {\n \"body\": \"Please add an error message if it fails :)\",\n \"diff_hunk\": \"@@ -108,6 +108,71 @@ def dl_preparation_check():\\n print(\\\"Shuffled dataloader passing.\\\")\\n \\n \\n+def central_dl_preparation_check():\\n+ state = AcceleratorState()\\n+ length = 32 * state.num_processes\\n+\\n+ dl = DataLoader(range(length), batch_size=8)\\n+ dl = prepare_data_loader(\\n+ dl, state.device, state.num_processes, state.process_index, put_on_device=True, central_dataloader=True\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result)\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long())\",\n \"from_author\": false\n },\n {\n \"body\": \"Oh actually this applies to all `assert` in this file!\",\n \"diff_hunk\": \"@@ -108,6 +108,71 @@ def dl_preparation_check():\\n print(\\\"Shuffled dataloader passing.\\\")\\n \\n \\n+def central_dl_preparation_check():\\n+ state = AcceleratorState()\\n+ length = 32 * state.num_processes\\n+\\n+ dl = DataLoader(range(length), batch_size=8)\\n+ dl = prepare_data_loader(\\n+ dl, state.device, state.num_processes, state.process_index, put_on_device=True, central_dataloader=True\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result)\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long())\",\n \"from_author\": false\n },\n {\n \"body\": \"Woopsie, this is some leftover to clean up! Thanks for flagging!\",\n \"diff_hunk\": \"@@ -421,6 +524,13 @@ def prepare_data_loader(\\n if new_batch_sampler is None:\\n kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\n \\n+ if central_dataloader:\\n+ data_loader = DataLoaderDispatcher(\\n+ new_dataset, split_batches=split_batches, batch_sampler=new_batch_sampler, **kwargs\\n+ )\\n+ data_loader.my_batch_size = dataloader.batch_size\",\n \"from_author\": true\n },\n {\n \"body\": \"This is just a test script ;-)\",\n \"diff_hunk\": \"@@ -108,6 +108,71 @@ def dl_preparation_check():\\n print(\\\"Shuffled dataloader passing.\\\")\\n \\n \\n+def central_dl_preparation_check():\\n+ state = AcceleratorState()\\n+ length = 32 * state.num_processes\\n+\\n+ dl = DataLoader(range(length), batch_size=8)\\n+ dl = prepare_data_loader(\\n+ dl, state.device, state.num_processes, state.process_index, put_on_device=True, central_dataloader=True\\n+ )\\n+ result = []\\n+ for batch in dl:\\n+ result.append(gather(batch))\\n+ result = torch.cat(result)\\n+ assert torch.equal(result.cpu(), torch.arange(0, length).long())\",\n \"from_author\": true\n },\n {\n \"body\": \"Let's go for `dispath_batches` to look like `split_batches`\",\n \"diff_hunk\": \"@@ -82,6 +82,9 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n+ central_dataloader (:obj:`bool`, `optional`, defaults to :obj:`False`):\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/164\",\n \"pr_id\": 734968636\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex d81e4ab61..ca49adf45 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -203,6 +203,8 @@ def _tpu_gather(tensor, name=\\\"tensor\\\"):\\n return type(tensor)({k: _tpu_gather(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n raise TypeError(f\\\"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n+ if tensor.ndim == 0:\\n+ tensor = tensor.clone()[None]\\n return xm.mesh_reduce(name, tensor, torch.cat)\\n \\n \\n@@ -213,6 +215,8 @@ def _gpu_gather(tensor):\\n return type(tensor)({k: _gpu_gather(v) for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n raise TypeError(f\\\"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n+ if tensor.ndim == 0:\\n+ tensor = tensor.clone()[None]\\n output_tensors = [tensor.clone() for _ in range(torch.distributed.get_world_size())]\\n torch.distributed.all_gather(output_tensors, tensor)\\n return torch.cat(output_tensors, dim=0)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/152\",\n \"pr_id\": 722757010\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 3e9f5f470..585d2aa88 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -152,7 +152,7 @@ just run\\n \\n accelerate config\\n \\n-on your machine and reply to the questions asked. This will save a `default_config.json` file in your cache folder for\\n+on your machine and reply to the questions asked. This will save a `default_config.yaml` file in your cache folder for\\n π€ Accelerate. That cache folder is (with decreasing order of priority):\\n \\n - The content of your environment variable ``HF_HOME`` suffixed with `accelerate`.\\n@@ -176,7 +176,7 @@ Note that if you specified a location for the config file in the previous step,\\n \\n .. code-block:: bash\\n \\n- accelerate test --config_file path_to_config.json\\n+ accelerate test --config_file path_to_config.yaml\\n \\n \\n Now that this is done, you can run your script with the following command:\\n@@ -190,7 +190,7 @@ If you stored the config file in a non-default location, you can indicate it to\\n \\n .. code-block:: bash\\n \\n- accelerate launch --config_file path_to_config.json path_to_script.py --args_for_the_script\\n+ accelerate launch --config_file path_to_config.yaml path_to_script.py --args_for_the_script\\n \\n You can also override any of the arguments determined by your config file, see TODO: insert ref here.\\n \\ndiff --git a/src/accelerate/commands/config/__init__.py b/src/accelerate/commands/config/__init__.py\\nindex 48ea96ab1..5bafb3be2 100644\\n--- a/src/accelerate/commands/config/__init__.py\\n+++ b/src/accelerate/commands/config/__init__.py\\n@@ -48,7 +48,7 @@ def config_command_parser(subparsers=None):\\n \\\"--config_file\\\",\\n default=None,\\n help=(\\n- \\\"The path to use to store the config file. Will default to a file named default_config.json in the cache \\\"\\n+ \\\"The path to use to store the config file. Will default to a file named default_config.yaml in the cache \\\"\\n \\\"location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have \\\"\\n \\\"such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed \\\"\\n \\\"with 'huggingface'.\\\"\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 55b019fa4..39c00c280 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -28,7 +28,7 @@\\n os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n )\\n cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n-default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n \\n # For backward compatibility: the default config is the json one if it's the only existing file.\\ndiff --git a/src/accelerate/commands/test.py b/src/accelerate/commands/test.py\\nindex ec6d2524b..379233679 100644\\n--- a/src/accelerate/commands/test.py\\n+++ b/src/accelerate/commands/test.py\\n@@ -30,7 +30,7 @@ def test_command_parser(subparsers=None):\\n \\\"--config_file\\\",\\n default=None,\\n help=(\\n- \\\"The path to use to store the config file. Will default to a file named default_config.json in the cache \\\"\\n+ \\\"The path to use to store the config file. Will default to a file named default_config.yaml in the cache \\\"\\n \\\"location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have \\\"\\n \\\"such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed \\\"\\n \\\"with 'huggingface'.\\\"\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/151\",\n \"pr_id\": 722375795\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex a6b7a7d74..c5238369c 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -388,4 +388,5 @@ def __post_init__(self):\\n },\\n },\\n \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ \\\"zero_allow_untested_optimizer\\\": True,\\n }\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"FYI, I'm not involved with accelerate's deepspeed integration. I suggested that it will be done in same way as transformers when it was first contributed, but it was still committed in a different way. Thus now the user has to use a completely different setup when switching from transformers and developers have to maintain something totally different. So I'm not participating in this particular endeavour.\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/150\",\n \"pr_id\": 722373435\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex a6b7a7d74..d81e4ab61 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -151,7 +151,7 @@ def convert_to_fp32(tensor):\\n if isinstance(tensor, (list, tuple)):\\n return honor_type(tensor, (convert_to_fp32(t) for t in tensor))\\n elif isinstance(tensor, dict):\\n- return type(tensor)({k: convert_to_fp32(v) for k, v in tensor.items()})\\n+ return type(tensor)(**{k: convert_to_fp32(v) for k, v in tensor.items()})\\n elif not hasattr(tensor, \\\"dtype\\\") or tensor.dtype != torch.float16:\\n return tensor\\n return tensor.float()\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/149\",\n \"pr_id\": 721725679\n },\n {\n \"diff\": \"diff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex 8707ed373..3b1281c84 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -136,7 +136,7 @@ Supported integrations\\n - multi-GPU on several nodes (machines)\\n - TPU\\n - FP16 with native AMP (apex on the roadmap)\\n-- DeepSpeed (experimental)\\n+- DeepSpeed (experimental support)\\n \\n .. toctree::\\n :maxdepth: 2\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 68a23fff5..3e9f5f470 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -381,6 +381,22 @@ this:\\n lr_scheduler.step()\\n \\n \\n+DeepSpeed\\n+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n+\\n+DeepSpeed support is experimental, so the underlying API will evolve in the near future and may have some slight\\n+breaking changes. In particular, π€ Accelerate does not support DeepSpeed config you have written yourself yet, this\\n+will be added in a next version.\\n+\\n+One main caveat for the DeepSpeed integration is that the DeepSpeed launcher always passes a ``local_rank`` variable to\\n+the training script, so your training script should accept it (whether you launch training with the DeepSpeed launcher\\n+or ``accelerate launch``).\\n+\\n+.. Warning::\\n+\\n+ The :func:`~accelerate.notebook_launcher` does not support the DeepSpeed integration yet.\\n+\\n+\\n Internal mechanism\\n -----------------------------------------------------------------------------------------------------------------------\\n \\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\nor ``accelerate launch``).\\r\\n```\",\n \"diff_hunk\": \"@@ -381,6 +381,22 @@ this:\\n lr_scheduler.step()\\n \\n \\n+DeepSpeed\\n+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n+\\n+DeepSpeed support is experimental, so the underlying API will evolve in the near future and may have some slight\\n+breaking changes. In particular, π€ Accelerate does not support DeepSpeed config you have written yourself yet, this\\n+will be added in a next version.\\n+\\n+One main caveat for the DeepSpeed integration is that the DeepSpeed launcher always passes a ``local_rank`` variable to\\n+the training script, so your training script should accept it (whether you launch training with the DeepSpeed launcher\\n+or ``accelerate launch`` Accelerate.\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/140\",\n \"pr_id\": 707116659\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 7ccdf5daf..07035a427 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -358,6 +358,20 @@ softmax). However you might want to put your loss computation inside the `accele\\n with accelerator.autocast():\\n loss = complex_loss_function(outputs, target):\\n \\n+Another caveat with Mixed Precision training is that the gradient will skip a few updates at the beginning and\\n+sometimes during training: because of the dynamic loss scaling strategy, there are points during training where the\\n+gradients have overflown, and the loss scaling factor is reduced to avoid this happening again at the next step.\\n+\\n+This means that you may update your learning rate scheduler when there was no update, which is fine in general, but may\\n+have an impact when you have very little training data, or if the first learning rate values of your scheduler are very\\n+important. In this case, you can skip the learning rate scheduler updates when the optimizer step was not done like\\n+this:\\n+\\n+.. codeblock::\\n+\\n+ if not accelerator.optimizer_step_was_skipped:\\n+ lr_scheduler.step()\\n+\\n \\n Internal mechanism\\n -----------------------------------------------------------------------------------------------------------------------\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a11b7a7a5..a35f7e268 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -566,3 +566,14 @@ def autocast(self):\\n autocast_context.__exit__()\\n else:\\n yield\\n+\\n+ @property\\n+ def optimizer_step_was_skipped(self):\\n+ \\\"\\\"\\\"\\n+ Whether or not the optimizer update was skipped (because of gradient overflow in mixed precision), in which\\n+ case the learning rate should not be changed.\\n+ \\\"\\\"\\\"\\n+ for optimizer in self._optimizers:\\n+ if optimizer.is_overflow:\\n+ return True\\n+ return False\\ndiff --git a/src/accelerate/deepspeed_utils.py b/src/accelerate/deepspeed_utils.py\\nindex e52c0c030..07450a87e 100644\\n--- a/src/accelerate/deepspeed_utils.py\\n+++ b/src/accelerate/deepspeed_utils.py\\n@@ -89,7 +89,7 @@ def step(self):\\n \\n @property\\n def is_overflow(self):\\n- \\\"\\\"\\\"This must be called before lr_scheduler.step() when using deepspeed with fp16\\\"\\\"\\\"\\n+ \\\"\\\"\\\"Whether or not the optimizer step was done, or skipped because of gradient overflow.\\\"\\\"\\\"\\n overflow = False\\n if hasattr(self.optimizer, \\\"overflow\\\"):\\n overflow = self.optimizer.overflow\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex b2909dbb5..37ca78833 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -53,6 +53,7 @@ def __init__(self, optimizer, device_placement=True, scaler=None):\\n self.scaler = scaler\\n self.state = AcceleratorState()\\n self.device_placement = device_placement\\n+ self._is_overflow = False\\n \\n # Handle device placement\\n if device_placement:\\n@@ -108,8 +109,12 @@ def step(self, closure=None):\\n optimizer_args = {\\\"closure\\\": closure} if closure is not None else {}\\n xm.optimizer_step(self.optimizer, optimizer_args=optimizer_args)\\n elif self.scaler is not None:\\n+ scale_before = self.scaler.get_scale()\\n self.scaler.step(self.optimizer, closure)\\n self.scaler.update()\\n+ scale_after = self.scaler.get_scale()\\n+ # If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.\\n+ self._is_overflow = scale_after < scale_before\\n else:\\n self.optimizer.step(closure)\\n \\n@@ -119,5 +124,5 @@ def _switch_parameters(self, parameters_map):\\n \\n @property\\n def is_overflow(self):\\n- \\\"\\\"\\\"This needs to be implemented at the end\\\"\\\"\\\"\\n- return False # TODO: implement it\\n+ \\\"\\\"\\\"Whether or not the optimizer step was done, or skipped because of gradient overflow.\\\"\\\"\\\"\\n+ return self._is_overflow\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\nsometimes during training: because of the dynamic loss scaling strategy, there are points during training where the\\r\\n```\",\n \"diff_hunk\": \"@@ -358,6 +358,20 @@ softmax). However you might want to put your loss computation inside the `accele\\n with accelerator.autocast():\\n loss = complex_loss_function(outputs, target):\\n \\n+Another caveat with Mixed Precision training is that the gradient will skip a few updates at the beginning and\\n+sometimes during training: because of the dynamic loss scaling strategy, there are points at training where the\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nhave an impact when you have very little training data, or if the first learning rate values of your scheduler are very\\r\\n```\",\n \"diff_hunk\": \"@@ -358,6 +358,20 @@ softmax). However you might want to put your loss computation inside the `accele\\n with accelerator.autocast():\\n loss = complex_loss_function(outputs, target):\\n \\n+Another caveat with Mixed Precision training is that the gradient will skip a few updates at the beginning and\\n+sometimes during training: because of the dynamic loss scaling strategy, there are points at training where the\\n+gradients have overflown, and the loss scaling factor is reduced to avoid this happening again at the next step.\\n+\\n+This means that you may update your learning rate scheduler when there was no update, which is fine in general, but may\\n+have an impace when you have very little training data, or if the first learning rate values of your scheduler are very\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/139\",\n \"pr_id\": 706448160\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 7ccdf5daf..2efdf6a82 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -251,6 +251,13 @@ To introduce special behavior in your script for TPUs you can check the :obj:`di\\n The `NLP example <https://github.com/huggingface/accelerate/blob/main/examples/nlp_example.py>`__ shows an example in\\n situation with dynamic padding.\\n \\n+One last thing to pay close attnetion to: if your model has tied weights (such as language models which tie the weights\\n+of the embedding matrix with the weights of the decoder), moving this model to the TPU (either yourself or after you\\n+passed your model to :meth:`~accelerate.Accelerator.prepare`) will break the tying. You will need to retie the weights\\n+after. You can find an example of this in the `run_clm_no_trainer\\n+<https://github.com/huggingface/transformers/blob/master/examples/pytorch/language-modeling/run_clm.py>`__ script in\\n+the Transformers repository.\\n+\\n \\n Other caveats\\n -----------------------------------------------------------------------------------------------------------------------\\n@@ -345,6 +352,7 @@ If you are using gradient clipping in your script, you should replace the calls\\n :obj:`torch.nn.utils.clip_grad_norm_` or :obj:`torch.nn.utils.clip_grad_value_` with :obj:`accelerator.clip_grad_norm_`\\n and :obj:`accelerator.clip_grad_value_` respectively.\\n \\n+\\n Mixed Precision training\\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/138\",\n \"pr_id\": 706392343\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 1e28fed85..7ccdf5daf 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -345,6 +345,19 @@ If you are using gradient clipping in your script, you should replace the calls\\n :obj:`torch.nn.utils.clip_grad_norm_` or :obj:`torch.nn.utils.clip_grad_value_` with :obj:`accelerator.clip_grad_norm_`\\n and :obj:`accelerator.clip_grad_value_` respectively.\\n \\n+Mixed Precision training\\n+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n+\\n+If you are running your training in Mixed Precision with Accelerate, you will get the best result with your loss being\\n+computed inside your model (like in Transformer models for instance). Every computation outside of the model will be\\n+executed in full precision (which is generally what you want for loss computation, expecially if it involves a\\n+softmax). However you might want to put your loss computation inside the `accelerator.autocast` context manager:\\n+\\n+.. codeblock::\\n+\\n+ with accelerator.autocast():\\n+ loss = complex_loss_function(outputs, target):\\n+\\n \\n Internal mechanism\\n -----------------------------------------------------------------------------------------------------------------------\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 281f4e9a7..a11b7a7a5 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -28,6 +28,7 @@\\n from .utils import (\\n DeepSpeedPlugin,\\n RNGType,\\n+ convert_outputs_to_fp32,\\n extract_model_from_parallel,\\n gather,\\n pad_across_processes,\\n@@ -295,6 +296,7 @@ def prepare_model(self, model):\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n if self.native_amp:\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n+ model.forward = convert_outputs_to_fp32(model.forward)\\n return model\\n \\n def _prepare_deepspeed(self, *args):\\n@@ -550,3 +552,17 @@ def get_state_dict(self, model):\\n state_dict[k] = state_dict[k].float()\\n \\n return state_dict\\n+\\n+ @contextmanager\\n+ def autocast(self):\\n+ \\\"\\\"\\\"\\n+ Will apply automatic mixed-precision inside the block inside this context manager, if it is enabled. Nothing\\n+ different will happen otherwise.\\n+ \\\"\\\"\\\"\\n+ if self.native_amp:\\n+ autocast_context = torch.cuda.amp.autocast()\\n+ autocast_context.__enter__()\\n+ yield\\n+ autocast_context.__exit__()\\n+ else:\\n+ yield\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 6edd1f1c0..a6b7a7d74 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -137,6 +137,46 @@ def send_to_device(tensor, device):\\n return tensor.to(device)\\n \\n \\n+def convert_to_fp32(tensor):\\n+ \\\"\\\"\\\"\\n+ Recursively converts the lements nested list/tuple/dictionary of tensors in FP16 precision to FP32.\\n+\\n+ Args:\\n+ tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to convert from FP16 to FP32.\\n+\\n+ Returns:\\n+ The same data structure as :obj:`tensor` with all tensors that were in FP16 precision converted to FP32.\\n+ \\\"\\\"\\\"\\n+ if isinstance(tensor, (list, tuple)):\\n+ return honor_type(tensor, (convert_to_fp32(t) for t in tensor))\\n+ elif isinstance(tensor, dict):\\n+ return type(tensor)({k: convert_to_fp32(v) for k, v in tensor.items()})\\n+ elif not hasattr(tensor, \\\"dtype\\\") or tensor.dtype != torch.float16:\\n+ return tensor\\n+ return tensor.float()\\n+\\n+\\n+def convert_outputs_to_fp32(model_forward):\\n+ \\\"\\\"\\\"\\n+ Decorator to apply to a function outputing tensors (like a model forward pass) that ensures the outputs in FP16\\n+ precision will be convert back to FP32.\\n+\\n+ Args:\\n+ model_forward (:obj:`Callable`):\\n+ The function which outputs we want to treat.\\n+\\n+ Returns:\\n+ The same function as :obj:`model_forward` but with converted outputs.\\n+ \\\"\\\"\\\"\\n+\\n+ def convert_outputs(*args, **kwargs):\\n+ outputs = model_forward(*args, **kwargs)\\n+ return convert_to_fp32(outputs)\\n+\\n+ return convert_outputs\\n+\\n+\\n def extract_model_from_parallel(model):\\n \\\"\\\"\\\"\\n Extract a model from its distributed containers.\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n Will apply automatic mixed-precision inside the block inside this context manager, if it is enabled. Nothing\\r\\n```\",\n \"diff_hunk\": \"@@ -550,3 +552,17 @@ def get_state_dict(self, model):\\n state_dict[k] = state_dict[k].float()\\n \\n return state_dict\\n+\\n+ @contextmanager\\n+ def autocast(self):\\n+ \\\"\\\"\\\"\\n+ Will apply automatic mixed precision inside the block inside thics context manager, if it is enabled. Nothing\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/134\",\n \"pr_id\": 704484703\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 30fd8314e..57ea686f9 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -52,6 +52,7 @@ def __init__(self, optimizer, device_placement=True, scaler=None):\\n self.optimizer = optimizer\\n self.scaler = scaler\\n self.state = AcceleratorState()\\n+ self.device_placement = device_placement\\n \\n # Handle device placement\\n if device_placement:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/127\",\n \"pr_id\": 693252365\n },\n {\n \"diff\": \"diff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 44909ab3c..96648ca65 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -104,6 +104,8 @@ def __init__(\\n self.drop_last = batch_sampler.drop_last\\n \\n def __len__(self):\\n+ if self.split_batches:\\n+ return len(self.batch_sampler)\\n if len(self.batch_sampler) % self.num_processes == 0:\\n return len(self.batch_sampler) // self.num_processes\\n length = len(self.batch_sampler) // self.num_processes\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/121\",\n \"pr_id\": 685201522\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 20274b671..281f4e9a7 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -413,8 +413,10 @@ def unscale_gradients(self, optimizer=None):\\n optimizer = self._optimizers\\n elif not isinstance(optimizer, (tuple, list)):\\n optimizer = [optimizer]\\n- for optimizer in optimizer:\\n- self.scaler.unscale_(optimizer)\\n+ for opt in optimizer:\\n+ while isinstance(opt, AcceleratedOptimizer):\\n+ opt = opt.optimizer\\n+ self.scaler.unscale_(opt)\\n \\n def clip_grad_norm_(self, parameters, max_norm, norm_type=2):\\n \\\"\\\"\\\"\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"The tests are not properly setup :see_no_evil: \",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/115\",\n \"pr_id\": 679070761\n },\n {\n \"diff\": \"diff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex 4c785b12f..fef2f0c08 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -16,7 +16,8 @@\\n import sys\\n \\n import torch\\n-from torch.multiprocessing import start_processes\\n+\\n+from packaging import version\\n \\n from .state import AcceleratorState\\n from .utils import PrepareForLaunch\\n@@ -82,6 +83,14 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n \\n if num_processes > 1:\\n # Multi-GPU launch\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.5.0\\\"):\\n+ raise ImportError(\\n+ \\\"Using `notebook_launcher` for distributed training on GPUs require torch >= 1.5.0, got \\\"\\n+ f\\\"{torch.__version__}.\\\"\\n+ )\\n+\\n+ from torch.multiprocessing import start_processes\\n+\\n if len(AcceleratorState._shared_state) > 0:\\n raise ValueError(\\n \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/108\",\n \"pr_id\": 671506096\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex ffbf36bbd..78a2ceb2a 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -44,6 +44,10 @@ limitations under the License.\\n <p>Run your *raw* PyTorch training script on any kind of device\\n </h3>\\n \\n+<h3 align=\\\"center\\\">\\n+ <a href=\\\"https://hf.co/course\\\"><img src=\\\"https://raw.githubusercontent.com/huggingface/transformers/master/docs/source/imgs/course_banner.png\\\"></a>\\n+</h3>\\n+\\n ## Easy to integrate\\n \\n π€ Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boilerplate code needed to use multi-GPUs/TPU/fp16.\\ndiff --git a/docs/source/imgs/course_banner.png b/docs/source/imgs/course_banner.png\\nnew file mode 100644\\nindex 000000000..45773d164\\nBinary files /dev/null and b/docs/source/imgs/course_banner.png differ\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/107\",\n \"pr_id\": 670432129\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 0bbba3644..30fd8314e 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -102,14 +102,15 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ optimizer_args = {\\\"closure\\\": closure} if closure is not None else {}\\n+ xm.optimizer_step(self.optimizer, optimizer_args=optimizer_args)\\n elif self.scaler is not None:\\n- self.scaler.step(self.optimizer)\\n+ self.scaler.step(self.optimizer, closure)\\n self.scaler.update()\\n else:\\n- self.optimizer.step()\\n+ self.optimizer.step(closure)\\n \\n def _switch_parameters(self, parameters_map):\\n for param_group in self.optimizer.param_groups:\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n xm.optimizer_step(self.optimizer, optimizer_args={\\\"closure\\\": closure})\\r\\n```\\r\\nThe [PyTorch XLA doc](https://pytorch.org/xla/release/1.8/index.html#torch_xla.core.xla_model.optimizer_step) seems to suggest we have to use `optimizer_args` to pass this along and it's not the second argument.\",\n \"diff_hunk\": \"@@ -102,14 +102,14 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ xm.optimizer_step(self.optimizer, dict(closure=closure))\",\n \"from_author\": false\n },\n {\n \"body\": \"good catch!\",\n \"diff_hunk\": \"@@ -102,14 +102,14 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ xm.optimizer_step(self.optimizer, dict(closure=closure))\",\n \"from_author\": true\n },\n {\n \"body\": \"Actually thinking a little bit more about it, let's not pass anything if there is no closure:\\r\\n```suggestion\\r\\n optimizer_args = {\\\"closure\\\": closure} if closure is not None else {}\\r\\n xm.optimizer_step(self.optimizer, optimizer_args=optimizer_args)\\r\\n```\",\n \"diff_hunk\": \"@@ -102,14 +102,14 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ xm.optimizer_step(self.optimizer, optimizer_args={\\\"closure\\\": closure})\",\n \"from_author\": false\n },\n {\n \"body\": \"I concur, this is a little more explicit, but it shouldn't matter (famous last words...) because the base `torch.optim.Optimizer` has a `closure` argument. For the other options, we pass that along anyway. \",\n \"diff_hunk\": \"@@ -102,14 +102,14 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ xm.optimizer_step(self.optimizer, optimizer_args={\\\"closure\\\": closure})\",\n \"from_author\": true\n },\n {\n \"body\": \"If you don't mind committing the suggestion then, we're all good to merge :-)\",\n \"diff_hunk\": \"@@ -102,14 +102,14 @@ def zero_grad(self, set_to_none=None):\\n set_to_none = False\\n self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n- def step(self):\\n+ def step(self, closure=None):\\n if self.state.distributed_type == DistributedType.TPU:\\n- xm.optimizer_step(self.optimizer)\\n+ xm.optimizer_step(self.optimizer, optimizer_args={\\\"closure\\\": closure})\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/105\",\n \"pr_id\": 670035276\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 2bc1459fd..a700cad62 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -387,16 +387,16 @@ def prepare_data_loader(self, data_loader):\\n def prepare_optimizer(self, optimizer):\\n return AcceleratedOptimizer(optimizer, device_placement=self.device_placement, scaler=self.scaler)\\n \\n- def backward(self, loss):\\n+ def backward(self, loss, **kwargs):\\n \\\"\\\"\\\"\\n Use :obj:`accelerator.backward(loss)` in lieu of :obj:`loss.backward()`.\\n \\\"\\\"\\\"\\n if self.distributed_type == DistributedType.DEEPSPEED:\\n- self.deepspeed_engine.backward(loss)\\n+ self.deepspeed_engine.backward(loss, **kwargs)\\n elif self.scaler is not None:\\n- self.scaler.scale(loss).backward()\\n+ self.scaler.scale(loss).backward(**kwargs)\\n else:\\n- loss.backward()\\n+ loss.backward(**kwargs)\\n \\n def unscale_gradients(self, optimizer=None):\\n \\\"\\\"\\\"\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/104\",\n \"pr_id\": 669621064\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex d119013d2..2bc1459fd 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -14,6 +14,7 @@\\n \\n import gc\\n import os\\n+from contextlib import contextmanager\\n from typing import List, Optional, Union\\n \\n import torch\\n@@ -183,6 +184,33 @@ def use_fp16(self):\\n use_fp16 = self.state.use_fp16\\n return use_fp16\\n \\n+ @contextmanager\\n+ def local_main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the local main process go inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_local_main_process)\\n+\\n+ @contextmanager\\n+ def main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the main process go first inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_main_process)\\n+\\n+ def _goes_first(self, is_main):\\n+ if not is_main:\\n+ self.wait_for_everyone()\\n+\\n+ yield\\n+\\n+ if is_main:\\n+ self.wait_for_everyone()\\n+\\n def print(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n Use in replacement of :obj:`print()` to only print once per server.\\n\",\n \"code_comments\": [\n {\n \"body\": \"Small nit: can we use `is_main` for consistency here (as well as at line 211 below)?\",\n \"diff_hunk\": \"@@ -183,6 +184,33 @@ def use_fp16(self):\\n use_fp16 = self.state.use_fp16\\n return use_fp16\\n \\n+ @contextmanager\\n+ def local_main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the local main process go inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_local_main_process)\\n+\\n+ @contextmanager\\n+ def main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the main process go first inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_main_process)\\n+\\n+ def _goes_first(self, is_master):\\n+ if not is_master:\",\n \"from_author\": false\n },\n {\n \"body\": \"Yes sure!\",\n \"diff_hunk\": \"@@ -183,6 +184,33 @@ def use_fp16(self):\\n use_fp16 = self.state.use_fp16\\n return use_fp16\\n \\n+ @contextmanager\\n+ def local_main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the local main process go inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_local_main_process)\\n+\\n+ @contextmanager\\n+ def main_process_first(self):\\n+ \\\"\\\"\\\"\\n+ Lets the main process go first inside a with block.\\n+\\n+ The other processes will enter the with block after the main process exits.\\n+ \\\"\\\"\\\"\\n+ yield from self._goes_first(self.is_main_process)\\n+\\n+ def _goes_first(self, is_master):\\n+ if not is_master:\",\n \"from_author\": true\n }\n ],\n \"context\": [\n {\n \"body\": \"Addressed the request.\",\n \"from_author\": true\n },\n {\n \"body\": \"Thanks!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/98\",\n \"pr_id\": 661117028\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex c7706d390..7c12b18e6 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -12,6 +12,7 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import gc\\n from typing import List, Optional, Union\\n \\n import torch\\n@@ -338,6 +339,15 @@ def save(self, obj, f):\\n \\\"\\\"\\\"\\n save(obj, f)\\n \\n+ def free_memory(self):\\n+ \\\"\\\"\\\"\\n+ Will release all references to the internal objects stored and call the garbage collector. You should call this\\n+ method between two trainings with different models/optimizers.\\n+ \\\"\\\"\\\"\\n+ self._optimizers = []\\n+ gc.collect()\\n+ torch.cuda.empty_cache()\\n+\\n def _get_named_parameters(self, *args):\\n named_parameters = {}\\n for obj in args:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/89\",\n \"pr_id\": 645882788\n },\n {\n \"diff\": \"diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex c7706d390..5a4bbe217 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -253,24 +253,36 @@ def backward(self, loss):\\n else:\\n loss.backward()\\n \\n- def clip_grad_norm_(self, parameters, max_norm, norm_type=2):\\n+ def unscale_gradients(self, optimizer=None):\\n \\\"\\\"\\\"\\n- Should be used in place of :func:`torch.nn.utils.clip_grad_norm_`.\\n+ Unscale the gradients in mixed precision training with AMP. This is a noop in all other settings.\\n+\\n+ Args:\\n+ optimizer (:obj:`torch.optim.Optimizer` or :obj:`List[torch.optim.Optimizer]`, `optional`):\\n+ The optimizer(s) for which to unscale gradients. If not set, will unscale gradients on all optimizers\\n+ that were passed to :meth:`~accelerate.Accelerator.prepare`.\\n \\\"\\\"\\\"\\n- # TODO: this unscales all optimizers where we should only unscale the one where parameters are.\\n if self.state.use_fp16 and self.native_amp:\\n- for optimizer in self._optimizers:\\n+ if optimizer is None:\\n+ # TODO: this unscales all optimizers where we should only unscale the one where parameters are.\\n+ optimizer = self._optimizers\\n+ elif not isinstance(optimizer, (tuple, list)):\\n+ optimizer = [optimizer]\\n+ for optimizer in optimizer:\\n self.scaler.unscale_(optimizer)\\n+\\n+ def clip_grad_norm_(self, parameters, max_norm, norm_type=2):\\n+ \\\"\\\"\\\"\\n+ Should be used in place of :func:`torch.nn.utils.clip_grad_norm_`.\\n+ \\\"\\\"\\\"\\n+ self.unscale_gradients()\\n torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type=norm_type)\\n \\n def clip_grad_value_(self, parameters, clip_value):\\n \\\"\\\"\\\"\\n Should be used in place of :func:`torch.nn.utils.clip_grad_value_`.\\n \\\"\\\"\\\"\\n- # TODO: this unscales all optimizers where we should only unscale the one where parameters are.\\n- if self.state.use_fp16 and self.native_amp:\\n- for optimizer in self._optimizers:\\n- self.scaler.unscale_(optimizer)\\n+ self.unscale_gradients()\\n torch.nn.utils.clip_grad_value_(parameters, clip_value)\\n \\n def gather(self, tensor):\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/88\",\n \"pr_id\": 645879064\n },\n {\n \"diff\": \"diff --git a/examples/README.md b/examples/README.md\\nindex 4d941b5d3..19995fc0a 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -23,7 +23,7 @@ The [nlp_example.py](./nlp_example.py) script is a simple example to train a Ber\\n Prior to running it you should install π€ Dataset and π€ Transformers:\\n \\n ```bash\\n-pip install datasets, transformers\\n+pip install datasets transformers\\n ```\\n \\n The same script can be run in any of the following configurations:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/87\",\n \"pr_id\": 645708436\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 4f6cf5f40..ffbf36bbd 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. to use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\n+\\n+```python\\n+from accelerator import Accelerator, DeepSpeedPlugin\\n+\\n+# deepspeed needs to know your gradient accumulation steps before hand, so don't forget to pass it\\n+# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed\\n+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)\\n+accelerator = Accelerator(fp16=True, deepspeed_plugin=deepspeed_plugin)\\n+\\n+# How to save your π€ Transformer?\\n+accelerator.wait_for_everyone()\\n+unwrapped_model = accelerator.unwrap_model(model)\\n+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))\\n+```\\n+\\n+Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.\\n+\\n ## Launching your training from a notebook\\n \\n π€ Accelerate also provides a `notebook_launcher` function you can use in a notebook to launch a distributed training. This is especially useful for Colab or Kaggle notebooks with a TPU backend. Just define your training loop in a `training_function` then in your last cell, add:\\n@@ -204,3 +224,4 @@ pip install accelerate\\n - multi-GPU on several nodes (machines)\\n - TPU\\n - FP16 with native AMP (apex on the roadmap)\\n+- DeepSpeed support (experimental)\\ndiff --git a/src/accelerate/__init__.py b/src/accelerate/__init__.py\\nindex f793b38c1..f6206df02 100644\\n--- a/src/accelerate/__init__.py\\n+++ b/src/accelerate/__init__.py\\n@@ -8,4 +8,4 @@\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs\\n from .notebook_launcher import notebook_launcher\\n from .state import DistributedType\\n-from .utils import synchronize_rng_states\\n+from .utils import DeepSpeedPlugin, synchronize_rng_states\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 7b09375df..d119013d2 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -13,6 +13,7 @@\\n # limitations under the License.\\n \\n import gc\\n+import os\\n from typing import List, Optional, Union\\n \\n import torch\\n@@ -22,8 +23,26 @@\\n from .data_loader import prepare_data_loader\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n-from .state import AcceleratorState, DistributedType\\n-from .utils import RNGType, extract_model_from_parallel, gather, pad_across_processes, save, wait_for_everyone\\n+from .state import AcceleratorState, DistributedType, is_deepspeed_available\\n+from .utils import (\\n+ DeepSpeedPlugin,\\n+ RNGType,\\n+ extract_model_from_parallel,\\n+ gather,\\n+ pad_across_processes,\\n+ save,\\n+ wait_for_everyone,\\n+)\\n+\\n+\\n+if is_deepspeed_available():\\n+ import deepspeed\\n+ from .deepspeed_utils import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper\\n+\\n+import logging\\n+\\n+\\n+logger = logging.getLogger(__name__)\\n \\n \\n class Accelerator:\\n@@ -46,6 +65,9 @@ class Accelerator:\\n cpu (:obj:`bool`, `optional`):\\n Whether or not to force the script to execute on CPU. Will ignore GPU available if set to :obj:`True` and\\n force the execution on one process only.\\n+ deepspeed_plugin (:obj:`DeepSpeedPlugin`, `optional`):\\n+ Tweak your DeepSpeed related args using this argument. This argument is optional and can be configured\\n+ directly using `accelerate config`\\n rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n The list of random number generators to synchronize at the beginning of each iteration in your prepared\\n dataloaders. Should be one or several of:\\n@@ -74,10 +96,18 @@ def __init__(\\n split_batches: bool = False,\\n fp16: bool = None,\\n cpu: bool = False,\\n+ deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n- self.state = AcceleratorState(fp16=fp16, cpu=cpu, _from_accelerator=True)\\n+ if deepspeed_plugin is None: # init from env variables\\n+ deepspeed_plugin = DeepSpeedPlugin() if os.environ.get(\\\"USE_DEEPSPEED\\\", \\\"false\\\") == \\\"true\\\" else None\\n+ else:\\n+ assert isinstance(\\n+ deepspeed_plugin, DeepSpeedPlugin\\n+ ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\n+\\n+ self.state = AcceleratorState(fp16=fp16, cpu=cpu, deepspeed_plugin=deepspeed_plugin, _from_accelerator=True)\\n \\n self.device_placement = device_placement\\n self.split_batches = split_batches\\n@@ -109,6 +139,7 @@ def __init__(\\n \\n # Internal references to the training objects\\n self._optimizers = []\\n+ self._models = []\\n \\n # RNG Types\\n if rng_types is None:\\n@@ -146,7 +177,11 @@ def is_local_main_process(self):\\n \\n @property\\n def use_fp16(self):\\n- return self.state.use_fp16\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ use_fp16 = self.state.deepspeed_plugin.deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]\\n+ else:\\n+ use_fp16 = self.state.use_fp16\\n+ return use_fp16\\n \\n def print(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n@@ -159,6 +194,7 @@ def _prepare_one(self, obj):\\n if isinstance(obj, torch.utils.data.DataLoader):\\n return self.prepare_data_loader(obj)\\n elif isinstance(obj, torch.nn.Module):\\n+ self._models.append(obj)\\n return self.prepare_model(obj)\\n elif isinstance(obj, torch.optim.Optimizer):\\n optimizer = self.prepare_optimizer(obj)\\n@@ -177,7 +213,6 @@ def prepare(self, *args):\\n - :obj:`torch.utils.data.DataLoader`: PyTorch Dataloader\\n - :obj:`torch.nn.Module`: PyTorch Module\\n - :obj:`torch.optim.Optimizer`: PyTorch Optimizer\\n-\\n \\\"\\\"\\\"\\n # On TPUs, putting the model on the XLA device will create new parameters, so the corresponding optimizer will\\n # have parameters disconnected from the model (so no training :-( ).\\n@@ -199,7 +234,10 @@ def prepare(self, *args):\\n # 1. grabbing old model parameters\\n old_named_params = self._get_named_parameters(*args)\\n \\n- result = tuple(self._prepare_one(obj) for obj in args)\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ result = self._prepare_deepspeed(*args)\\n+ else:\\n+ result = tuple(self._prepare_one(obj) for obj in args)\\n \\n if tpu_should_fix_optimizer:\\n # 2. grabbing new model parameters\\n@@ -231,6 +269,82 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ deepspeed_plugin = self.state.deepspeed_plugin\\n+ self.deepspeed_config = deepspeed_plugin.deepspeed_config\\n+\\n+ batch_sizes = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ if len(batch_sizes) == 0:\\n+ raise ValueError(\\n+ \\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\"\\n+ )\\n+\\n+ batch_size_per_device = min(batch_sizes) if deepspeed_plugin.is_train_batch_min else max(batch_sizes)\\n+ if len(batch_sizes) > 1:\\n+ logger.info(\\n+ f\\\"Since you passed both train and evaluation dataloader, `is_train_batch_min` (here \\\\\\n+ {deepspeed_plugin.is_train_batch_min} will decide the `train_batch_size` ({batch_size_per_device}).\\\"\\n+ )\\n+\\n+ self.deepspeed_config[\\\"train_batch_size\\\"] = (\\n+ batch_size_per_device * deepspeed_plugin.gradient_accumulation_steps * self.num_processes\\n+ )\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ if deepspeed_plugin.auto_opt_mapping:\\n+ is_adam = isinstance(optimizer, torch.optim.Adam)\\n+ is_adamw = isinstance(optimizer, torch.optim.AdamW)\\n+ if (is_adam or is_adamw) and deepspeed_plugin.offload_optimizer_device == \\\"cpu\\\":\\n+ defaults = optimizer.defaults\\n+ optimizer = deepspeed.ops.adam.DeepSpeedCPUAdam(\\n+ model.parameters(),\\n+ lr=defaults[\\\"lr\\\"],\\n+ bias_correction=True,\\n+ betas=defaults[\\\"betas\\\"],\\n+ eps=defaults[\\\"eps\\\"],\\n+ weight_decay=defaults[\\\"weight_decay\\\"],\\n+ amsgrad=defaults[\\\"amsgrad\\\"],\\n+ adamw_mode=is_adamw,\\n+ )\\n+\\n+ # useful when only eval_dataloader is given into `accelerator.prepare()`\\n+ if model is not None:\\n+ engine = DeepSpeedEngineWrapper(\\n+ args=None,\\n+ model=model,\\n+ optimizer=optimizer,\\n+ config_params=self.deepspeed_config,\\n+ dist_init_required=False,\\n+ )\\n+ for i in range(len(result)):\\n+ if isinstance(result[i], torch.nn.Module):\\n+ result[i] = engine\\n+ elif isinstance(result[i], torch.optim.Optimizer):\\n+ result[i] = DeepSpeedOptimizerWrapper(engine.optimizer, engine)\\n+ self.deepspeed_engine = engine # pointing for deepspeed_engine.backward()\\n+ self._models.append(engine)\\n+ self._optimizers.append(engine.optimizer)\\n+ assert (\\n+ len(self._models) == 1\\n+ ), \\\"You can't use same `Accelerator()` instance with 2 models when using DeepSpeed\\\"\\n+\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ assert hasattr(\\n+ self, \\\"deepspeed_engine\\\"\\n+ ), \\\"You need to pass the model along the optimizer when using Deepspeed.\\\"\\n+\\n+ return tuple(result)\\n+\\n def prepare_data_loader(self, data_loader):\\n return prepare_data_loader(\\n data_loader,\\n@@ -249,7 +363,9 @@ def backward(self, loss):\\n \\\"\\\"\\\"\\n Use :obj:`accelerator.backward(loss)` in lieu of :obj:`loss.backward()`.\\n \\\"\\\"\\\"\\n- if self.scaler is not None:\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ self.deepspeed_engine.backward(loss)\\n+ elif self.scaler is not None:\\n self.scaler.scale(loss).backward()\\n else:\\n loss.backward()\\n@@ -357,6 +473,8 @@ def free_memory(self):\\n method between two trainings with different models/optimizers.\\n \\\"\\\"\\\"\\n self._optimizers = []\\n+ self._models = []\\n+ self.deepspeed_engine = None\\n gc.collect()\\n torch.cuda.empty_cache()\\n \\n@@ -384,3 +502,21 @@ def _get_devices(self, *args):\\n optimizer_device = param_group[\\\"params\\\"][0].device\\n break\\n return (model_device, optimizer_device)\\n+\\n+ def get_state_dict(self, model):\\n+ is_zero_3 = False\\n+ if is_deepspeed_available():\\n+ if isinstance(model, DeepSpeedEngineWrapper) and self.distributed_type == DistributedType.DEEPSPEED:\\n+ is_zero_3 = self.state.deepspeed_plugin.zero_stage == 3\\n+\\n+ if is_zero_3:\\n+ state_dict = model._zero3_consolidated_fp16_state_dict()\\n+ else:\\n+ model = self.unwrap_model(model)\\n+ state_dict = model.state_dict()\\n+\\n+ for k in state_dict:\\n+ if state_dict[k].dtype == torch.float16:\\n+ state_dict[k] = state_dict[k].float()\\n+\\n+ return state_dict\\ndiff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex ebc176089..eaaad20f2 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -16,6 +16,7 @@\\n \\n from accelerate.state import ComputeEnvironment, DistributedType\\n \\n+from ...utils import is_deepspeed_available\\n from .config_args import ClusterConfig\\n from .config_utils import _ask_field, _convert_distributed_mode, _convert_yes_no_to_bool\\n \\n@@ -31,7 +32,7 @@ def get_cluster_input():\\n num_machines = 1\\n main_process_ip = None\\n main_process_port = None\\n- if distributed_type == DistributedType.MULTI_GPU or distributed_type == DistributedType.MULTI_CPU:\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.MULTI_CPU]:\\n num_machines = _ask_field(\\n \\\"How many different machines will you use (use more than 1 for multi-node training)? [1]: \\\",\\n lambda x: int(x),\\n@@ -50,6 +51,42 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ deepspeed_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ if use_deepspeed:\\n+ distributed_type = DistributedType.DEEPSPEED\\n+ assert (\\n+ is_deepspeed_available()\\n+ ), \\\"DeepSpeed is not installed => run `pip3 install deepspeed` or build it from source\\\"\\n+\\n+ deepspeed_config = {}\\n+ if distributed_type == DistributedType.DEEPSPEED:\\n+ deepspeed_config[\\\"zero_stage\\\"] = _ask_field(\\n+ \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2, 3)? [2]: \\\",\\n+ lambda x: int(x),\\n+ default=2,\\n+ )\\n+\\n+ if deepspeed_config[\\\"zero_stage\\\"] >= 2:\\n+ deepspeed_config[\\\"offload_optimizer_device\\\"] = _ask_field(\\n+ \\\"Where to offload optimizer states? [NONE/cpu/nvme]: \\\",\\n+ lambda x: str(x),\\n+ default=\\\"none\\\",\\n+ )\\n+\\n+ deepspeed_config[\\\"gradient_accumulation_steps\\\"] = _ask_field(\\n+ \\\"How many gradient accumulation steps you're passing in your script? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ )\\n+\\n if distributed_type == DistributedType.TPU:\\n main_training_function = _ask_field(\\n \\\"What is the name of the function in your script that should be launched in all parallel scripts? [main]: \\\",\\n@@ -85,4 +122,5 @@ def get_cluster_input():\\n main_process_ip=main_process_ip,\\n main_process_port=main_process_port,\\n main_training_function=main_training_function,\\n+ deepspeed_config=deepspeed_config,\\n )\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 8cc993b59..55b019fa4 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -119,6 +119,9 @@ class ClusterConfig(BaseConfig):\\n main_process_port: Optional[int] = None\\n main_training_function: str = \\\"main\\\"\\n \\n+ # args for deepspeed_plugin\\n+ deepspeed_config: dict = None\\n+\\n \\n @dataclass\\n class SageMakerConfig(BaseConfig):\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex e27c6ed5c..4f392d6fa 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -44,6 +44,12 @@ def launch_command_parser(subparsers=None):\\n action=\\\"store_true\\\",\\n help=\\\"Whether or not this should launch a distributed GPU training.\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--use_deepspeed\\\",\\n+ default=False,\\n+ action=\\\"store_true\\\",\\n+ help=\\\"Whether to use deepspeed.\\\",\\n+ )\\n parser.add_argument(\\n \\\"--tpu\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not this should launch a TPU training.\\\"\\n )\\n@@ -95,6 +101,25 @@ def launch_command_parser(subparsers=None):\\n \\\"script.\\\"\\n ),\\n )\\n+ parser.add_argument(\\n+ \\\"--zero_stage\\\",\\n+ default=None,\\n+ type=int,\\n+ help=\\\"DeepSpeed's ZeRO optimization stage (useful only when `use_deepspeed` flag is passed).\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--offload_optimizer_device\\\",\\n+ default=None,\\n+ type=str,\\n+ help=\\\"Decides where (none|cpu|nvme) to offload optimizer states (useful only when `use_deepspeed` flag is passed).\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--gradient_accumulation_steps\\\",\\n+ default=None,\\n+ type=int,\\n+ help=\\\"No of gradient_accumulation_steps used in your training script (useful only when `use_deepspeed` flag is passed).\\\",\\n+ )\\n+\\n # Other arguments of the training scripts\\n parser.add_argument(\\\"training_script_args\\\", nargs=argparse.REMAINDER, help=\\\"Arguments of the training script.\\\")\\n \\n@@ -151,6 +176,43 @@ def multi_gpu_launcher(args):\\n raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)\\n \\n \\n+def deepspeed_launcher(args):\\n+\\n+ cmd = [\\\"deepspeed\\\"]\\n+ if args.num_machines > 1:\\n+ cmd.extend(\\n+ [\\n+ \\\"--num_gpus\\\",\\n+ str(args.num_processes // args.num_machines),\\n+ \\\"--num_nodes\\\",\\n+ str(args.num_machines),\\n+ \\\"--node_rank\\\",\\n+ str(args.machine_rank),\\n+ \\\"--master_addr\\\",\\n+ args.main_process_ip,\\n+ \\\"--master_port\\\",\\n+ str(args.main_process_port),\\n+ ]\\n+ )\\n+ else:\\n+ cmd.extend([\\\"--num_gpus\\\", str(args.num_processes)])\\n+\\n+ cmd.append(args.training_script)\\n+ cmd.extend(args.training_script_args)\\n+\\n+ current_env = os.environ.copy()\\n+ current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ current_env[\\\"USE_DEEPSPEED\\\"] = \\\"true\\\"\\n+ current_env[\\\"DEEPSPEED_ZERO_STAGE\\\"] = str(args.zero_stage)\\n+ current_env[\\\"GRADIENT_ACCUMULATION_STEPS\\\"] = str(args.gradient_accumulation_steps)\\n+ current_env[\\\"DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE\\\"] = str(args.offload_optimizer_device)\\n+\\n+ process = subprocess.Popen(cmd, env=current_env)\\n+ process.wait()\\n+ if process.returncode != 0:\\n+ raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)\\n+\\n+\\n def tpu_launcher(args):\\n import torch_xla.distributed.xla_multiprocessing as xmp\\n \\n@@ -276,19 +338,26 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if args.multi_gpu and args.tpu:\\n- raise ValueError(\\\"You can only pick one between `--multi_gpu` and `--tpu`.\\\")\\n+ if sum([args.multi_gpu, args.tpu, args.use_deepspeed]) > 1:\\n+ raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`.\\\")\\n \\n defaults = None\\n # Get the default from the config file.\\n if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n defaults = load_config_from_file(args.config_file)\\n- if not args.multi_gpu and not args.tpu:\\n+ if not args.multi_gpu and not args.tpu and not args.use_deepspeed:\\n+ args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n # Update args with the defaults\\n for name, attr in defaults.__dict__.items():\\n+ if isinstance(attr, dict):\\n+ for k in defaults.deepspeed_config:\\n+ if getattr(args, k) is None:\\n+ setattr(args, k, defaults.deepspeed_config[k])\\n+ continue\\n+\\n # Those args are handled separately\\n if (\\n name not in [\\\"compute_environment\\\", \\\"fp16\\\", \\\"distributed_type\\\"]\\n@@ -303,7 +372,9 @@ def launch_command(args):\\n args.num_processes = 1\\n \\n # Use the proper launcher\\n- if args.multi_gpu and not args.cpu:\\n+ if args.use_deepspeed and not args.cpu:\\n+ deepspeed_launcher(args)\\n+ elif args.multi_gpu and not args.cpu:\\n multi_gpu_launcher(args)\\n elif args.tpu and not args.cpu:\\n tpu_launcher(args)\\ndiff --git a/src/accelerate/deepspeed_utils.py b/src/accelerate/deepspeed_utils.py\\nnew file mode 100644\\nindex 000000000..11897ddc7\\n--- /dev/null\\n+++ b/src/accelerate/deepspeed_utils.py\\n@@ -0,0 +1,96 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available, is_deepspeed_available\\n+\\n+\\n+if is_deepspeed_available():\\n+ from deepspeed import DeepSpeedEngine\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+class DeepSpeedEngineWrapper(DeepSpeedEngine):\\n+ \\\"\\\"\\\"\\n+ Wrapper over deepspeed.DeepSpeedEngine object\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, *args, **kwargs):\\n+ super().__init__(*args, **kwargs)\\n+\\n+ # overwriting micro_steps for user's gradient_accumulation\\n+ self.micro_steps = -1\\n+\\n+ def step(self, lr_kwargs=None):\\n+ \\\"\\\"\\\"DeepSpeedEngine.step() without `micro_steps` update & no profiling\\\"\\\"\\\"\\n+ if self.is_gradient_accumulation_boundary(): # it shouldn't matter whether we keep this line or not\\n+ if self.progressive_layer_drop:\\n+ self.progressive_layer_drop.update_state(self.global_steps)\\n+\\n+ self._take_model_step(lr_kwargs)\\n+\\n+ def backward(self, loss):\\n+ \\\"\\\"\\\"DeepSpeedEngine.backward() with with no loss scaling; no profiling but with `micro_steps` update\\\"\\\"\\\"\\n+\\n+ if self.zero_optimization():\\n+ self.optimizer.is_gradient_accumulation_boundary = self.is_gradient_accumulation_boundary()\\n+ self.optimizer.backward(loss)\\n+ elif self.amp_enabled():\\n+ # AMP requires delaying unscale when inside gradient accumulation boundaries\\n+ # https://nvidia.github.io/apex/advanced.html#gradient-accumulation-across-iterations\\n+ delay_unscale = not self.is_gradient_accumulation_boundary()\\n+ with amp.scale_loss(loss, self.optimizer, delay_unscale=delay_unscale) as scaled_loss:\\n+ scaled_loss.backward()\\n+ elif self.fp16_enabled():\\n+ self.optimizer.backward(loss)\\n+ else:\\n+ loss.backward()\\n+\\n+ if self.enable_backward_allreduce:\\n+ self.allreduce_gradients()\\n+\\n+ # this will ensure deepspeed gradient_accumulation matches user's accumulation\\n+ self.micro_steps += 1\\n+\\n+\\n+class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):\\n+ \\\"\\\"\\\"\\n+ Internal wrapper around a deepspeed optimizer.\\n+\\n+ Args:\\n+ optimizer (:obj:`torch.optim.optimizer.Optimizer`):\\n+ The optimizer to wrap.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, optimizer, model: DeepSpeedEngineWrapper):\\n+ super().__init__(optimizer, device_placement=False, scaler=None)\\n+\\n+ self.model = model\\n+\\n+ def zero_grad(self, set_to_none=None):\\n+ pass # `model.step()` is doing that automatically. Therefore, it's implementation is not needed\\n+\\n+ def step(self):\\n+ \\\"\\\"\\\"This will handle optimizer.step() & optimizer.zero_grad() with gradient_accumulation\\\"\\\"\\\"\\n+ self.model.step()\\n+\\n+ @property\\n+ def is_overflow(self):\\n+ \\\"\\\"\\\"This must be called before lr_scheduler.step() when using deepspeed with fp16\\\"\\\"\\\"\\n+ overflow = False\\n+ if hasattr(self.optimizer, \\\"overflow\\\"):\\n+ overflow = self.optimizer.overflow\\n+ return overflow\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 1dd9f506a..0bbba3644 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -114,3 +114,8 @@ def step(self):\\n def _switch_parameters(self, parameters_map):\\n for param_group in self.optimizer.param_groups:\\n param_group[\\\"params\\\"] = [parameters_map.get(p, p) for p in param_group[\\\"params\\\"]]\\n+\\n+ @property\\n+ def is_overflow(self):\\n+ \\\"\\\"\\\"This needs to be implemented at the end\\\"\\\"\\\"\\n+ return False # TODO: implement it\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 76376038b..5b349fc38 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -12,6 +12,7 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import importlib\\n import os\\n from distutils.util import strtobool\\n from enum import Enum\\n@@ -48,10 +49,18 @@ def is_ccl_available():\\n return _ccl_available\\n \\n \\n+def is_apex_available():\\n+ return importlib.util.find_spec(\\\"apex\\\") is not None\\n+\\n+\\n def is_tpu_available():\\n return _tpu_available\\n \\n \\n+def is_deepspeed_available():\\n+ return importlib.util.find_spec(\\\"deepspeed\\\") is not None\\n+\\n+\\n def parse_flag_from_env(key, default=False):\\n value = os.environ.get(key, str(default))\\n return strtobool(value) == 1 # As its name indicates `strtobool` actually returns an int...\\n@@ -66,6 +75,7 @@ class DistributedType(str, Enum):\\n - **NO** -- Not a distributed environment, just a single process.\\n - **MULTI_CPU** -- Distributed on multiple CPU nodes.\\n - **MULTI_GPU** -- Distributed on multiple GPUs.\\n+ - **DEEPSPEED** -- Using DeepSpeed.\\n - **TPU** -- Distributed on TPUs.\\n \\\"\\\"\\\"\\n \\n@@ -73,6 +83,7 @@ class DistributedType(str, Enum):\\n NO = \\\"NO\\\"\\n MULTI_CPU = \\\"MULTI_CPU\\\"\\n MULTI_GPU = \\\"MULTI_GPU\\\"\\n+ DEEPSPEED = \\\"DEEPSPEED\\\"\\n TPU = \\\"TPU\\\"\\n \\n \\n@@ -127,10 +138,11 @@ class AcceleratorState:\\n \\n _shared_state = {}\\n \\n- def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool = False):\\n+ def __init__(self, fp16: bool = None, cpu: bool = False, deepspeed_plugin=None, _from_accelerator: bool = False):\\n self.__dict__ = self._shared_state\\n if not getattr(self, \\\"initialized\\\", False):\\n self.backend = None\\n+ self.deepspeed_plugin = None\\n if not _from_accelerator:\\n raise ValueError(\\n \\\"Please make sure to properly initialize your accelerator via `accelerator = Accelerator()` \\\"\\n@@ -143,6 +155,23 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.local_process_index = xm.get_local_ordinal()\\n self.device = xm.xla_device()\\n self.use_fp16 = False\\n+ elif os.environ.get(\\\"USE_DEEPSPEED\\\", \\\"false\\\") == \\\"true\\\" and not cpu:\\n+ assert (\\n+ is_deepspeed_available()\\n+ ), \\\"DeepSpeed is not available => install it using `pip3 install deepspeed` or build it from source\\\"\\n+ self.distributed_type = DistributedType.DEEPSPEED\\n+ if not torch.distributed.is_initialized():\\n+ torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n+ self.num_processes = torch.distributed.get_world_size()\\n+ self.process_index = torch.distributed.get_rank()\\n+ self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n+ self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n+ torch.cuda.set_device(self.device)\\n+ self.use_fp16 = False # deepspeed handles fp16 using deepspeed_config\\n+ fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ deepspeed_plugin.deepspeed_config.update({\\\"fp16\\\": {\\\"enabled\\\": fp16}})\\n+ self.deepspeed_plugin = deepspeed_plugin\\n elif int(os.environ.get(\\\"LOCAL_RANK\\\", -1)) != -1 and not cpu:\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n@@ -200,11 +229,15 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.initialized = True\\n \\n def __repr__(self):\\n- return (\\n+ use_fp16 = self.deepspeed_plugin.fp16 if self.distributed_type == DistributedType.DEEPSPEED else self.use_fp16\\n+ repr = (\\n f\\\"Distributed environment: {self.distributed_type}{(' Backend: ' + self.backend) if self.backend else ''}\\\\n\\\"\\n f\\\"Num processes: {self.num_processes}\\\\n\\\"\\n f\\\"Process index: {self.process_index}\\\\n\\\"\\n f\\\"Local process index: {self.local_process_index}\\\\n\\\"\\n f\\\"Device: {self.device}\\\\n\\\"\\n- f\\\"Use FP16 precision: {self.use_fp16}\\\\n\\\"\\n+ f\\\"Use FP16 precision: {use_fp16}\\\\n\\\"\\n )\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ repr += f\\\"ds_config: {self.deepspeed_plugin.ds_config}\\\\n\\\"\\n+ return repr\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 7302ead15..6edd1f1c0 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -15,13 +15,14 @@\\n import importlib\\n import os\\n import random\\n+from dataclasses import dataclass, field\\n from enum import Enum\\n from typing import List, Optional, Union\\n \\n import numpy as np\\n import torch\\n \\n-from .state import AcceleratorState, DistributedType, is_tpu_available\\n+from .state import AcceleratorState, DistributedType, is_deepspeed_available, is_tpu_available\\n \\n \\n if is_tpu_available():\\n@@ -36,6 +37,10 @@ def is_sagemaker_available():\\n return importlib.util.find_spec(\\\"sagemaker\\\") is not None\\n \\n \\n+if is_deepspeed_available():\\n+ from deepspeed import DeepSpeedEngine\\n+\\n+\\n class RNGType(Enum):\\n TORCH = \\\"torch\\\"\\n CUDA = \\\"cuda\\\"\\n@@ -142,7 +147,11 @@ def extract_model_from_parallel(model):\\n Returns:\\n :obj:`torch.nn.Module`: The extracted model.\\n \\\"\\\"\\\"\\n- while isinstance(model, (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)):\\n+ options = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)\\n+ if is_deepspeed_available():\\n+ options += (DeepSpeedEngine,)\\n+\\n+ while isinstance(model, options):\\n model = model.module\\n return model\\n \\n@@ -251,6 +260,7 @@ def wait_for_everyone():\\n if (\\n AcceleratorState().distributed_type == DistributedType.MULTI_GPU\\n or AcceleratorState().distributed_type == DistributedType.MULTI_CPU\\n+ or AcceleratorState().distributed_type == DistributedType.DEEPSPEED\\n ):\\n torch.distributed.barrier()\\n elif AcceleratorState().distributed_type == DistributedType.TPU:\\n@@ -293,3 +303,49 @@ def __call__(self, index, *args):\\n os.environ[\\\"RANK\\\"] = str(index)\\n \\n self.launcher(*args)\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\\n+\\n+ auto_opt_mapping: bool = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n+ )\\n+\\n+ offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n+\\n+ def __post_init__(self):\\n+\\n+ if self.gradient_accumulation_steps is None:\\n+ self.gradient_accumulation_steps = int(os.environ.get(\\\"GRADIENT_ACCUMULATION_STEPS\\\", 1))\\n+\\n+ if self.zero_stage is None:\\n+ self.zero_stage = int(os.environ.get(\\\"DEEPSPEED_ZERO_STAGE\\\", 2))\\n+\\n+ if self.offload_optimizer_device is None:\\n+ self.offload_optimizer_device = os.environ.get(\\\"DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE\\\", \\\"none\\\")\\n+\\n+ self.deepspeed_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\n+ \\\"stage\\\": self.zero_stage,\\n+ \\\"offload_optimizer\\\": {\\n+ \\\"device\\\": self.offload_optimizer_device,\\n+ },\\n+ },\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ }\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n assert isinstance(deepspeed_plugin, DeepSpeedPlugin), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -86,18 +85,10 @@ def __init__(\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n+ if deepspeed_plugin is not None:\\n+ assert isinstance(deepspeed_plugin, DeepSpeedPlugin), \\\"deepspeed_plugin must be instance of DeepSpeedPlugin\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n assert len(batch_size) > 0, \\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Rename to batch_sizes (since there are several of them)?\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n logger.info(\\\"Since you passed several dataloaders, `is_train_batch_min` will determine the `train_batch_size`\\\".)\\r\\n```\\r\\n\\r\\n+ I think we should check the list has more than one element before issuing this info!\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"Nothing needs to be done for the `eval_batch_size`?\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"I don't understand this part, could you explain?\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\",\n \"from_author\": false\n },\n {\n \"body\": \"The error message should be more along the lines of \\\"You need to pass the model along the optimizer when using Deepspeed.\\\"\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\\n+\\n+ # useful when only eval_dataloader is given into `accelerator.prepare()`\\n+ if model is not None:\\n+ model, optimizer, _, _ = deepspeed.initialize(model=model, optimizer=optimizer, config_params=self.ds_config, dist_init_required=False, model_parameters=model_parameters)\\n+ assert isinstance(model, deepspeed.DeepSpeedEngine), \\\"PipelineEngine not supported currently\\\"\\n+ for i in range(len(result)):\\n+ if isinstance(result[i], torch.nn.Module):\\n+ result[i] = DeepSpeedEngineWrapper(model)\\n+ elif isinstance(result[i], torch.optim.Optimizer):\\n+ result[i] = DeepSpeedOptimizerWrapper(optimizer, model)\\n+ self.model = model # pointing for model.backward()\\n+ \\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ assert hasattr(self, \\\"model\\\"), \\\"Accelerator instance must have model as its attribute\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"I'm not sure I understand this error message.\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\\n+\\n+ # useful when only eval_dataloader is given into `accelerator.prepare()`\\n+ if model is not None:\\n+ model, optimizer, _, _ = deepspeed.initialize(model=model, optimizer=optimizer, config_params=self.ds_config, dist_init_required=False, model_parameters=model_parameters)\\n+ assert isinstance(model, deepspeed.DeepSpeedEngine), \\\"PipelineEngine not supported currently\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Great to have this handled here :-) \",\n \"diff_hunk\": \"@@ -248,7 +308,9 @@ def backward(self, loss):\\n \\\"\\\"\\\"\\n Use :obj:`accelerator.backward(loss)` in lieu of :obj:`loss.backward()`.\\n \\\"\\\"\\\"\\n- if self.scaler is not None:\\n+ if self.distributed_type == DistributedType.DEEPSPEED:\\n+ self.model.backward(loss)\",\n \"from_author\": false\n },\n {\n \"body\": \"I think deepspeed is a subcase of multi-CPU/multi-GPU no? I would rather ask the question after.\",\n \"diff_hunk\": \"@@ -16,22 +16,22 @@\\n \\n from accelerate.state import ComputeEnvironment, DistributedType\\n \\n-from .config_args import ClusterConfig\\n+from .config_args import ClusterConfig, DeepSpeedConfig\\n from .config_utils import _ask_field, _convert_distributed_mode, _convert_yes_no_to_bool\\n \\n \\n def get_cluster_input():\\n distributed_type = _ask_field(\\n- \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] TPU): \\\",\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] DeepSpeed [4] TPU): \\\",\\n _convert_distributed_mode,\\n- error_message=\\\"Please enter 0, 1, 2 or 3.\\\",\\n+ error_message=\\\"Please enter 0, 1, 2, 3 or 4.\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"I think this one should just be left at True: there are going to be tons of parameters for deepspeed so let's keep the essential ones in the question (and use the default for the others). Users can edit the config after!\",\n \"diff_hunk\": \"@@ -50,6 +50,25 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ # TODO: add other deepspeed args\\n+ if distributed_type == DistributedType.DEEPSPEED:\\n+ zero_stage = _ask_field(\\n+ \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2)? [2]: \\\",\\n+ lambda x: int(x),\\n+ default=2,\\n+ )\\n+ gradient_accumulation_steps = _ask_field(\\n+ \\\"What should be your number of gradient accumulation steps? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ )\\n+ is_train_batch_min = _ask_field(\\n+ \\\"Should accelerate choose minimum batch size incase both train & eval dataloaders are passed? [True]: \\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"Why add this default?\",\n \"diff_hunk\": \"@@ -111,13 +111,25 @@ def __post_init__(self):\\n \\n @dataclass\\n class ClusterConfig(BaseConfig):\\n- num_processes: int\\n+ num_processes: int = None\\n machine_rank: int = 0\\n num_machines: int = 1\\n main_process_ip: Optional[str] = None\\n main_process_port: Optional[int] = None\\n main_training_function: str = \\\"main\\\"\\n \\n+ def __post_init__(self):\\n+ super().__post_init__()\\n+ assert self.num_processes is not None, \\\"num_processes can't be None\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Are those all expected by deepspeed?\",\n \"diff_hunk\": \"@@ -151,6 +151,44 @@ def multi_gpu_launcher(args):\\n raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)\\n \\n \\n+def deepspeed_launcher(args):\\n+ # TODO: need to complete this\\n+\\n+ cmd = [\\\"deepspeed\\\"]\\n+ if args.num_machines > 1:\\n+ cmd.extend(\\n+ [\\n+ \\\"--num_gpus\\\",\\n+ str(args.num_processes // args.num_machines),\\n+ \\\"--num_nodes\\\",\\n+ str(args.num_machines),\\n+ \\\"--node_rank\\\",\\n+ str(args.machine_rank),\\n+ \\\"--master_addr\\\",\\n+ args.main_process_ip,\\n+ \\\"--master_port\\\",\\n+ str(args.main_process_port),\\n+ ]\\n+ )\\n+ else:\\n+ cmd.extend([\\\"--num_gpus\\\", str(args.num_processes)])\\n+\\n+ cmd.append(args.training_script)\\n+ cmd.extend(args.training_script_args)\\n+\\n+ current_env = os.environ.copy()\\n+ current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ current_env[\\\"ZERO_STAGE\\\"] = int(args.zero_stage)\\n+ current_env[\\\"GRADIENT_ACCUMULATION_STEPS\\\"] = int(args.gradient_accumulation_steps)\\n+ current_env[\\\"IS_TRAIN_BATCH_MIN\\\"] = bool(args.is_train_batch_min)\",\n \"from_author\": false\n },\n {\n \"body\": \"There is something done in Transformers for that, if you need help.\",\n \"diff_hunk\": \"@@ -276,14 +314,15 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if args.multi_gpu and args.tpu:\\n+ if args.multi_gpu and args.tpu: # TODO: fix this for deepspeed\",\n \"from_author\": false\n },\n {\n \"body\": \"Make sure to use the `make style` command, this is not super readable here :-)\",\n \"diff_hunk\": \"@@ -0,0 +1,177 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import torch\\n+import torch.nn as nn\\n+from dataclasses import dataclass, field\\n+\\n+from .state import is_apex_available\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(default=1, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"})\\n+ zero_stage: int = field(default=0, metadata={\\\"help\\\": \\\"Possible options are 0,1,2\\\"})\\n+ is_train_batch_min: str = field(default=True, metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"})\",\n \"from_author\": false\n },\n {\n \"body\": \"This is copied from `deepspeed`? Could we subclass their class then and only change the method that requires it?\",\n \"diff_hunk\": \"@@ -0,0 +1,177 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import torch\\n+import torch.nn as nn\\n+from dataclasses import dataclass, field\\n+\\n+from .state import is_apex_available\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(default=1, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"})\\n+ zero_stage: int = field(default=0, metadata={\\\"help\\\": \\\"Possible options are 0,1,2\\\"})\\n+ is_train_batch_min: str = field(default=True, metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=False, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\\n+\\n+ def __post_init__(self):\\n+ self.ds_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"fp16\\\": {\\\"enabled\\\": False if self.fp16 is None else self.fp16},\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\\"stage\\\": self.zero_stage},\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ }\\n+\\n+\\n+class DeepSpeedEngineWrapper(nn.Module):\",\n \"from_author\": false\n },\n {\n \"body\": \"Should this subclass the `AcceleratedOptimizer` for most properties and only overrides the necessary ones?\",\n \"diff_hunk\": \"@@ -0,0 +1,177 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import torch\\n+import torch.nn as nn\\n+from dataclasses import dataclass, field\\n+\\n+from .state import is_apex_available\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(default=1, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"})\\n+ zero_stage: int = field(default=0, metadata={\\\"help\\\": \\\"Possible options are 0,1,2\\\"})\\n+ is_train_batch_min: str = field(default=True, metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=False, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\\n+\\n+ def __post_init__(self):\\n+ self.ds_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"fp16\\\": {\\\"enabled\\\": False if self.fp16 is None else self.fp16},\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\\"stage\\\": self.zero_stage},\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ }\\n+\\n+\\n+class DeepSpeedEngineWrapper(nn.Module):\\n+ \\\"\\\"\\\"\\n+ Internal wrapper around DeepSpeedEngine instance\\n+\\n+ Args:\\n+ model (:obj: `DeepSpeedEngine`):\\n+ DeepSpeedEngine instance created using deepspeed.initalize()\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, model):\\n+ super().__init__()\\n+ self.model = model\\n+ self.optimizer = model.optimizer\\n+\\n+ self.progressive_layer_drop = model.progressive_layer_drop\\n+ self.global_steps = model.global_steps\\n+\\n+ # overwriting micro_steps for user's gradient_accumulation\\n+ self.model.micro_steps = -1\\n+\\n+ def forward(self, *args, **kwargs):\\n+ return self.model(*args, **kwargs)\\n+\\n+ def train(self, *args, **kwargs):\\n+ return self.model.train(*args, **kwargs)\\n+\\n+ def eval(self, *args, **kwargs):\\n+ return self.model.eval(*args, **kwargs)\\n+\\n+ def is_gradient_accumulation_boundary(self):\\n+ return self.model.is_gradient_accumulation_boundary()\\n+\\n+ def zero_optimization(self):\\n+ return self.model.zero_optimization()\\n+\\n+ def amp_enabled(self):\\n+ return self.model.amp_enabled()\\n+\\n+ def fp16_enabled(self):\\n+ return self.model.fp16_enabled()\\n+\\n+ def _take_model_step(self, *args, **kwargs):\\n+ return self.model._take_model_step(*args, **kwargs)\\n+\\n+ def step(self, lr_kwargs=None):\\n+ \\\"\\\"\\\" DeepSpeedEngine.step() without `micro_steps` update & no profiling \\\"\\\"\\\"\\n+ if self.is_gradient_accumulation_boundary(): # it shouldn't matter whether we keep this line or not\\n+ if self.progressive_layer_drop:\\n+ self.progressive_layer_drop.update_state(self.global_steps)\\n+\\n+ self._take_model_step(lr_kwargs)\\n+\\n+ def backward(self, loss):\\n+ \\\"\\\"\\\" DeepSpeedEngine.backward() with no loss scaling & no profiling \\\"\\\"\\\"\\n+ if self.zero_optimization():\\n+ self.optimizer.is_gradient_accumulation_boundary = self.is_gradient_accumulation_boundary(\\n+ )\\n+ self.optimizer.backward(loss)\\n+ elif self.amp_enabled():\\n+ assert is_apex_available, \\\"You have enabled apex in deepspeed_plugin, but apex is unavailable in your machine\\\"\\n+ # AMP requires delaying unscale when inside gradient accumulation boundaries\\n+ # https://nvidia.github.io/apex/advanced.html#gradient-accumulation-across-iterations\\n+ delay_unscale = not self.is_gradient_accumulation_boundary()\\n+ with amp.scale_loss(loss,\\n+ self.optimizer,\\n+ delay_unscale=delay_unscale) as scaled_loss:\\n+ scaled_loss.backward()\\n+ elif self.fp16_enabled():\\n+ self.optimizer.backward(loss)\\n+ else:\\n+ loss.backward()\\n+\\n+ # this will ensure deepspeed gradient_accumulation matches user's accumulation\\n+ self.model.micro_steps += 1\\n+\\n+ def save_checkpoint(self, *args, **kwargs):\\n+ return self.model.save_checkpoint(*args, **kwargs)\\n+\\n+ def load_checkpoint(self, *args, **kwargs):\\n+ return self.model.load_checkpoint(*args, **kwargs)\\n+\\n+\\n+class DeepSpeedOptimizerWrapper(torch.optim.Optimizer):\",\n \"from_author\": false\n },\n {\n \"body\": \"I can do this next week!\",\n \"diff_hunk\": \"@@ -113,3 +113,8 @@ def step(self):\\n def _switch_parameters(self, parameters_map):\\n for param_group in self.optimizer.param_groups:\\n param_group[\\\"params\\\"] = [parameters_map.get(p, p) for p in param_group[\\\"params\\\"]]\\n+\\n+ @property\\n+ def is_overflow(self):\\n+ \\\"\\\"\\\" This needs to be implemented at the end \\\"\\\"\\\"\\n+ return False # TODO: implement it\",\n \"from_author\": false\n },\n {\n \"body\": \"Apex is not supported yet. Where do you need it?\",\n \"diff_hunk\": \"@@ -34,6 +35,20 @@\\n except ImportError:\\n _tpu_available = False\\n \\n+try:\\n+ import deepspeed\\n+\\n+ _deepspeed_available = True\\n+except:\\n+ _deepspeed_available = False\\n+\\n+try:\\n+ from apex import amp\\n+\\n+ _apex_available = True\\n+except ImportError:\\n+ _apex_available = False\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"I would prefer not importing directly (see [here](https://github.com/huggingface/accelerate/blob/a96fbaaf19e650da101bfadb886ecc1d1b1cb205/src/accelerate/utils.py#L31) for an example on how to this).\",\n \"diff_hunk\": \"@@ -34,6 +35,20 @@\\n except ImportError:\\n _tpu_available = False\\n \\n+try:\\n+ import deepspeed\\n+\\n+ _deepspeed_available = True\\n+except:\\n+ _deepspeed_available = False\",\n \"from_author\": false\n },\n {\n \"body\": \"Yes, we can do that I think. Then we won't need `deepspeed.initialize()` since deepspeed.initialize() is doing just sending everything to `DeepSpeedEngine` (see [this](https://github.com/microsoft/DeepSpeed/blob/46f4573b1a8a9cda2b45f4de4e90b631cee3f80b/deepspeed/__init__.py#L119)).\",\n \"diff_hunk\": \"@@ -0,0 +1,177 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import torch\\n+import torch.nn as nn\\n+from dataclasses import dataclass, field\\n+\\n+from .state import is_apex_available\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(default=1, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"})\\n+ zero_stage: int = field(default=0, metadata={\\\"help\\\": \\\"Possible options are 0,1,2\\\"})\\n+ is_train_batch_min: str = field(default=True, metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=False, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\\n+\\n+ def __post_init__(self):\\n+ self.ds_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"fp16\\\": {\\\"enabled\\\": False if self.fp16 is None else self.fp16},\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\\"stage\\\": self.zero_stage},\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ }\\n+\\n+\\n+class DeepSpeedEngineWrapper(nn.Module):\",\n \"from_author\": true\n },\n {\n \"body\": \"yes in `deepspeed.initialize()` as `config_params`\",\n \"diff_hunk\": \"@@ -151,6 +151,44 @@ def multi_gpu_launcher(args):\\n raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)\\n \\n \\n+def deepspeed_launcher(args):\\n+ # TODO: need to complete this\\n+\\n+ cmd = [\\\"deepspeed\\\"]\\n+ if args.num_machines > 1:\\n+ cmd.extend(\\n+ [\\n+ \\\"--num_gpus\\\",\\n+ str(args.num_processes // args.num_machines),\\n+ \\\"--num_nodes\\\",\\n+ str(args.num_machines),\\n+ \\\"--node_rank\\\",\\n+ str(args.machine_rank),\\n+ \\\"--master_addr\\\",\\n+ args.main_process_ip,\\n+ \\\"--master_port\\\",\\n+ str(args.main_process_port),\\n+ ]\\n+ )\\n+ else:\\n+ cmd.extend([\\\"--num_gpus\\\", str(args.num_processes)])\\n+\\n+ cmd.append(args.training_script)\\n+ cmd.extend(args.training_script_args)\\n+\\n+ current_env = os.environ.copy()\\n+ current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n+ current_env[\\\"ZERO_STAGE\\\"] = int(args.zero_stage)\\n+ current_env[\\\"GRADIENT_ACCUMULATION_STEPS\\\"] = int(args.gradient_accumulation_steps)\\n+ current_env[\\\"IS_TRAIN_BATCH_MIN\\\"] = bool(args.is_train_batch_min)\",\n \"from_author\": true\n },\n {\n \"body\": \"`deepspeed.initialize()` passes arguments to either of 2 class - `DeepSpeedEngine` or `PipelineEngine`. & I had to make changes to DeepSpeedEngine for preventing automatic gradient_accumulation inside deepspeed (in `DeepSpeedEngineWrapper`) & hence only `DeepSpeedEngine` is supported right now. But this line can be removed if we directly inherit `DeepSpeedEngineWrapper` from `DeepSpeedEngine` directly (as pointed out by you in a later comment).\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\\n+\\n+ # useful when only eval_dataloader is given into `accelerator.prepare()`\\n+ if model is not None:\\n+ model, optimizer, _, _ = deepspeed.initialize(model=model, optimizer=optimizer, config_params=self.ds_config, dist_init_required=False, model_parameters=model_parameters)\\n+ assert isinstance(model, deepspeed.DeepSpeedEngine), \\\"PipelineEngine not supported currently\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"DeepSpeed can build optimizer automatically for us if optimizer key is included in `ds_config`, instead of giving `torch.optim.Optimizer` in `deepspeed.initialize()`. Passing optimizer dict is the recommended way by deepspeed since they have some fused implementation & it's more easy to switch their optimizers. So we need to include that somehow.\\r\\n\\r\\nSo one way is to let user pass optimizer as dict in accelerate.prepare() itself & later we can handle that; while other can be to include it in deepspeed_plugin. What way you would suggest??\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\",\n \"from_author\": true\n },\n {\n \"body\": \"its needed in DeepSpeedEngineWrapper.\",\n \"diff_hunk\": \"@@ -34,6 +35,20 @@\\n except ImportError:\\n _tpu_available = False\\n \\n+try:\\n+ import deepspeed\\n+\\n+ _deepspeed_available = True\\n+except:\\n+ _deepspeed_available = False\\n+\\n+try:\\n+ from apex import amp\\n+\\n+ _apex_available = True\\n+except ImportError:\\n+ _apex_available = False\\n+\",\n \"from_author\": true\n },\n {\n \"body\": \"I need to fix it a bit. Will work on it.\",\n \"diff_hunk\": \"@@ -111,13 +111,25 @@ def __post_init__(self):\\n \\n @dataclass\\n class ClusterConfig(BaseConfig):\\n- num_processes: int\\n+ num_processes: int = None\\n machine_rank: int = 0\\n num_machines: int = 1\\n main_process_ip: Optional[str] = None\\n main_process_port: Optional[int] = None\\n main_training_function: str = \\\"main\\\"\\n \\n+ def __post_init__(self):\\n+ super().__post_init__()\\n+ assert self.num_processes is not None, \\\"num_processes can't be None\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"no\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\",\n \"from_author\": true\n },\n {\n \"body\": \"Let's focus on this on another PR. We could have accelerate support this in general (since the goal is to have the same API for everything) but it would require more work.\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\",\n \"from_author\": false\n },\n {\n \"body\": \"Ok, then please use the same as below and not a direct import.\",\n \"diff_hunk\": \"@@ -34,6 +35,20 @@\\n except ImportError:\\n _tpu_available = False\\n \\n+try:\\n+ import deepspeed\\n+\\n+ _deepspeed_available = True\\n+except:\\n+ _deepspeed_available = False\\n+\\n+try:\\n+ from apex import amp\\n+\\n+ _apex_available = True\\n+except ImportError:\\n+ _apex_available = False\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"okay. another PR after this then :)\",\n \"diff_hunk\": \"@@ -230,6 +245,51 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ batch_size = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert len(batch_size) > 0, \\\"You must specify training_dataloader in `accelerate.prepare()` when using DeepSpeed\\\"\\n+ logger.info(\\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\")\\n+ batch_size = min(batch_size) if ds_plugin.is_train_batch_min else max(batch_size)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = batch_size * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ model_parameters = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\\n+\\n+ # TODO: how dict based optimizer should be passed (in optimizer or ds_plugin) ??\\n+ # if isinstance(optimizer, dict):\\n+ # self.ds_config.update({\\\"optimizer\\\": optimizer})\\n+ # optimizer = None\",\n \"from_author\": true\n },\n {\n \"body\": \"Can we use `batch_sizes` here?\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ bz = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\",\n \"from_author\": false\n },\n {\n \"body\": \"It think this one would read better as (including the suggested rename form before):\\r\\n```suggestion\\r\\n if len(batch_sizes) == 0:\\r\\n raise ValueError(\\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\")\\r\\n```\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ bz = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert (\\n+ len(bz) > 0\\n+ ), \\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Since we are computing it just after, can we log it? the log should be something like:\\r\\n```\\r\\nf\\\"Since you passed both train and evaluation dataloader, `is_train_batch_min` (here {ds_plugin.is_train_batch_min} will decide the `train_batch_size` ({batch_size_per_device}).\\\"\\r\\n```\\r\\nThis might need to be split in two lines as well to respect the 119 char limit.\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ bz = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert (\\n+ len(bz) > 0\\n+ ), \\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\"\\n+ if len(bz) > 1:\\n+ logger.info(\\n+ \\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\"\\n+ )\\n+ batch_size_per_device = min(bz) if ds_plugin.is_train_batch_min else max(bz)\",\n \"from_author\": false\n },\n {\n \"body\": \"There can be several models or several optimizers passed, so we should make a list of models and optimizers for that case here? If deepspeed only supports one, we should raise an error here.\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\\n+\\n+ bz = [obj.batch_size for obj in args if hasattr(obj, \\\"batch_size\\\")]\\n+ assert (\\n+ len(bz) > 0\\n+ ), \\\"You must specify a training or evaluation dataloader in `accelerate.prepare()` when using DeepSpeed.\\\"\\n+ if len(bz) > 1:\\n+ logger.info(\\n+ \\\"Since you passed both train & eval dataloader, `is_train_batch_min` will decide the `train_batch_size`\\\"\\n+ )\\n+ batch_size_per_device = min(bz) if ds_plugin.is_train_batch_min else max(bz)\\n+\\n+ self.ds_config[\\\"train_batch_size\\\"] = (\\n+ batch_size_per_device * ds_plugin.gradient_accumulation_steps * self.num_processes\\n+ )\\n+\\n+ result = [self._prepare_one(obj) if isinstance(obj, torch.utils.data.DataLoader) else obj for obj in args]\\n+\\n+ model = None\\n+ optimizer = None\\n+ for obj in result:\\n+ if isinstance(obj, torch.nn.Module):\\n+ model = obj\\n+ elif isinstance(obj, (torch.optim.Optimizer, dict)):\\n+ optimizer = obj\",\n \"from_author\": false\n },\n {\n \"body\": \"Is this the only reference we create? It seems so but I want to be certain.\",\n \"diff_hunk\": \"@@ -357,6 +447,7 @@ def free_memory(self):\\n method between two trainings with different models/optimizers.\\n \\\"\\\"\\\"\\n self._optimizers = []\\n+ self.deepspeed_engine = None\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2)? [0]: \\\",\\r\\n```\\r\\nShould include 3?\",\n \"diff_hunk\": \"@@ -50,6 +50,39 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ ds_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed (yes/no)? [NO]\\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ if use_deepspeed:\\n+ distributed_type = DistributedType.DEEPSPEED\\n+\\n+ ds_config = {}\\n+ if distributed_type == DistributedType.DEEPSPEED:\\n+ ds_config[\\\"zero_stage\\\"] = _ask_field(\\n+ \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2)? [0]: \\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"Should this be a more general check of whether `attr` is a dict?\",\n \"diff_hunk\": \"@@ -276,19 +338,26 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if args.multi_gpu and args.tpu:\\n- raise ValueError(\\\"You can only pick one between `--multi_gpu` and `--tpu`.\\\")\\n+ if sum([args.multi_gpu, args.tpu, args.use_deepspeed]) > 1:\\n+ raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`.\\\")\\n \\n defaults = None\\n # Get the default from the config file.\\n if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n defaults = load_config_from_file(args.config_file)\\n- if not args.multi_gpu and not args.tpu:\\n+ if not args.multi_gpu and not args.tpu and not args.use_deepspeed:\\n+ args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n # Update args with the defaults\\n for name, attr in defaults.__dict__.items():\\n+ if name == \\\"ds_config\\\":\",\n \"from_author\": false\n },\n {\n \"body\": \"If I am faster than you and implement it for more general usecases, please rebase. If I'm not I will do this after merging :-)\",\n \"diff_hunk\": \"@@ -114,3 +114,8 @@ def step(self):\\n def _switch_parameters(self, parameters_map):\\n for param_group in self.optimizer.param_groups:\\n param_group[\\\"params\\\"] = [parameters_map.get(p, p) for p in param_group[\\\"params\\\"]]\\n+\\n+ @property\\n+ def is_overflow(self):\\n+ \\\"\\\"\\\"This needs to be implemented at the end\\\"\\\"\\\"\\n+ return False # TODO: implement it\",\n \"from_author\": false\n },\n {\n \"body\": \"This file should be removed afterward :-) \",\n \"diff_hunk\": \"@@ -0,0 +1,461 @@\\n+# coding=utf-8\",\n \"from_author\": false\n },\n {\n \"body\": \"Can we say `self.deepspeed_config` to go with `self.state.deepspeed_plugin`?\\r\\n\\r\\nAlso would love if this function was using `deepspeed_plugin` instead of `ds_pluging`.\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\",\n \"from_author\": false\n },\n {\n \"body\": \"value of `ds_config` will always be a dict since I am defining it to be `dict` when taking deepspeed arguments from `accelerate config`.\",\n \"diff_hunk\": \"@@ -276,19 +338,26 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if args.multi_gpu and args.tpu:\\n- raise ValueError(\\\"You can only pick one between `--multi_gpu` and `--tpu`.\\\")\\n+ if sum([args.multi_gpu, args.tpu, args.use_deepspeed]) > 1:\\n+ raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`.\\\")\\n \\n defaults = None\\n # Get the default from the config file.\\n if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n defaults = load_config_from_file(args.config_file)\\n- if not args.multi_gpu and not args.tpu:\\n+ if not args.multi_gpu and not args.tpu and not args.use_deepspeed:\\n+ args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n # Update args with the defaults\\n for name, attr in defaults.__dict__.items():\\n+ if name == \\\"ds_config\\\":\",\n \"from_author\": true\n },\n {\n \"body\": \"will remove it in the very end (before merge)\",\n \"diff_hunk\": \"@@ -0,0 +1,461 @@\\n+# coding=utf-8\",\n \"from_author\": true\n },\n {\n \"body\": \"I didn't understand the question. Could you please clarify??\\r\\n\\r\\nI will rename `ds_plugin` to `deepspeed_plugin`.\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\",\n \"from_author\": true\n },\n {\n \"body\": \"I would prefer we use `deepspeed_plugin` and `deepspeed_config` instead of `ds_plugin` and `ds_config`\",\n \"diff_hunk\": \"@@ -231,6 +255,70 @@ def prepare_model(self, model):\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\n \\n+ def _prepare_deepspeed(self, *args):\\n+\\n+ ds_plugin = self.state.deepspeed_plugin\\n+ self.ds_config = ds_plugin.ds_config\",\n \"from_author\": false\n },\n {\n \"body\": \"Yes, that's why I'm suggesting we check `if isinstance(attr, dict)` instead of the name.\",\n \"diff_hunk\": \"@@ -276,19 +338,26 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n \\n def launch_command(args):\\n # Sanity checks\\n- if args.multi_gpu and args.tpu:\\n- raise ValueError(\\\"You can only pick one between `--multi_gpu` and `--tpu`.\\\")\\n+ if sum([args.multi_gpu, args.tpu, args.use_deepspeed]) > 1:\\n+ raise ValueError(\\\"You can only pick one between `--multi_gpu`, `--use_deepspeed`, `--tpu`.\\\")\\n \\n defaults = None\\n # Get the default from the config file.\\n if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n defaults = load_config_from_file(args.config_file)\\n- if not args.multi_gpu and not args.tpu:\\n+ if not args.multi_gpu and not args.tpu and not args.use_deepspeed:\\n+ args.use_deepspeed = defaults.distributed_type == DistributedType.DEEPSPEED\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n # Update args with the defaults\\n for name, attr in defaults.__dict__.items():\\n+ if name == \\\"ds_config\\\":\",\n \"from_author\": false\n },\n {\n \"body\": \"yes\",\n \"diff_hunk\": \"@@ -357,6 +447,7 @@ def free_memory(self):\\n method between two trainings with different models/optimizers.\\n \\\"\\\"\\\"\\n self._optimizers = []\\n+ self.deepspeed_engine = None\",\n \"from_author\": true\n },\n {\n \"body\": \"This sentence is a bit ambiguous: do I have to change something in my code? I'd either say \\\"You don't need to change anything. If you desire to tweak your deepspeed related args, we provide ....\\\"\",\n \"diff_hunk\": \"@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. For using deepspeed, you don't really need to change anything in your code once you integrate accelerate in your code. You can set everything using just `accelerate config`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n1. DeepSpeed support is experimental for now. In case you get into some issue, please raise an issue.\\r\\n```\\r\\nUsers should always feel free to open issues :)\",\n \"diff_hunk\": \"@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. For using deepspeed, you don't really need to change anything in your code once you integrate accelerate in your code. You can set everything using just `accelerate config`.\\n+\\n+In case you would like to change your deepspeed related args from python script, we provide you the `DeepSpeedPlugin`.\\n+\\n+```python\\n+from accelerator import Accelerator, DeepSpeedPlugin\\n+\\n+# deepspeed needs to know your gradient accumulation steps before hand, so don't forget to pass it\\n+# Remember you need to do gradient accumulation by yourself, just like you would have done without deepspeed\\n+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)\\n+accelerator = Accelerator(fp16=True, deepspeed_plugin=deepspeed_plugin)\\n+```\\n+\\n+Note:\\n+\\n+1. DeepSpeed support is experimental for now. In case you get into some issue, feel free to raise an issue.\",\n \"from_author\": false\n },\n {\n \"body\": \"The file `deepspeed_utils` has a hard requirement on `deepspeed` being available\",\n \"diff_hunk\": \"@@ -20,12 +20,22 @@\\n from packaging import version\\n \\n from .data_loader import prepare_data_loader\\n+from .deepspeed_utils import DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedPlugin\",\n \"from_author\": false\n },\n {\n \"body\": \"This should be conditionally imported if objects are to be imported from this file in others where deepspeed isn't necessarily installed\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\",\n \"from_author\": false\n },\n {\n \"body\": \"I don't understand this argument\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available\\n+\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"Is it necessary to have this here if it shouldn't be used?\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available\\n+\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\\n+\\n+ auto_opt_mapping: bool = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n+ )\\n+\\n+ offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=None, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\",\n \"from_author\": false\n },\n {\n \"body\": \"This would place the comment as a docstring, but is that really the goal? Shouldn't it rather be:\\r\\n```suggestion\\r\\n pass # `model.step()` is doing that automatically. Therefore, it's implementation is not needed\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available\\n+\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\\n+\\n+ auto_opt_mapping: bool = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n+ )\\n+\\n+ offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=None, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\\n+\\n+ def __post_init__(self):\\n+\\n+ if self.gradient_accumulation_steps is None:\\n+ self.gradient_accumulation_steps = int(os.environ.get(\\\"GRADIENT_ACCUMULATION_STEPS\\\", 1))\\n+\\n+ if self.zero_stage is None:\\n+ self.zero_stage = int(os.environ.get(\\\"DEEPSPEED_ZERO_STAGE\\\", 2))\\n+\\n+ if self.fp16 is None:\\n+ self.fp16 = bool(os.environ.get(\\\"USE_FP16\\\", \\\"False\\\"))\\n+\\n+ if self.offload_optimizer_device is None:\\n+ self.offload_optimizer_device = os.environ.get(\\\"DEEPSPEED_OFFLOAD_OPTIMIZER_DEVICE\\\", \\\"none\\\")\\n+\\n+ self.deepspeed_config = {\\n+ \\\"train_batch_size\\\": None,\\n+ \\\"fp16\\\": {\\\"enabled\\\": self.fp16},\\n+ \\\"gradient_accumulation_steps\\\": self.gradient_accumulation_steps,\\n+ \\\"zero_optimization\\\": {\\n+ \\\"stage\\\": self.zero_stage,\\n+ \\\"offload_optimizer\\\": {\\n+ \\\"device\\\": self.offload_optimizer_device,\\n+ },\\n+ },\\n+ \\\"steps_per_print\\\": float(\\\"inf\\\"), # this will stop deepspeed from logging @ stdout\\n+ }\\n+\\n+\\n+class DeepSpeedEngineWrapper(DeepSpeedEngine):\\n+ \\\"\\\"\\\"\\n+ Wrapper over deepspeed.DeepSpeedEngine object\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, *args, **kwargs):\\n+ super().__init__(*args, **kwargs)\\n+\\n+ # overwriting micro_steps for user's gradient_accumulation\\n+ self.micro_steps = -1\\n+\\n+ def step(self, lr_kwargs=None):\\n+ \\\"\\\"\\\"DeepSpeedEngine.step() without `micro_steps` update & no profiling\\\"\\\"\\\"\\n+ if self.is_gradient_accumulation_boundary(): # it shouldn't matter whether we keep this line or not\\n+ if self.progressive_layer_drop:\\n+ self.progressive_layer_drop.update_state(self.global_steps)\\n+\\n+ self._take_model_step(lr_kwargs)\\n+\\n+ def backward(self, loss):\\n+ \\\"\\\"\\\"DeepSpeedEngine.backward() with with no loss scaling; no profiling but with `micro_steps` update\\\"\\\"\\\"\\n+\\n+ if self.zero_optimization():\\n+ self.optimizer.is_gradient_accumulation_boundary = self.is_gradient_accumulation_boundary()\\n+ self.optimizer.backward(loss)\\n+ elif self.amp_enabled():\\n+ # AMP requires delaying unscale when inside gradient accumulation boundaries\\n+ # https://nvidia.github.io/apex/advanced.html#gradient-accumulation-across-iterations\\n+ delay_unscale = not self.is_gradient_accumulation_boundary()\\n+ with amp.scale_loss(loss, self.optimizer, delay_unscale=delay_unscale) as scaled_loss:\\n+ scaled_loss.backward()\\n+ elif self.fp16_enabled():\\n+ self.optimizer.backward(loss)\\n+ else:\\n+ loss.backward()\\n+\\n+ if self.enable_backward_allreduce:\\n+ self.allreduce_gradients()\\n+\\n+ # this will ensure deepspeed gradient_accumulation matches user's accumulation\\n+ self.micro_steps += 1\\n+\\n+\\n+class DeepSpeedOptimizerWrapper(AcceleratedOptimizer):\\n+ \\\"\\\"\\\"\\n+ Internal wrapper around a deepspeed optimizer.\\n+\\n+ Args:\\n+ optimizer (:obj:`torch.optim.optimizer.Optimizer`):\\n+ The optimizer to wrap.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, optimizer, model: DeepSpeedEngineWrapper):\\n+ super().__init__(optimizer, device_placement=False, scaler=None)\\n+\\n+ self.model = model\\n+\\n+ def zero_grad(self, set_to_none=None):\\n+ \\\"\\\"\\\"`model.step()` is doing that automatically. Therefore, it's implementation is not needed\\\"\\\"\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Do we really need a `DeepSpeedPlugin` to be initialized if deepspeed isn't available?\",\n \"diff_hunk\": \"@@ -74,10 +84,18 @@ def __init__(\\n split_batches: bool = False,\\n fp16: bool = None,\\n cpu: bool = False,\\n+ deepspeed_plugin: DeepSpeedPlugin = None,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n- self.state = AcceleratorState(fp16=fp16, cpu=cpu, _from_accelerator=True)\\n+ if deepspeed_plugin is None:\\n+ deepspeed_plugin = DeepSpeedPlugin() # init from env variables\\n+ else:\\n+ assert isinstance(\\n+ deepspeed_plugin, DeepSpeedPlugin\\n+ ), \\\"`deepspeed_plugin` must be a DeepSpeedPlugin object.\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"Do you want to use DeepSpeed (yes/no)? [no]\\\",\\r\\n```\",\n \"diff_hunk\": \"@@ -50,6 +50,39 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ deepspeed_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed (yes/no)? [NO]\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"DeepSpeed needs to know the batch size of the data even if we build dataloader by ourself. & we are extracting batch size from dataloader internally. But whenever 2 dataloaders are passed in `accelerator.prepare()` (i.e. both train & eval), we can't directly take the batch size from `train_dataloader`, since internally we don't know which is train & which is eval (because of the way accelerator.prepare() takes in args). So this argument will help users to decide what is train batch size & what is eval.\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available\\n+\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\",\n \"from_author\": true\n },\n {\n \"body\": \"I will try to find other solution.\",\n \"diff_hunk\": \"@@ -0,0 +1,150 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+from dataclasses import dataclass, field\\n+\\n+from deepspeed import DeepSpeedEngine\\n+\\n+from .optimizer import AcceleratedOptimizer\\n+from .state import is_apex_available\\n+\\n+\\n+if is_apex_available():\\n+ import amp\\n+\\n+\\n+@dataclass\\n+class DeepSpeedPlugin:\\n+\\n+ gradient_accumulation_steps: int = field(\\n+ default=None, metadata={\\\"help\\\": \\\"Number of steps to accumulate gradients before updating optimizer states\\\"}\\n+ )\\n+ zero_stage: int = field(\\n+ default=None,\\n+ metadata={\\\"help\\\": \\\"Possible options are 0,1,2,3; Default will be taken from environment variable\\\"},\\n+ )\\n+ is_train_batch_min: str = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"If both train & eval dataloaders are specified, this will decide the train_batch_size\\\"},\\n+ )\\n+\\n+ auto_opt_mapping: bool = field(\\n+ default=True,\\n+ metadata={\\\"help\\\": \\\"whether to map torch.adam to deepspeed optimizer version of adam based on config\\\"},\\n+ )\\n+\\n+ offload_optimizer_device: bool = field(default=None, metadata={\\\"help\\\": \\\"Possible options are none|cpu|nvme\\\"})\\n+\\n+ fp16: bool = field(repr=False, default=None, metadata={\\\"help\\\": \\\"You need not define this here\\\"})\",\n \"from_author\": true\n },\n {\n \"body\": \"I think you probably want a space at the end of this to be consistent with the other _ask_fields\",\n \"diff_hunk\": \"@@ -50,6 +50,39 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ deepspeed_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed (yes/no)? [NO]\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"Should actually be \\r\\n```\\r\\n \\\"Do you want to use DeepSpeed? [yes/NO]: \\\",\\r\\n```\\r\\nto be compatible with what is actually in the lib for now.\",\n \"diff_hunk\": \"@@ -50,6 +50,39 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ deepspeed_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed (yes/no)? [NO]\\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"Where to offload optimizer states? [NONE/cpu/nvme]: \\\",\\r\\n```\\r\\n\\r\\nAlso to have the same kind of syntax as the others.\",\n \"diff_hunk\": \"@@ -50,6 +50,39 @@ def get_cluster_input():\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n+\\n+ deepspeed_config = None\\n+ if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:\\n+ use_deepspeed = _ask_field(\\n+ \\\"Do you want to use DeepSpeed (yes/no)? [NO]\\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ if use_deepspeed:\\n+ distributed_type = DistributedType.DEEPSPEED\\n+\\n+ deepspeed_config = {}\\n+ if distributed_type == DistributedType.DEEPSPEED:\\n+ deepspeed_config[\\\"zero_stage\\\"] = _ask_field(\\n+ \\\"What should be your DeepSpeed's ZeRO optimization stage (0, 1, 2, 3)? [2]: \\\",\\n+ lambda x: int(x),\\n+ default=2,\\n+ )\\n+\\n+ if deepspeed_config[\\\"zero_stage\\\"] >= 2:\\n+ deepspeed_config[\\\"offload_optimizer_device\\\"] = _ask_field(\\n+ \\\"Where to offload optimizer states (none|cpu|nvme)? [none]: \\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nπ€ Accelerate supports training on single/multiple GPUs using DeepSpeed. to use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\r\\n```\",\n \"diff_hunk\": \"@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. For using deepspeed, you don't need to change anything. You can set everything using just `accelerate config`. However, if you desire to tweak your deepspeed related args from your python script, we provide you the `DeepSpeedPlugin`.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed\\r\\n```\",\n \"diff_hunk\": \"@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. For using deepspeed, you don't need to change anything. You can set everything using just `accelerate config`. However, if you desire to tweak your deepspeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\n+\\n+```python\\n+from accelerator import Accelerator, DeepSpeedPlugin\\n+\\n+# deepspeed needs to know your gradient accumulation steps before hand, so don't forget to pass it\\n+# Remember you need to do gradient accumulation by yourself, just like you would have done without deepspeed\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nNote: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.\\r\\n```\",\n \"diff_hunk\": \"@@ -160,6 +160,26 @@ Once you have MPI setup on your cluster, just run:\\n mpirun -np 2 python examples/nlp_example.py\\n ```\\n \\n+## Launching training using DeepSpeed\\n+\\n+π€ Accelerate supports training on single/multiple GPUs using DeepSpeed. For using deepspeed, you don't need to change anything. You can set everything using just `accelerate config`. However, if you desire to tweak your deepspeed related args from your python script, we provide you the `DeepSpeedPlugin`.\\n+\\n+```python\\n+from accelerator import Accelerator, DeepSpeedPlugin\\n+\\n+# deepspeed needs to know your gradient accumulation steps before hand, so don't forget to pass it\\n+# Remember you need to do gradient accumulation by yourself, just like you would have done without deepspeed\\n+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)\\n+accelerator = Accelerator(fp16=True, deepspeed_plugin=deepspeed_plugin)\\n+\\n+# How to save your π€ Transformer?\\n+accelerator.wait_for_everyone()\\n+unwrapped_model = accelerator.unwrap_model(model)\\n+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))\\n+```\\n+\\n+Note: DeepSpeed support is experimental for now. In case you get into some issue, please raise an issue.\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Note for before merging this: the PR should be rebased on master and the reference to the model added in the `Accelerator` should be cleaned up in the method introduced in the PR above.\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/82\",\n \"pr_id\": 643935829\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 9c044ce9e..4f6cf5f40 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -63,12 +63,12 @@ Here is an example:\\n + device = accelerator.device\\n \\n model = torch.nn.Transformer().to(device)\\n- optim = torch.optim.Adam(model.parameters())\\n+ optimizer = torch.optim.Adam(model.parameters())\\n \\n dataset = load_dataset('my_dataset')\\n data = torch.utils.data.DataLoader(dataset, shuffle=True)\\n \\n-+ model, optim, data = accelerator.prepare(model, optim, data)\\n++ model, optimizer, data = accelerator.prepare(model, optimizer, data)\\n \\n model.train()\\n for epoch in range(10):\\n@@ -104,12 +104,12 @@ In particular, the same code can then be run without modification on your local\\n \\n - model = torch.nn.Transformer().to(device)\\n + model = torch.nn.Transformer()\\n- optim = torch.optim.Adam(model.parameters())\\n+ optimizer = torch.optim.Adam(model.parameters())\\n \\n dataset = load_dataset('my_dataset')\\n data = torch.utils.data.DataLoader(dataset, shuffle=True)\\n \\n-+ model, optim, data = accelerator.prepare(model, optim, data)\\n++ model, optimizer, data = accelerator.prepare(model, optimizer, data)\\n \\n model.train()\\n for epoch in range(10):\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/81\",\n \"pr_id\": 643899032\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 0e115bdd4..8cc993b59 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -39,7 +39,8 @@\\n \\n \\n def load_config_from_file(config_file):\\n- config_file = config_file if config_file is not None else default_config_file\\n+ config_file_exists = config_file is not None and os.path.isfile(config_file)\\n+ config_file = config_file if config_file_exists else default_config_file\\n with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n if config_file.endswith(\\\".json\\\"):\\n if (\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/79\",\n \"pr_id\": 641198528\n },\n {\n \"diff\": \"diff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex 3a9b03e28..4c785b12f 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -106,7 +106,7 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n try:\\n print(f\\\"Launching a training on {num_processes} GPUs.\\\")\\n- start_processes(launcher, nprocs=num_processes, start_method=\\\"fork\\\")\\n+ start_processes(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n finally:\\n # Clean up the environment variables set.\\n del os.environ[\\\"WORLD_SIZE\\\"]\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/78\",\n \"pr_id\": 640586316\n },\n {\n \"diff\": \"diff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex 57f253267..3a9b03e28 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -42,10 +42,10 @@ def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use\\n The port to use to communicate between processes when launching a multi-GPU training.\\n \\\"\\\"\\\"\\n # Are we in a google colab or a Kaggle Kernel?\\n- if \\\"IPython\\\" in sys.modules:\\n- in_colab_or_kaggle = \\\"google.colab\\\" in str(sys.modules[\\\"IPython\\\"].get_ipython())\\n- elif any(key.startswith(\\\"KAGGLE\\\") for key in os.environ.keys()):\\n+ if any(key.startswith(\\\"KAGGLE\\\") for key in os.environ.keys()):\\n in_colab_or_kaggle = True\\n+ elif \\\"IPython\\\" in sys.modules:\\n+ in_colab_or_kaggle = \\\"google.colab\\\" in str(sys.modules[\\\"IPython\\\"].get_ipython())\\n else:\\n in_colab_or_kaggle = False\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/73\",\n \"pr_id\": 637599010\n },\n {\n \"diff\": \"diff --git a/examples/README.md b/examples/README.md\\nindex 434a230ea..4d941b5d3 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -110,7 +110,7 @@ The same script can be run in any of the following configurations:\\n Prior to running it you should install timm and torchvision:\\n \\n ```bash\\n-pip install timm, torchvision\\n+pip install timm torchvision\\n ```\\n \\n and you should download the data with the following commands:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/70\",\n \"pr_id\": 634579457\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 63b53eccb..1dd9f506a 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -17,6 +17,7 @@\\n from packaging import version\\n \\n from .state import AcceleratorState, DistributedType, is_tpu_available\\n+from .utils import honor_type\\n \\n \\n if is_tpu_available():\\n@@ -25,7 +26,7 @@\\n \\n def move_to_device(state, device):\\n if isinstance(state, (list, tuple)):\\n- return type(state)(move_to_device(t, device) for t in state)\\n+ return honor_type(state, (move_to_device(t, device) for t in state))\\n elif isinstance(state, dict):\\n return type(state)({k: move_to_device(v, device) for k, v in state.items()})\\n elif isinstance(state, torch.Tensor):\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 9e38cbad9..7302ead15 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -99,6 +99,17 @@ def synchronize_rng_states(rng_types: List[Union[str, RNGType]], generator: Opti\\n synchronize_rng_state(RNGType(rng_type), generator=generator)\\n \\n \\n+def honor_type(obj, generator):\\n+ \\\"\\\"\\\"\\n+ Cast a generator to the same type as obj (list, tuple or namedtuple)\\n+ \\\"\\\"\\\"\\n+ # There is no direct check whether an object if of type namedtuple sadly, this is a workaround.\\n+ if isinstance(obj, tuple) and hasattr(obj, \\\"_fields\\\"):\\n+ # Can instantiate a namedtuple from a generator directly, contrary to a tuple/list.\\n+ return type(obj)(*list(generator))\\n+ return type(obj)(generator)\\n+\\n+\\n def send_to_device(tensor, device):\\n \\\"\\\"\\\"\\n Recursively sends the elements in a nested list/tuple/dictionary of tensors to a given device.\\n@@ -113,7 +124,7 @@ def send_to_device(tensor, device):\\n The same data structure as :obj:`tensor` with all tensors sent to the proper device.\\n \\\"\\\"\\\"\\n if isinstance(tensor, (list, tuple)):\\n- return type(tensor)(send_to_device(t, device) for t in tensor)\\n+ return honor_type(tensor, (send_to_device(t, device) for t in tensor))\\n elif isinstance(tensor, dict):\\n return type(tensor)({k: send_to_device(v, device) for k, v in tensor.items()})\\n elif not hasattr(tensor, \\\"to\\\"):\\n@@ -138,7 +149,7 @@ def extract_model_from_parallel(model):\\n \\n def _tpu_gather(tensor, name=\\\"tensor\\\"):\\n if isinstance(tensor, (list, tuple)):\\n- return type(tensor)(_tpu_gather(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor))\\n+ return honor_type(tensor, (_tpu_gather(t, name=f\\\"{name}_{i}\\\") for i, t in enumerate(tensor)))\\n elif isinstance(tensor, dict):\\n return type(tensor)({k: _tpu_gather(v, name=f\\\"{name}_{k}\\\") for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n@@ -148,7 +159,7 @@ def _tpu_gather(tensor, name=\\\"tensor\\\"):\\n \\n def _gpu_gather(tensor):\\n if isinstance(tensor, (list, tuple)):\\n- return type(tensor)(_gpu_gather(t) for t in tensor)\\n+ return honor_type(tensor, (_gpu_gather(t) for t in tensor))\\n elif isinstance(tensor, dict):\\n return type(tensor)({k: _gpu_gather(v) for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\n@@ -198,7 +209,7 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n Whether to pad at the beginning or the end.\\n \\\"\\\"\\\"\\n if isinstance(tensor, (list, tuple)):\\n- return type(tensor)(pad_across_processes(t, dim=dim, pad_index=pad_index) for t in tensor)\\n+ return honor_type(tensor, (pad_across_processes(t, dim=dim, pad_index=pad_index) for t in tensor))\\n elif isinstance(tensor, dict):\\n return type(tensor)({k: pad_across_processes(v, dim=dim, pad_index=pad_index) for k, v in tensor.items()})\\n elif not isinstance(tensor, torch.Tensor):\\ndiff --git a/tests/test_utils.py b/tests/test_utils.py\\nnew file mode 100644\\nindex 000000000..ca617634d\\n--- /dev/null\\n+++ b/tests/test_utils.py\\n@@ -0,0 +1,53 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+from collections import namedtuple\\n+\\n+import torch\\n+\\n+from accelerate.utils import send_to_device\\n+\\n+\\n+TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b\\\")\\n+\\n+\\n+class UtilsTester(unittest.TestCase):\\n+ def test_send_to_device(self):\\n+ tensor = torch.randn(5, 2)\\n+ device = torch.device(\\\"cuda\\\") if torch.cuda.is_available() else torch.device(\\\"cpu\\\")\\n+\\n+ result1 = send_to_device(tensor, device)\\n+ self.assertTrue(torch.equal(result1.cpu(), tensor))\\n+\\n+ result2 = send_to_device((tensor, [tensor, tensor]), device)\\n+ self.assertIsInstance(result2, tuple)\\n+ self.assertTrue(torch.equal(result2[0].cpu(), tensor))\\n+ self.assertIsInstance(result2[1], list)\\n+ self.assertTrue(torch.equal(result2[1][0].cpu(), tensor))\\n+ self.assertTrue(torch.equal(result2[1][1].cpu(), tensor))\\n+\\n+ result2 = send_to_device({\\\"a\\\": tensor, \\\"b\\\": [tensor, tensor]}, device)\\n+ self.assertIsInstance(result2, dict)\\n+ self.assertTrue(torch.equal(result2[\\\"a\\\"].cpu(), tensor))\\n+ self.assertIsInstance(result2[\\\"b\\\"], list)\\n+ self.assertTrue(torch.equal(result2[\\\"b\\\"][0].cpu(), tensor))\\n+ self.assertTrue(torch.equal(result2[\\\"b\\\"][1].cpu(), tensor))\\n+\\n+ result3 = send_to_device(TestNamedTuple(a=tensor, b=[tensor, tensor]), device)\\n+ self.assertIsInstance(result3, TestNamedTuple)\\n+ self.assertTrue(torch.equal(result3.a.cpu(), tensor))\\n+ self.assertIsInstance(result3.b, list)\\n+ self.assertTrue(torch.equal(result3.b[0].cpu(), tensor))\\n+ self.assertTrue(torch.equal(result3.b[1].cpu(), tensor))\\n\",\n \"code_comments\": [\n {\n \"body\": \"Great tests :)\",\n \"diff_hunk\": \"@@ -0,0 +1,53 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import unittest\\n+from collections import namedtuple\\n+\\n+import torch\\n+\\n+from accelerate.utils import send_to_device\\n+\\n+\\n+TestNamedTuple = namedtuple(\\\"TestNamedTuple\\\", \\\"a b\\\")\\n+\\n+\\n+class UtilsTester(unittest.TestCase):\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/67\",\n \"pr_id\": 630984689\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 6e2211143..9c044ce9e 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -151,6 +151,15 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+## Launching multi-CPU run using MPI\\n+\\n+π€ Here is another way to launch multi-CPU run using MPI. You can learn how to install Open MPI on [this page](https://www.open-mpi.org/faq/?category=building#easy-build). You can use Intel MPI or MVAPICH as well.\\n+Once you have MPI setup on your cluster, just run:\\n+\\n+```bash\\n+mpirun -np 2 python examples/nlp_example.py\\n+```\\n+\\n ## Launching your training from a notebook\\n \\n π€ Accelerate also provides a `notebook_launcher` function you can use in a notebook to launch a distributed training. This is especially useful for Colab or Kaggle notebooks with a TPU backend. Just define your training loop in a `training_function` then in your last cell, add:\\n@@ -188,6 +197,8 @@ pip install accelerate\\n ## Supported integrations\\n \\n - CPU only\\n+- multi-CPU on one node (machine)\\n+- multi-CPU on several nodes (machines)\\n - single GPU\\n - multi-GPU on one node (machine)\\n - multi-GPU on several nodes (machines)\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 0143ac949..c7706d390 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -223,6 +223,9 @@ def prepare_model(self, model):\\n output_device=self.local_process_index,\\n **kwargs,\\n )\\n+ elif self.distributed_type == DistributedType.MULTI_CPU:\\n+ kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n+ model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\n if self.native_amp:\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\n return model\\ndiff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex c8bf1bcd7..ebc176089 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -22,16 +22,16 @@\\n \\n def get_cluster_input():\\n distributed_type = _ask_field(\\n- \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-GPU, [2] TPU): \\\",\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] TPU): \\\",\\n _convert_distributed_mode,\\n- error_message=\\\"Please enter 0, 1 or 2.\\\",\\n+ error_message=\\\"Please enter 0, 1, 2 or 3.\\\",\\n )\\n \\n machine_rank = 0\\n num_machines = 1\\n main_process_ip = None\\n main_process_port = None\\n- if distributed_type == DistributedType.MULTI_GPU:\\n+ if distributed_type == DistributedType.MULTI_GPU or distributed_type == DistributedType.MULTI_CPU:\\n num_machines = _ask_field(\\n \\\"How many different machines will you use (use more than 1 for multi-node training)? [1]: \\\",\\n lambda x: int(x),\\ndiff --git a/src/accelerate/commands/config/config_utils.py b/src/accelerate/commands/config/config_utils.py\\nindex dd14965f7..2bc0e7ec9 100644\\n--- a/src/accelerate/commands/config/config_utils.py\\n+++ b/src/accelerate/commands/config/config_utils.py\\n@@ -37,7 +37,7 @@ def _convert_compute_environment(value):\\n \\n def _convert_distributed_mode(value):\\n value = int(value)\\n- return DistributedType([\\\"NO\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\\n+ return DistributedType([\\\"NO\\\", \\\"MULTI_CPU\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\\n \\n \\n def _convert_sagemaker_distributed_mode(value):\\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 042a6bdde..76376038b 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -19,6 +19,14 @@\\n import torch\\n \\n \\n+try:\\n+ import torch_ccl # noqa: F401\\n+\\n+ _ccl_available = True\\n+except ImportError:\\n+ _ccl_available = False\\n+\\n+\\n try:\\n import torch_xla.core.xla_model as xm\\n \\n@@ -27,6 +35,19 @@\\n _tpu_available = False\\n \\n \\n+def get_int_from_env(env_keys, default):\\n+ \\\"\\\"\\\"Returns the first positive env value found in the `env_keys` list or the default.\\\"\\\"\\\"\\n+ for e in env_keys:\\n+ val = int(os.environ.get(e, -1))\\n+ if val >= 0:\\n+ return val\\n+ return default\\n+\\n+\\n+def is_ccl_available():\\n+ return _ccl_available\\n+\\n+\\n def is_tpu_available():\\n return _tpu_available\\n \\n@@ -43,12 +64,14 @@ class DistributedType(str, Enum):\\n Values:\\n \\n - **NO** -- Not a distributed environment, just a single process.\\n+ - **MULTI_CPU** -- Distributed on multiple CPU nodes.\\n - **MULTI_GPU** -- Distributed on multiple GPUs.\\n - **TPU** -- Distributed on TPUs.\\n \\\"\\\"\\\"\\n \\n # Subclassing str as well as Enum allows the `DistributedType` to be JSON-serializable out of the box.\\n NO = \\\"NO\\\"\\n+ MULTI_CPU = \\\"MULTI_CPU\\\"\\n MULTI_GPU = \\\"MULTI_GPU\\\"\\n TPU = \\\"TPU\\\"\\n \\n@@ -107,6 +130,7 @@ class AcceleratorState:\\n def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool = False):\\n self.__dict__ = self._shared_state\\n if not getattr(self, \\\"initialized\\\", False):\\n+ self.backend = None\\n if not _from_accelerator:\\n raise ValueError(\\n \\\"Please make sure to properly initialize your accelerator via `accelerator = Accelerator()` \\\"\\n@@ -123,12 +147,50 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif get_int_from_env([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"], 1) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and get_int_from_env([\\\"CCL_WORKER_COUNT\\\"], 0) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ # Try to get launch configuration from environment variables set by MPI launcher - works for Intel MPI, OpenMPI and MVAPICH\\n+ rank = get_int_from_env([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = get_int_from_env([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = get_int_from_env(\\n+ [\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0\\n+ )\\n+ local_size = get_int_from_env(\\n+ [\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1\\n+ )\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ os.environ[\\\"LOCAL_RANK\\\"] = str(local_rank)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None):\\n+ os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ raise ValueError(\\n+ \\\"Looks like distributed multinode run but MASTER_ADDR env not set, \\\"\\n+ \\\"please try exporting rank 0's hostname as MASTER_ADDR\\\"\\n+ )\\n+ if not torch.distributed.is_initialized():\\n+ torch.distributed.init_process_group(backend, rank=rank, world_size=size)\\n+ self.backend = backend\\n+ self.num_processes = torch.distributed.get_world_size()\\n+ self.process_index = torch.distributed.get_rank()\\n+ self.local_process_index = local_rank\\n+ self.device = torch.device(\\\"cpu\\\")\\n+ self.use_fp16 = False\\n else:\\n self.distributed_type = DistributedType.NO\\n self.num_processes = 1\\n@@ -139,7 +201,7 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n \\n def __repr__(self):\\n return (\\n- f\\\"Distributed environment: {self.distributed_type}\\\\n\\\"\\n+ f\\\"Distributed environment: {self.distributed_type}{(' Backend: ' + self.backend) if self.backend else ''}\\\\n\\\"\\n f\\\"Num processes: {self.num_processes}\\\\n\\\"\\n f\\\"Process index: {self.process_index}\\\\n\\\"\\n f\\\"Local process index: {self.local_process_index}\\\\n\\\"\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 5dfe85e54..9e38cbad9 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -80,6 +80,8 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona\\n rng_state = rng_state.to(state.device)\\n torch.distributed.broadcast(rng_state, 0)\\n rng_state = rng_state.cpu()\\n+ elif state.distributed_type == DistributedType.MULTI_CPU:\\n+ torch.distributed.broadcast(rng_state, 0)\\n \\n # Set the broadcast rng state\\n if rng_type == RNGType.TORCH:\\n@@ -156,6 +158,9 @@ def _gpu_gather(tensor):\\n return torch.cat(output_tensors, dim=0)\\n \\n \\n+_cpu_gather = _gpu_gather\\n+\\n+\\n def gather(tensor):\\n \\\"\\\"\\\"\\n Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.\\n@@ -171,6 +176,8 @@ def gather(tensor):\\n return _tpu_gather(tensor, name=\\\"accelerate.utils.gather\\\")\\n elif AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n return _gpu_gather(tensor)\\n+ elif AcceleratorState().distributed_type == DistributedType.MULTI_CPU:\\n+ return _cpu_gather(tensor)\\n else:\\n return tensor\\n \\n@@ -230,7 +237,10 @@ def wait_for_everyone():\\n \\n Make sure all processes will reach this instruction otherwise one of your processes will hang forever.\\n \\\"\\\"\\\"\\n- if AcceleratorState().distributed_type == DistributedType.MULTI_GPU:\\n+ if (\\n+ AcceleratorState().distributed_type == DistributedType.MULTI_GPU\\n+ or AcceleratorState().distributed_type == DistributedType.MULTI_CPU\\n+ ):\\n torch.distributed.barrier()\\n elif AcceleratorState().distributed_type == DistributedType.TPU:\\n xm.rendezvous(\\\"accelerate.utils.wait_for_everyone\\\")\\n@@ -266,7 +276,7 @@ def __init__(self, launcher, distributed_type=\\\"NO\\\"):\\n self.distributed_type = DistributedType(distributed_type)\\n \\n def __call__(self, index, *args):\\n- if self.distributed_type == DistributedType.MULTI_GPU:\\n+ if self.distributed_type == DistributedType.MULTI_GPU or self.distributed_type == DistributedType.MULTI_CPU:\\n # Prepare the environment for torch.distributed\\n os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n os.environ[\\\"RANK\\\"] = str(index)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n model = torch.nn.parallel.DistributedDataParallel(model, **kwargs)\\r\\n```\\r\\nThis can probably fit in one line.\",\n \"diff_hunk\": \"@@ -223,6 +223,12 @@ def prepare_model(self, model):\\n output_device=self.local_process_index,\\n **kwargs,\\n )\\n+ elif self.distributed_type == DistributedType.MULTI_CPU:\\n+ kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n+ model = torch.nn.parallel.DistributedDataParallel(\\n+ model,\\n+ **kwargs,\\n+ )\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"Which type of machine are you using? ([0] No distributed training, [1] multinode-CPU, [2] multi-GPU, [3] TPU): \\\",\\r\\n```\\r\\nThis is not multi-CPU on one machine, it's multiple machines for CPU, so I think we should be more explicit than multi-CPU\",\n \"diff_hunk\": \"@@ -22,16 +22,16 @@\\n \\n def get_cluster_input():\\n distributed_type = _ask_field(\\n- \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-GPU, [2] TPU): \\\",\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] TPU): \\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"The name is a bit too short, and we don't use 2 like this in this repo (for instance we have `send_to_device` not `send2device`). It also returns the first match What about `get_int_from_env`?\\r\\n\\r\\n`env_list` is also not the right name for the argument as we don't pass a list of envs, but a lsit of names to query in the env, so I would use `env_keys` instead of `env_list`. `default` should not have a default value since there is not a canonical one (the function is used with -1 once, 0 twice and 1 twice below).\\r\\n\\r\\nLastly, a short docstring that explains what this function does (returning the first positive env found in the list or the default) would be awesome!\",\n \"diff_hunk\": \"@@ -27,6 +35,18 @@\\n _tpu_available = False\\n \\n \\n+def env2int(env_list, default=-1):\",\n \"from_author\": false\n },\n {\n \"body\": \"I think the value should also be `MULTI_NODE_CPU`.\",\n \"diff_hunk\": \"@@ -37,7 +37,7 @@ def _convert_compute_environment(value):\\n \\n def _convert_distributed_mode(value):\\n value = int(value)\\n- return DistributedType([\\\"NO\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\\n+ return DistributedType([\\\"NO\\\", \\\"MULTI_CPU\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if not os.environ.get(\\\"MASTER_PORT\\\", None):\\r\\n os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"I thin we should raise a ValueError here telling the user to pass a `MASTER_ADDR` instead of relying on a default.\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ print(\\\"Warning: Looks like distributed multinode run but MASTER_ADDR env not set, using '127.0.0.1' as default\\\")\\n+ print(\\\"If this run hangs, try exporting rank 0's hostname as MASTER_ADDR\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"This one is not used anywhere, so I would remove it.\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ print(\\\"Warning: Looks like distributed multinode run but MASTER_ADDR env not set, using '127.0.0.1' as default\\\")\\n+ print(\\\"If this run hangs, try exporting rank 0's hostname as MASTER_ADDR\\\")\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ if not torch.distributed.is_initialized():\\n+ torch.distributed.init_process_group(backend, rank=rank, world_size=size)\\n+ self.backend = backend\\n+ self.num_processes = torch.distributed.get_world_size()\\n+ self.process_index = torch.distributed.get_rank()\\n+ self.local_process_index = local_rank\\n+ self.local_num_processes = local_size\",\n \"from_author\": false\n },\n {\n \"body\": \"We should only display the backend if it's not None.\",\n \"diff_hunk\": \"@@ -139,7 +193,7 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n \\n def __repr__(self):\\n return (\\n- f\\\"Distributed environment: {self.distributed_type}\\\\n\\\"\\n+ f\\\"Distributed environment: {self.distributed_type} Backend: {self.backend}\\\\n\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Well, actually we can have multi-cpu on a single machine. The typical use case is one process (or rank as it is called in MPI world) per socket. So, on a dual socket machine, we can have two ranks per node. So, I suggest keeping it as multi-CPU.\",\n \"diff_hunk\": \"@@ -22,16 +22,16 @@\\n \\n def get_cluster_input():\\n distributed_type = _ask_field(\\n- \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-GPU, [2] TPU): \\\",\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] TPU): \\\",\",\n \"from_author\": true\n },\n {\n \"body\": \"Some MPI-like custom backends can initialize without MASTER_ADDR so I just put a warning. I can change to ValueError if you think that's a better choice.\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ print(\\\"Warning: Looks like distributed multinode run but MASTER_ADDR env not set, using '127.0.0.1' as default\\\")\\n+ print(\\\"If this run hangs, try exporting rank 0's hostname as MASTER_ADDR\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"We are in a test where `backend != \\\"mpi\\\"`, so I would adapt the error message (to say the backend needs a MASTER_ADDR) and raise an error. For MPI, it will still work without the MASTER_ADDR.\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ print(\\\"Warning: Looks like distributed multinode run but MASTER_ADDR env not set, using '127.0.0.1' as default\\\")\\n+ print(\\\"If this run hangs, try exporting rank 0's hostname as MASTER_ADDR\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"Made the change.\",\n \"diff_hunk\": \"@@ -123,12 +146,43 @@ def __init__(self, fp16: bool = None, cpu: bool = False, _from_accelerator: bool\\n self.distributed_type = DistributedType.MULTI_GPU\\n if not torch.distributed.is_initialized():\\n torch.distributed.init_process_group(backend=\\\"nccl\\\")\\n+ self.backend = \\\"nccl\\\"\\n self.num_processes = torch.distributed.get_world_size()\\n self.process_index = torch.distributed.get_rank()\\n self.local_process_index = int(os.environ.get(\\\"LOCAL_RANK\\\", -1))\\n self.device = torch.device(\\\"cuda\\\", self.local_process_index)\\n torch.cuda.set_device(self.device)\\n self.use_fp16 = parse_flag_from_env(\\\"USE_FP16\\\", False) if fp16 is None else fp16\\n+ elif env2int([\\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\", \\\"WORLD_SIZE\\\"]) > 1:\\n+ self.distributed_type = DistributedType.MULTI_CPU\\n+ if is_ccl_available() and env2int([\\\"CCL_WORKER_COUNT\\\"]) > 0:\\n+ backend = \\\"ccl\\\"\\n+ elif torch.distributed.is_mpi_available():\\n+ backend = \\\"mpi\\\"\\n+ else:\\n+ backend = \\\"gloo\\\"\\n+ rank = env2int([\\\"RANK\\\", \\\"PMI_RANK\\\", \\\"OMPI_COMM_WORLD_RANK\\\", \\\"MV2_COMM_WORLD_RANK\\\"], 0)\\n+ size = env2int([\\\"WORLD_SIZE\\\", \\\"PMI_SIZE\\\", \\\"OMPI_COMM_WORLD_SIZE\\\", \\\"MV2_COMM_WORLD_SIZE\\\"], 1)\\n+ local_rank = env2int([\\\"LOCAL_RANK\\\", \\\"MPI_LOCALRANKID\\\", \\\"OMPI_COMM_WORLD_LOCAL_RANK\\\", \\\"MV2_COMM_WORLD_LOCAL_RANK\\\"], 0)\\n+ local_size = env2int([\\\"MPI_LOCALNRANKS\\\", \\\"OMPI_COMM_WORLD_LOCAL_SIZE\\\", \\\"MV2_COMM_WORLD_LOCAL_SIZE\\\"], 1)\\n+ self.local_process_index = local_rank\\n+ os.environ[\\\"RANK\\\"] = str(rank)\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(size)\\n+ if not os.environ.get(\\\"MASTER_PORT\\\", None): os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\\n+ if not os.environ.get(\\\"MASTER_ADDR\\\", None):\\n+ if local_size != size and backend != \\\"mpi\\\":\\n+ print(\\\"Warning: Looks like distributed multinode run but MASTER_ADDR env not set, using '127.0.0.1' as default\\\")\\n+ print(\\\"If this run hangs, try exporting rank 0's hostname as MASTER_ADDR\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"Does this require an install of some library? Let's add how to!\",\n \"diff_hunk\": \"@@ -151,6 +151,15 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+## Launching multi-CPU run using MPI\\n+\\n+π€ Here is another way to launch multi-CPU run using MPI\\n+On your cluster just run:\\n+\\n+```bash\\n+mpirun -np 2 python examples/nlp_example.py\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n \\\"\\\"\\\"Returns the first positive env value found in the `env_keys` list or the default.\\\"\\\"\\\"\\r\\n```\",\n \"diff_hunk\": \"@@ -27,6 +35,19 @@\\n _tpu_available = False\\n \\n \\n+def get_int_from_env(env_keys, default):\\n+ \\\"\\\"\\\"Returns the first positive env found in the `env_keys` list or the default.\\\"\\\"\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"There are multiple options e.g. [Intel MPI](https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/mpi-library.html#gs.0hn0hn), [OpenMPI](https://www.open-mpi.org/) or MVAPICH. I assume, typical HPC clusters would have some version available or users can install them in userspace easily. example instructions for Open-MPI are [here](https://www.open-mpi.org/faq/?category=building#easy-build).\",\n \"diff_hunk\": \"@@ -151,6 +151,15 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+## Launching multi-CPU run using MPI\\n+\\n+π€ Here is another way to launch multi-CPU run using MPI\\n+On your cluster just run:\\n+\\n+```bash\\n+mpirun -np 2 python examples/nlp_example.py\",\n \"from_author\": true\n },\n {\n \"body\": \"Ok, added a line on how to get OpenMPI...\",\n \"diff_hunk\": \"@@ -151,6 +151,15 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+## Launching multi-CPU run using MPI\\n+\\n+π€ Here is another way to launch multi-CPU run using MPI\\n+On your cluster just run:\\n+\\n+```bash\\n+mpirun -np 2 python examples/nlp_example.py\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\n import torch_ccl\\r\\n```\\r\\nI think this should take care of the problem\",\n \"diff_hunk\": \"@@ -19,6 +19,14 @@\\n import torch\\n \\n \\n+try:\\n+ import torch_ccl as ccl\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"I have made the suggested changes. Please take a look.\\r\\nThanks.\",\n \"from_author\": true\n },\n {\n \"body\": \"Last step, could you run `make style` on your branch? This should take care of the failing test.\\r\\nLet me know if run into any trouble and I can push it on the PR instead.\",\n \"from_author\": false\n },\n {\n \"body\": \"Sorry, my system doesn't have black. Make gave error.\\r\\n\\r\\n```\\r\\nblack tests src examples\\r\\nmake: black: Command not found\\r\\nmake: *** [style] Error 127\\r\\n```\\r\\nCan you please go ahead and push it to PR?\\r\\nThanks.\",\n \"from_author\": true\n },\n {\n \"body\": \"Just installed black and fixed formatting... It is still giving an error about torch_ccl import but I don't know how to fix it...\",\n \"from_author\": true\n },\n {\n \"body\": \"Fixed issue with flake8 and squashed to single commit... Should be good to merge now.\",\n \"from_author\": true\n },\n {\n \"body\": \"Thanks again for all your work on this!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/63\",\n \"pr_id\": 628807140\n },\n {\n \"diff\": \"diff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 7a8422a05..44909ab3c 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -364,7 +364,8 @@ def prepare_data_loader(\\n )\\n \\n new_dataset = dataloader.dataset\\n- new_batch_sampler = dataloader.batch_sampler\\n+ # Iterable dataset doesn't like batch_sampler, but data_loader creates a default one for it\\n+ new_batch_sampler = dataloader.batch_sampler if not isinstance(new_dataset, IterableDataset) else None\\n generator = getattr(dataloader, \\\"generator\\\", None)\\n # No change if no multiprocess\\n if num_processes != 1:\\n@@ -413,6 +414,11 @@ def prepare_data_loader(\\n for k in _PYTORCH_DATALOADER_KWARGS\\n if k not in ignore_kwargs\\n }\\n+\\n+ # Need to provide batch_size as batch_sampler is None for Iterable dataset\\n+ if new_batch_sampler is None:\\n+ kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\n+\\n return DataLoaderShard(\\n new_dataset,\\n device=device if put_on_device else None,\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n # Iterable dataset doesn't like batch_sampler, but data_loader creates a default one for it\\r\\n new_batch_sampler = dataloader.batch_sampler if not isinstance(new_dataset, IterableDataset) else None\\r\\n```\\r\\nLet's group the two lines together.\",\n \"diff_hunk\": \"@@ -365,6 +365,9 @@ def prepare_data_loader(\\n \\n new_dataset = dataloader.dataset\\n new_batch_sampler = dataloader.batch_sampler\\n+ if isinstance(new_dataset, IterableDataset):\\n+ # Iterable dataset doesn't like batch_sampler, data_loader creates a default one for it\\n+ new_batch_sampler = None\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n # Need to provide batch_size as batch_sampler is None for Iterable dataset\\r\\n if new_batch_sampler is None:\\r\\n kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\\r\\n```\",\n \"diff_hunk\": \"@@ -413,6 +416,10 @@ def prepare_data_loader(\\n for k in _PYTORCH_DATALOADER_KWARGS\\n if k not in ignore_kwargs\\n }\\n+\\n+ # Need to provide batch_size as batch_sampler is None for Iterable dataset\\n+ if new_batch_sampler is None: kwargs[\\\"batch_size\\\"] = dataloader.batch_size // num_processes if split_batches else dataloader.batch_size\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/62\",\n \"pr_id\": 628803524\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex f1242d3fd..44cff4d55 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -137,6 +137,7 @@ def multi_gpu_launcher(args):\\n )\\n else:\\n cmd.extend([\\\"--nproc_per_node\\\", str(args.num_processes)])\\n+ cmd.extend([\\\"--master_port\\\", str(args.main_process_port)])\\n cmd.append(args.training_script)\\n cmd.extend(args.training_script_args)\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/58\",\n \"pr_id\": 625298184\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 280473ee5..6e2211143 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -163,8 +163,6 @@ notebook_launcher(training_function)\\n \\n An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb). [](https://colab.research.google.com/github/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb)\\n \\n-Note that this launcher does not work in Jupyter Notebook on a machine with multiple GPUs (yet). This feature will be released in a later version.\\n-\\n ## Why should I use π€ Accelerate?\\n \\n You should use π€ Accelerate when you want to easily run your training scripts in a distributed environment without having to renounce full control over your training loop. This is not a high-level framework above PyTorch, just a thin wrapper so you don't have to learn a new library, In fact the whole API of π€ Accelerate is in one class, the `Accelerator` object.\\ndiff --git a/docs/source/launcher.rst b/docs/source/launcher.rst\\nindex da28ad920..1c2279946 100644\\n--- a/docs/source/launcher.rst\\n+++ b/docs/source/launcher.rst\\n@@ -15,16 +15,15 @@ Notebook Launcher\\n =======================================================================================================================\\n \\n Launch your training function inside a notebook. Currently supports launching a training with TPUs on [Google\\n-Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kaggle.com/code), or training on one GPU,\\n-but support for training on several GPUs (if the machine on which you are running your notebook has them) is planned\\n-for a future release.\\n+Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kaggle.com/code), as well as training on\\n+several GPUs (if the machine on which you are running your notebook has them).\\n \\n An example can be found in `this notebook\\n <https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb>`__.\\n \\n .. warning::\\n \\n- If you are training on Colab or a Kaggle kernel with TPUs, your :obj:`Accelerator` object should only be defined\\n- inside the training function. This is because the initialization should be done inside the launcher only.\\n+ Your :obj:`Accelerator` object should only be defined inside the training function. This is because the\\n+ initialization should be done inside the launcher only.\\n \\n .. autofunction:: accelerate.notebook_launcher\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex d9846b777..1e28fed85 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -199,9 +199,8 @@ Launching training from a notebook\\n -----------------------------------------------------------------------------------------------------------------------\\n \\n In Accelerate 0.3.0, a new :class:`~accelerate.notebook_launcher` has been introduced to help you launch your training\\n-function from a notebook. Currently supports launching a training with TPUs on Colab, or training on one GPU, but\\n-support for training on several GPUs (if the machine on which you are running your notebook has them) is planned for a\\n-future release.\\n+function from a notebook. This launcher supports launching a training with TPUs on Colab or Kaggle, as well as training\\n+on several GPUs (if the machine on which you are running your notebook has them).\\n \\n Just define a function responsible for your whole training and/or evaluation in a cell of the notebook, then execute a\\n cell with the following code:\\n@@ -214,8 +213,8 @@ cell with the following code:\\n \\n .. warning::\\n \\n- If you are training on Colab with TPUs, your :obj:`Accelerator` object should only be defined inside the training\\n- function. This is because the initialization should be done inside the launcher only.\\n+ Your :obj:`Accelerator` object should only be defined inside the training function. This is because the\\n+ initialization should be done inside the launcher only.\\n \\n \\n Training on TPU\\ndiff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nindex e9dce7677..57f253267 100644\\n--- a/src/accelerate/notebook_launcher.py\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -14,15 +14,15 @@\\n \\n import os\\n import sys\\n-import warnings\\n \\n import torch\\n+from torch.multiprocessing import start_processes\\n \\n from .state import AcceleratorState\\n from .utils import PrepareForLaunch\\n \\n \\n-def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\", **kwargs):\\n+def notebook_launcher(function, args=(), num_processes=None, use_fp16=False, use_port=\\\"29500\\\"):\\n \\\"\\\"\\\"\\n Launches a training function, using several processes if it's possible in the current environment (TPU with\\n multiple cores for instance).\\n@@ -32,17 +32,15 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n The training function to execute. If it accepts arguments, the first argument should be the index of the\\n process run.\\n args (:obj:`Tuple`):\\n- Tuple of arguments to pass to the function (it will receive :obj:`(index, *args)`).\\n+ Tuple of arguments to pass to the function (it will receive :obj:`*args`).\\n num_processes (:obj:`int`, `optional`):\\n The number of processes to use for training. Will default to 8 in Colab/Kaggle if a TPU is available, to\\n the number of GPUs available otherwise.\\n-\\n- .. warning::\\n-\\n- Multiple GPUs is not yet supported.\\n+ use_fp16 (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ If :obj:`True`, will use mixed precision training on multi-GPU.\\n+ use_port (:obj:`str`, `optional`, defaults to :obj:`\\\"29500\\\"`):\\n+ The port to use to communicate between processes when launching a multi-GPU training.\\n \\\"\\\"\\\"\\n- launcher = PrepareForLaunch(function)\\n-\\n # Are we in a google colab or a Kaggle Kernel?\\n if \\\"IPython\\\" in sys.modules:\\n in_colab_or_kaggle = \\\"google.colab\\\" in str(sys.modules[\\\"IPython\\\"].get_ipython())\\n@@ -65,15 +63,60 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n if num_processes is None:\\n num_processes = 8\\n \\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"TPU\\\")\\n+ print(f\\\"Launching a training on {num_processes} TPU cores.\\\")\\n xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n- launcher(0, *args)\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\n \\n else:\\n if num_processes is None:\\n- num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+ raise ValueError(\\n+ \\\"You have to specify the number of GPUs you would like to use, add `num_process=...` to your call.\\\"\\n+ )\\n \\n if num_processes > 1:\\n- warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n- launcher(0, *args)\\n+ # Multi-GPU launch\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n+ \\\"inside your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+\\n+ if torch.cuda.is_initialized():\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, you need to avoid running any instruction \\\"\\n+ \\\"using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA \\\"\\n+ \\\"function.\\\"\\n+ )\\n+\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\n+ os.environ[\\\"USE_FP16\\\"] = str(use_fp16)\\n+\\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"MULTI_GPU\\\")\\n+ try:\\n+ print(f\\\"Launching a training on {num_processes} GPUs.\\\")\\n+ start_processes(launcher, nprocs=num_processes, start_method=\\\"fork\\\")\\n+ finally:\\n+ # Clean up the environment variables set.\\n+ del os.environ[\\\"WORLD_SIZE\\\"]\\n+ del os.environ[\\\"MASTER_ADDR\\\"]\\n+ del os.environ[\\\"MASTER_PORT\\\"]\\n+\\n+ else:\\n+ # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 0c2282b2c..5dfe85e54 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -13,7 +13,7 @@\\n # limitations under the License.\\n \\n import importlib\\n-import inspect\\n+import os\\n import random\\n from enum import Enum\\n from typing import List, Optional, Union\\n@@ -252,15 +252,23 @@ def save(obj, f):\\n \\n class PrepareForLaunch:\\n \\\"\\\"\\\"\\n- Prepare a function that launches a script.\\n+ Prepare a function that will launched in a distributed setup.\\n+\\n+ Args:\\n+ launcher (:obj:`Callable`):\\n+ The function to launch.\\n+ distributed_type (:class:`~accelerate.state.DistributedType`):\\n+ The distributed type to prepare for.\\n \\\"\\\"\\\"\\n \\n- def __init__(self, launcher):\\n+ def __init__(self, launcher, distributed_type=\\\"NO\\\"):\\n self.launcher = launcher\\n+ self.distributed_type = DistributedType(distributed_type)\\n+\\n+ def __call__(self, index, *args):\\n+ if self.distributed_type == DistributedType.MULTI_GPU:\\n+ # Prepare the environment for torch.distributed\\n+ os.environ[\\\"LOCAL_RANK\\\"] = str(index)\\n+ os.environ[\\\"RANK\\\"] = str(index)\\n \\n- def __call__(self, index):\\n- launcher_sig = inspect.signature(self.launcher)\\n- if len(launcher_sig.parameters) == 0:\\n- self.launcher()\\n- else:\\n- self.launcher(index)\\n+ self.launcher(*args)\\n\",\n \"code_comments\": [\n {\n \"body\": \"I am not that experienced with `torch.distributed`, but is it good to have them hardcoded and not overrideable? We could add parameters to adjust them. \\r\\n\",\n \"diff_hunk\": \"@@ -65,15 +61,60 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n if num_processes is None:\\n num_processes = 8\\n \\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"TPU\\\")\\n+ print(f\\\"Launching a training on {num_processes} TPU cores.\\\")\\n xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n- launcher(0, *args)\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\n \\n else:\\n if num_processes is None:\\n- num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+ raise ValueError(\\n+ \\\"You have to specify the number of GPUs you would like to use, add `num_process=...` to your call.\\\"\\n+ )\\n \\n if num_processes > 1:\\n- warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n- launcher(0, *args)\\n+ # Multi-GPU launch\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n+ \\\"inside your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+\\n+ if torch.cuda.is_initialized():\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, you need to avoid running any instruction \\\"\\n+ \\\"using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA \\\"\\n+ \\\"function.\\\"\\n+ )\\n+\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Those are the default values in `torch.distributed.launch`. The master address should not change since this does not support multi-node training. I can add a kwarg for the master port.\",\n \"diff_hunk\": \"@@ -65,15 +61,60 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n if num_processes is None:\\n num_processes = 8\\n \\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"TPU\\\")\\n+ print(f\\\"Launching a training on {num_processes} TPU cores.\\\")\\n xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n- launcher(0, *args)\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\n \\n else:\\n if num_processes is None:\\n- num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+ raise ValueError(\\n+ \\\"You have to specify the number of GPUs you would like to use, add `num_process=...` to your call.\\\"\\n+ )\\n \\n if num_processes > 1:\\n- warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n- launcher(0, *args)\\n+ # Multi-GPU launch\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n+ \\\"inside your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+\\n+ if torch.cuda.is_initialized():\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, you need to avoid running any instruction \\\"\\n+ \\\"using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA \\\"\\n+ \\\"function.\\\"\\n+ )\\n+\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"Yeah saw the default [here](https://github.com/pytorch/pytorch/blob/master/torch/distributed/elastic_launch.py#L394). But who knows what setup customers are using, e.g. IPV6, custom cnames etc. \",\n \"diff_hunk\": \"@@ -65,15 +61,60 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n if num_processes is None:\\n num_processes = 8\\n \\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"TPU\\\")\\n+ print(f\\\"Launching a training on {num_processes} TPU cores.\\\")\\n xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n- launcher(0, *args)\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\n \\n else:\\n if num_processes is None:\\n- num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+ raise ValueError(\\n+ \\\"You have to specify the number of GPUs you would like to use, add `num_process=...` to your call.\\\"\\n+ )\\n \\n if num_processes > 1:\\n- warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n- launcher(0, *args)\\n+ # Multi-GPU launch\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n+ \\\"inside your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+\\n+ if torch.cuda.is_initialized():\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, you need to avoid running any instruction \\\"\\n+ \\\"using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA \\\"\\n+ \\\"function.\\\"\\n+ )\\n+\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ os.environ[\\\"MASTER_PORT\\\"] = \\\"29500\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n os.environ[\\\"MASTER_PORT\\\"] = str(use_port)\\r\\n```\\r\\nWould add the extra conversion, might be else error prone\",\n \"diff_hunk\": \"@@ -65,15 +63,60 @@ def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\"\\n if num_processes is None:\\n num_processes = 8\\n \\n+ launcher = PrepareForLaunch(function, distributed_type=\\\"TPU\\\")\\n+ print(f\\\"Launching a training on {num_processes} TPU cores.\\\")\\n xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n else:\\n # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n- launcher(0, *args)\\n+ if torch.cuda.is_available():\\n+ print(\\\"Launching training on one GPU.\\\")\\n+ else:\\n+ print(\\\"Launching training on CPU.\\\")\\n+ function(*args)\\n \\n else:\\n if num_processes is None:\\n- num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+ raise ValueError(\\n+ \\\"You have to specify the number of GPUs you would like to use, add `num_process=...` to your call.\\\"\\n+ )\\n \\n if num_processes > 1:\\n- warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n- launcher(0, *args)\\n+ # Multi-GPU launch\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized \\\"\\n+ \\\"inside your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+\\n+ if torch.cuda.is_initialized():\\n+ raise ValueError(\\n+ \\\"To launch a multi-GPU training from your notebook, you need to avoid running any instruction \\\"\\n+ \\\"using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA \\\"\\n+ \\\"function.\\\"\\n+ )\\n+\\n+ # torch.distributed will expect a few environment variable to be here. We set the ones common to each\\n+ # process here (the other ones will be set be the launcher).\\n+ os.environ[\\\"WORLD_SIZE\\\"] = str(num_processes)\\n+ os.environ[\\\"MASTER_ADDR\\\"] = \\\"127.0.0.1\\\"\\n+ os.environ[\\\"MASTER_PORT\\\"] = use_port\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/56\",\n \"pr_id\": 624442154\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/test.py b/src/accelerate/commands/test.py\\nindex 1940c5039..ec6d2524b 100644\\n--- a/src/accelerate/commands/test.py\\n+++ b/src/accelerate/commands/test.py\\n@@ -46,7 +46,7 @@ def test_command(args):\\n script_name = os.path.sep.join(__file__.split(os.path.sep)[:-2] + [\\\"test_utils\\\", \\\"test_script.py\\\"])\\n \\n test_args = f\\\"\\\"\\\"\\n- {script_name} --config_file={args.config_file}\\n+ --config_file={args.config_file} {script_name}\\n \\\"\\\"\\\".split()\\n cmd = [\\\"accelerate-launch\\\"] + test_args\\n result = execute_subprocess_async(cmd, env=os.environ.copy())\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/54\",\n \"pr_id\": 623905518\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 25bc92c13..280473ee5 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -151,6 +151,20 @@ For instance, here is how you would run the GLUE example on the MRPC task (from\\n accelerate launch examples/nlp_example.py\\n ```\\n \\n+## Launching your training from a notebook\\n+\\n+π€ Accelerate also provides a `notebook_launcher` function you can use in a notebook to launch a distributed training. This is especially useful for Colab or Kaggle notebooks with a TPU backend. Just define your training loop in a `training_function` then in your last cell, add:\\n+\\n+```python\\n+from accelerate import notebook_launcher\\n+\\n+notebook_launcher(training_function)\\n+```\\n+\\n+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb). [](https://colab.research.google.com/github/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb)\\n+\\n+Note that this launcher does not work in Jupyter Notebook on a machine with multiple GPUs (yet). This feature will be released in a later version.\\n+\\n ## Why should I use π€ Accelerate?\\n \\n You should use π€ Accelerate when you want to easily run your training scripts in a distributed environment without having to renounce full control over your training loop. This is not a high-level framework above PyTorch, just a thin wrapper so you don't have to learn a new library, In fact the whole API of π€ Accelerate is in one class, the `Accelerator` object.\\ndiff --git a/docs/source/launcher.rst b/docs/source/launcher.rst\\nindex 1b0520d1b..da28ad920 100644\\n--- a/docs/source/launcher.rst\\n+++ b/docs/source/launcher.rst\\n@@ -19,6 +19,9 @@ Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kagg\\n but support for training on several GPUs (if the machine on which you are running your notebook has them) is planned\\n for a future release.\\n \\n+An example can be found in `this notebook\\n+<https://github.com/huggingface/notebooks/blob/master/examples/accelerate/simple_nlp_example.ipynb>`__.\\n+\\n .. warning::\\n \\n If you are training on Colab or a Kaggle kernel with TPUs, your :obj:`Accelerator` object should only be defined\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/52\",\n \"pr_id\": 623785568\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex 56ba51f64..c8bf1bcd7 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -46,7 +46,7 @@ def get_cluster_input():\\n main_process_ip = _ask_field(\\n \\\"What is the IP address of the machine that will host the main process? \\\",\\n )\\n- main_process_ip = _ask_field(\\n+ main_process_port = _ask_field(\\n \\\"What is the port you will use to communicate with the main process? \\\",\\n lambda x: int(x),\\n )\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/50\",\n \"pr_id\": 623305806\n },\n {\n \"diff\": \"diff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex ceef4fc91..fb58d1e04 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -155,5 +155,6 @@ Supported integrations\\n :caption: API reference\\n \\n accelerator\\n+ launcher\\n kwargs\\n internal\\ndiff --git a/docs/source/launcher.rst b/docs/source/launcher.rst\\nnew file mode 100644\\nindex 000000000..1b0520d1b\\n--- /dev/null\\n+++ b/docs/source/launcher.rst\\n@@ -0,0 +1,27 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+\\n+Notebook Launcher\\n+=======================================================================================================================\\n+\\n+Launch your training function inside a notebook. Currently supports launching a training with TPUs on [Google\\n+Colab](https://colab.research.google.com/) and [Kaggle kernels](https://www.kaggle.com/code), or training on one GPU,\\n+but support for training on several GPUs (if the machine on which you are running your notebook has them) is planned\\n+for a future release.\\n+\\n+.. warning::\\n+\\n+ If you are training on Colab or a Kaggle kernel with TPUs, your :obj:`Accelerator` object should only be defined\\n+ inside the training function. This is because the initialization should be done inside the launcher only.\\n+\\n+.. autofunction:: accelerate.notebook_launcher\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 5e3d9ac17..d9846b777 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -195,6 +195,29 @@ If you stored the config file in a non-default location, you can indicate it to\\n You can also override any of the arguments determined by your config file, see TODO: insert ref here.\\n \\n \\n+Launching training from a notebook\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+In Accelerate 0.3.0, a new :class:`~accelerate.notebook_launcher` has been introduced to help you launch your training\\n+function from a notebook. Currently supports launching a training with TPUs on Colab, or training on one GPU, but\\n+support for training on several GPUs (if the machine on which you are running your notebook has them) is planned for a\\n+future release.\\n+\\n+Just define a function responsible for your whole training and/or evaluation in a cell of the notebook, then execute a\\n+cell with the following code:\\n+\\n+.. code-block::\\n+\\n+ from accelerate import notebook_launcher\\n+\\n+ notebook_launcher(training_function)\\n+\\n+.. warning::\\n+\\n+ If you are training on Colab with TPUs, your :obj:`Accelerator` object should only be defined inside the training\\n+ function. This is because the initialization should be done inside the launcher only.\\n+\\n+\\n Training on TPU\\n -----------------------------------------------------------------------------------------------------------------------\\n \\ndiff --git a/src/accelerate/__init__.py b/src/accelerate/__init__.py\\nindex d005e1235..8edc050c3 100644\\n--- a/src/accelerate/__init__.py\\n+++ b/src/accelerate/__init__.py\\n@@ -6,5 +6,6 @@\\n \\n from .accelerator import Accelerator\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs\\n+from .notebook_launcher import notebook_launcher\\n from .state import DistributedType\\n from .utils import synchronize_rng_states\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 9e3e7a566..f1242d3fd 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -16,7 +16,6 @@\\n \\n import argparse\\n import importlib\\n-import inspect\\n import os\\n import subprocess\\n import sys\\n@@ -27,15 +26,7 @@\\n from accelerate.commands.config import default_config_file, load_config_from_file\\n from accelerate.commands.config.config_args import SageMakerConfig\\n from accelerate.state import ComputeEnvironment, DistributedType\\n-from accelerate.utils import is_sagemaker_available\\n-\\n-\\n-class _AddOneArg:\\n- def __init__(self, launcher):\\n- self.launcher = launcher\\n-\\n- def __call__(self, index):\\n- self.launcher()\\n+from accelerate.utils import PrepareForLaunch, is_sagemaker_available\\n \\n \\n def launch_command_parser(subparsers=None):\\n@@ -176,12 +167,7 @@ def tpu_launcher(args):\\n # Patch sys.argv\\n sys.argv = [args.training_script] + args.training_script_args\\n \\n- # If the function does not take one argument, launch will fail\\n- launcher_sig = inspect.signature(main_function)\\n- if len(launcher_sig.parameters) == 0:\\n- xmp.spawn(_AddOneArg(main_function), args=(), nprocs=args.num_processes)\\n- else:\\n- xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n+ xmp.spawn(PrepareForLaunch(main_function), args=(), nprocs=args.num_processes)\\n \\n \\n def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\ndiff --git a/src/accelerate/notebook_launcher.py b/src/accelerate/notebook_launcher.py\\nnew file mode 100644\\nindex 000000000..e9dce7677\\n--- /dev/null\\n+++ b/src/accelerate/notebook_launcher.py\\n@@ -0,0 +1,79 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import sys\\n+import warnings\\n+\\n+import torch\\n+\\n+from .state import AcceleratorState\\n+from .utils import PrepareForLaunch\\n+\\n+\\n+def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\", **kwargs):\\n+ \\\"\\\"\\\"\\n+ Launches a training function, using several processes if it's possible in the current environment (TPU with\\n+ multiple cores for instance).\\n+\\n+ Args:\\n+ function (:obj:`Callable`):\\n+ The training function to execute. If it accepts arguments, the first argument should be the index of the\\n+ process run.\\n+ args (:obj:`Tuple`):\\n+ Tuple of arguments to pass to the function (it will receive :obj:`(index, *args)`).\\n+ num_processes (:obj:`int`, `optional`):\\n+ The number of processes to use for training. Will default to 8 in Colab/Kaggle if a TPU is available, to\\n+ the number of GPUs available otherwise.\\n+\\n+ .. warning::\\n+\\n+ Multiple GPUs is not yet supported.\\n+ \\\"\\\"\\\"\\n+ launcher = PrepareForLaunch(function)\\n+\\n+ # Are we in a google colab or a Kaggle Kernel?\\n+ if \\\"IPython\\\" in sys.modules:\\n+ in_colab_or_kaggle = \\\"google.colab\\\" in str(sys.modules[\\\"IPython\\\"].get_ipython())\\n+ elif any(key.startswith(\\\"KAGGLE\\\") for key in os.environ.keys()):\\n+ in_colab_or_kaggle = True\\n+ else:\\n+ in_colab_or_kaggle = False\\n+\\n+ if in_colab_or_kaggle:\\n+ if os.environ.get(\\\"TPU_NAME\\\", None) is not None:\\n+ # TPU launch\\n+ import torch_xla.distributed.xla_multiprocessing as xmp\\n+\\n+ if len(AcceleratorState._shared_state) > 0:\\n+ raise ValueError(\\n+ \\\"To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside \\\"\\n+ \\\"your training function. Restart your notebook and make sure no cells initializes an \\\"\\n+ \\\"`Accelerator`.\\\"\\n+ )\\n+ if num_processes is None:\\n+ num_processes = 8\\n+\\n+ xmp.spawn(launcher, args=args, nprocs=num_processes, start_method=\\\"fork\\\")\\n+ else:\\n+ # No need for a distributed launch otherwise as it's either CPU or one GPU.\\n+ launcher(0, *args)\\n+\\n+ else:\\n+ if num_processes is None:\\n+ num_processes = torch.cuda.device_count() if torch.cuda.is_available() else 1\\n+\\n+ if num_processes > 1:\\n+ warnings.warn(\\\"`notebook_launcher` does not support multiple GPUs yet, launching the training on one GPU.\\\")\\n+ launcher(0, *args)\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 0ac7d04e5..0c2282b2c 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -13,6 +13,7 @@\\n # limitations under the License.\\n \\n import importlib\\n+import inspect\\n import random\\n from enum import Enum\\n from typing import List, Optional, Union\\n@@ -247,3 +248,19 @@ def save(obj, f):\\n xm.save(obj, f)\\n elif AcceleratorState().local_process_index == 0:\\n torch.save(obj, f)\\n+\\n+\\n+class PrepareForLaunch:\\n+ \\\"\\\"\\\"\\n+ Prepare a function that launches a script.\\n+ \\\"\\\"\\\"\\n+\\n+ def __init__(self, launcher):\\n+ self.launcher = launcher\\n+\\n+ def __call__(self, index):\\n+ launcher_sig = inspect.signature(self.launcher)\\n+ if len(launcher_sig.parameters) == 0:\\n+ self.launcher()\\n+ else:\\n+ self.launcher(index)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\nLaunch your training function inside a notebook. Currently supports launching a training with TPUs on [Google Colab](https://colab.research.google.com/), or training\\r\\n```\\r\\n```suggestion\\r\\nLaunch your training function from a notebook. Currently supports launching a training with TPUs on Colab, or training\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,26 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+\\n+Notebook Launcher\\n+=======================================================================================================================\\n+\\n+Launch your training function from a notebook. Currently supports launching a training with TPUs on Colab, or training\",\n \"from_author\": false\n },\n {\n \"body\": \"We could add a check for Kaggle here too. I guess users expect the same behavior there. I checked a Kaggle TPU notebook, sadly `sys.modules[\\\"IPython\\\"].get_ipython()` is not hinting that the notebook is run on Kaggle. But we could add a check like `if any(key.startswith('KAGGLE') for key in os.environ.keys())`. Additionally here is a dump of the env vars on kaggle\\r\\n\\r\\n```python\\r\\nenviron{'LC_ALL': 'C.UTF-8',\\r\\n 'LD_LIBRARY_PATH': '/opt/conda/lib',\\r\\n 'KAGGLE_DATA_PROXY_TOKEN': 'eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.B5s-CblnZQjaC_KXAizqBneeEiZmD-pS7Asgb2h-jS6uEkmkIIHLYg.ddiwW2QpGlaxa5Q584WQOg.E8mrT0sr5vZsIb5v4zdJf6uvrzk2wuZCaM6g-xLBTkZo_Nx-lLLqcZqUrZixTOznQqeidkc5tJibiyYBeBGcRnwSuFXx0w4V0EJPfKVqp_B5TMbOROvjnLIpX3eoINPjQd7I38nmCeyrlGUnC-aTHLFqDAxaaYmcESykEixt_Hlc7Q_DfiD_uPkEzJs8buJBvcYGFq8FWbJB7n89rkDY-P9xvZnSsFjbiQYtAbfwcKGdxGKYKAoVdqRhsRHjVjj6HDVQU38Ldnuhzjg2kdt8Xhu__YxSXq0Gh-RFLZxP90M.ZPazCS7UZW9RyI3-jniqPA',\\r\\n 'LANG': 'C.UTF-8',\\r\\n 'HOSTNAME': '6497510c329c',\\r\\n 'TESSERACT_PATH': '/usr/bin/tesseract',\\r\\n 'XRT_TPU_CONFIG': 'tpu_worker;0;10.0.0.2:8470',\\r\\n 'KAGGLE_KERNEL_INTEGRATIONS': '',\\r\\n 'PROJ_LIB': '/opt/conda/share/proj',\\r\\n 'KAGGLE_KERNEL_RUN_TYPE': 'Interactive',\\r\\n 'MKL_THREADING_LAYER': 'GNU',\\r\\n 'NO_GCE_CHECK': 'True',\\r\\n 'PWD': '/kaggle/working',\\r\\n 'HOME': '/root',\\r\\n 'DL_ANACONDA_HOME': '/opt/conda',\\r\\n 'ANACONDA_PYTHON_VERSION': '3.7',\\r\\n 'KAGGLE_URL_BASE': 'https://www.kaggle.com',\\r\\n 'KAGGLE_USER_SECRETS_TOKEN': 'eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..kvSYrK_dnCLGYSW8GDnQdg.xlHt52wzWG2SlyvAN6zUq9M2S3m6maqeK_nGH6zCEL-VDZE-CYAC19Ecal8oy7zJQCFYcTDdFGi-Qq6c3tdXinuUy-kG1UQ8MnTSDJJT1AvIWAeQf2MNacS8TMWa7IYG.DLWrZFE6rlAGB7rKowpPKQ',\\r\\n 'KAGGLE_DOCKER_IMAGE': 'gcr.io/kaggle-images/python:tpu',\\r\\n 'CONTAINER_NAME': 'base-cpu',\\r\\n 'KAGGLE_DATA_PROXY_PROJECT': 'kaggle-161607',\\r\\n 'SHELL': '/bin/bash',\\r\\n 'MPLBACKEND': 'agg',\\r\\n 'SHLVL': '1',\\r\\n 'PYTHONPATH': '/kaggle/lib/kagglegym:/kaggle/lib',\\r\\n 'CONTAINER_URL': 'gcr.io/deeplearning-platform-release/base-cpu:nightly-2021-03-28',\\r\\n 'KAGGLE_CONTAINER_NAME': 'kaggle_gq54lOn7oztYNC879IY4P2ItqdI6zTyAKVlolN6KbYE-60764729-webtier',\\r\\n 'PYTHONUSERBASE': '/root/.local',\\r\\n 'PATH': '/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',\\r\\n 'KAGGLE_DATA_PROXY_URL': 'https://dp.kaggle.net',\\r\\n 'TPU_NAME': 'grpc://10.0.0.2:8470',\\r\\n '_': '/opt/conda/bin/jupyter',\\r\\n 'GIT_PYTHON_REFRESH': 'quiet',\\r\\n 'JPY_PARENT_PID': '9',\\r\\n 'TERM': 'xterm-color',\\r\\n 'CLICOLOR': '1',\\r\\n 'PAGER': 'cat',\\r\\n 'GIT_PAGER': 'cat'}\\r\\n``` \\r\\n\\r\\nAdditionally, if we add Kaggle we should rename `in_colab` to maybe `in_colab_or_kaggle`.\",\n \"diff_hunk\": \"@@ -0,0 +1,80 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import os\\n+import sys\\n+import warnings\\n+\\n+import torch\\n+\\n+from .state import AcceleratorState\\n+from .utils import PrepareForLaunch\\n+\\n+\\n+def notebook_launcher(function, args=(), num_processes=None, start_method=\\\"fork\\\", **kwargs):\\n+ \\\"\\\"\\\"\\n+ Launches a training function, using several processes if it's possible in the current environment (TPU with\\n+ multiple cores for instance).\\n+\\n+ Args:\\n+ function (:obj:`Callable`):\\n+ The training function to execute. If it accepts arguments, the first argument should be the index of the\\n+ process run.\\n+ args (:obj:`Tuple`):\\n+ Tuple of arguments to pass to the function (it will receive :obj:`(index, *args)`).\\n+ num_processes (:obj:`int`, `optional`):\\n+ The number of processes to use for training. Will default to 8 in Colab if a TPU is available, to the\\n+ number of GPUs available otherwise.\\n+ start_method (:obj:`str`, `optional`, defaults to :obj:`\\\"fork\\\"`):\\n+ The method to use to start the various processes\\n+ kwargs:\\n+ Additional keyword arguments passed along to the multiprocess :obj:`spawn` method.\\n+\\n+ .. warning::\\n+\\n+ Multiple GPUs is not yet supported.\\n+ \\\"\\\"\\\"\\n+ launcher = PrepareForLaunch(function)\\n+\\n+ # Are we in a google colab?\\n+ if \\\"IPython\\\" in sys.modules:\\n+ in_colab = \\\"google.colab\\\" in str(sys.modules[\\\"IPython\\\"].get_ipython())\\n+ else:\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Yes, notebook examples will follow! Working on it this afternoon and hoping to have most NLP tasks by the end of the week!\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/44\",\n \"pr_id\": 622263859\n },\n {\n \"diff\": \"diff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 55d00ab5d..63b53eccb 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -14,6 +14,8 @@\\n \\n import torch\\n \\n+from packaging import version\\n+\\n from .state import AcceleratorState, DistributedType, is_tpu_available\\n \\n \\n@@ -86,8 +88,18 @@ def load_state_dict(self, state_dict):\\n def state_dict(self):\\n return self.optimizer.state_dict()\\n \\n- def zero_grad(self):\\n- self.optimizer.zero_grad()\\n+ def zero_grad(self, set_to_none=None):\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.7.0\\\"):\\n+ if set_to_none is not None:\\n+ raise ValueError(\\n+ \\\"`set_to_none` for Optimizer.zero_grad` was introduced in PyTorch 1.7.0 and can't be used for \\\"\\n+ f\\\"earlier versions (found version {torch.__version__}).\\\"\\n+ )\\n+ self.optimizer.zero_grad()\\n+ else:\\n+ if set_to_none is not None:\\n+ set_to_none = False\\n+ self.optimizer.zero_grad(set_to_none=set_to_none)\\n \\n def step(self):\\n if self.state.distributed_type == DistributedType.TPU:\\n\",\n \"code_comments\": [\n {\n \"body\": \"if set_to_none is None:\",\n \"diff_hunk\": \"@@ -86,8 +88,18 @@ def load_state_dict(self, state_dict):\\n def state_dict(self):\\n return self.optimizer.state_dict()\\n \\n- def zero_grad(self):\\n- self.optimizer.zero_grad()\\n+ def zero_grad(self, set_to_none=None):\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.7.0\\\"):\\n+ if set_to_none is not None:\\n+ raise ValueError(\\n+ \\\"`set_to_none` for Optimizer.zero_grad` was introduced in PyTorch 1.7.0 and can't be used for \\\"\\n+ f\\\"earlier versions (found version {torch.__version__}).\\\"\\n+ )\\n+ self.optimizer.zero_grad()\\n+ else:\\n+ if set_to_none is not None:\",\n \"from_author\": false\n },\n {\n \"body\": \"Good catch!\",\n \"diff_hunk\": \"@@ -86,8 +88,18 @@ def load_state_dict(self, state_dict):\\n def state_dict(self):\\n return self.optimizer.state_dict()\\n \\n- def zero_grad(self):\\n- self.optimizer.zero_grad()\\n+ def zero_grad(self, set_to_none=None):\\n+ if version.parse(torch.__version__) < version.parse(\\\"1.7.0\\\"):\\n+ if set_to_none is not None:\\n+ raise ValueError(\\n+ \\\"`set_to_none` for Optimizer.zero_grad` was introduced in PyTorch 1.7.0 and can't be used for \\\"\\n+ f\\\"earlier versions (found version {torch.__version__}).\\\"\\n+ )\\n+ self.optimizer.zero_grad()\\n+ else:\\n+ if set_to_none is not None:\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/43\",\n \"pr_id\": 622247621\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 382636253..903f2b0e0 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -66,10 +66,10 @@ def launch_command_parser(subparsers=None):\\n \\\"--num_processes\\\", type=int, default=None, help=\\\"The total number of processes to be launched in parallel.\\\"\\n )\\n parser.add_argument(\\n- \\\"--num_machines\\\", type=int, default=1, help=\\\"The total number of machines used in this training.\\\"\\n+ \\\"--num_machines\\\", type=int, default=None, help=\\\"The total number of machines used in this training.\\\"\\n )\\n parser.add_argument(\\n- \\\"--machine_rank\\\", type=int, default=0, help=\\\"The rank of the machine on which this script is launched.\\\"\\n+ \\\"--machine_rank\\\", type=int, default=None, help=\\\"The rank of the machine on which this script is launched.\\\"\\n )\\n parser.add_argument(\\\"--main_process_ip\\\", type=str, default=None, help=\\\"The IP address of the machine of rank 0.\\\")\\n parser.add_argument(\\n@@ -298,6 +298,16 @@ def launch_command(args):\\n if not args.multi_gpu and not args.tpu:\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n+ if defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n+ # Update args with the defaults\\n+ for name, attr in defaults.__dict__.items():\\n+ # Those args are handled separately\\n+ if (\\n+ name not in [\\\"compute_environment\\\", \\\"fp16\\\", \\\"distributed_type\\\"]\\n+ and getattr(args, name, None) is None\\n+ ):\\n+ setattr(args, name, attr)\\n+\\n if args.num_processes is None and defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n args.num_processes = defaults.num_processes\\n if not args.fp16:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/38\",\n \"pr_id\": 621191010\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nindex a9e412f7d..56ba51f64 100644\\n--- a/src/accelerate/commands/config/cluster.py\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -58,22 +58,22 @@ def get_cluster_input():\\n else:\\n main_training_function = \\\"main\\\"\\n \\n- num_processes = _ask_field(\\n- \\\"How many processes in total will you use? [1]: \\\",\\n- lambda x: int(x),\\n- default=1,\\n- error_message=\\\"Please enter an integer.\\\",\\n- )\\n+ num_processes = _ask_field(\\n+ \\\"How many processes in total will you use? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ error_message=\\\"Please enter an integer.\\\",\\n+ )\\n \\n- if distributed_type != DistributedType.TPU:\\n- fp16 = _ask_field(\\n- \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n- _convert_yes_no_to_bool,\\n- default=False,\\n- error_message=\\\"Please enter yes or no.\\\",\\n- )\\n- else:\\n- fp16 = False\\n+ if distributed_type != DistributedType.TPU:\\n+ fp16 = _ask_field(\\n+ \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ else:\\n+ fp16 = False\\n \\n return ClusterConfig(\\n compute_environment=ComputeEnvironment.LOCAL_MACHINE,\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/35\",\n \"pr_id\": 619582633\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 1d56f9e4b..5e3d9ac17 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -199,18 +199,18 @@ Training on TPU\\n -----------------------------------------------------------------------------------------------------------------------\\n \\n If you want to launch your script on TPUs, there are a few caveats you should be aware of. Behind the scenes, the TPUs\\n-will create a graph of all the operations happening im your training step (forward pass, backward pass and optimizer\\n+will create a graph of all the operations happening in your training step (forward pass, backward pass and optimizer\\n step). This is why your first step of training will always be very long as building and compiling this graph for\\n optimizations takes some time.\\n \\n The good news is that this compilation will be cached so the second step and all the following will be much faster. The\\n bas news is that it only applies if all of your steps do exactly the same operations, which implies:\\n \\n-- having all tensors of the same length in all your lenghts\\n-- having static code (i.e., not a foor loop of length that could change from step to step)\\n+- having all tensors of the same length in all your lengths\\n+- having static code (i.e., not a for loop of length that could change from step to step)\\n \\n Having any of the things above change between two steps will trigger a new compilation which will, once again, take a\\n-lof of time. In practice, that means you must take special care to have all your tensors in your inputs of the same\\n+lot of time. In practice, that means you must take special care to have all your tensors in your inputs of the same\\n shape (so no dynamic padding for instance if you are in an NLP problem) and should not use layer with for loops that\\n have different lengths depending on the inputs (such as an LSTM) or the training will be excruciatingly slow.\\n \\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 75539559e..0143ac949 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -280,7 +280,7 @@ def gather(self, tensor):\\n \\n Args:\\n tensor (:obj:`torch.Tensor`, or a nested tuple/list/dictionary of :obj:`torch.Tensor`):\\n- The tensors to gather accross all processes.\\n+ The tensors to gather across all processes.\\n \\n Returns:\\n :obj:`torch.Tensor`, or a nested tuple/list/dictionary of :obj:`torch.Tensor`: The gathered tensor(s). Note\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 24a7ad08a..7a8422a05 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -271,7 +271,7 @@ class DataLoaderShard(DataLoader):\\n - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n - :obj:`\\\"generator\\\"`: an optional :obj:`torch.Generator`\\n generator (:obj:`torch.Generator`, `optional`):\\n- A random number generator to keep synchronized accross processes.\\n+ A random number generator to keep synchronized across processes.\\n kwargs:\\n All other keyword arguments to pass to the regular :obj:`DataLoader` initialization.\\n \\\"\\\"\\\"\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/33\",\n \"pr_id\": 618706134\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex a05debfda..0e115bdd4 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -44,7 +44,7 @@ def load_config_from_file(config_file):\\n if config_file.endswith(\\\".json\\\"):\\n if (\\n json.load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE)\\n- is ComputeEnvironment.LOCAL_MACHINE\\n+ == ComputeEnvironment.LOCAL_MACHINE\\n ):\\n config_class = ClusterConfig\\n else:\\n@@ -53,7 +53,7 @@ def load_config_from_file(config_file):\\n else:\\n if (\\n yaml.safe_load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE)\\n- is ComputeEnvironment.LOCAL_MACHINE\\n+ == ComputeEnvironment.LOCAL_MACHINE\\n ):\\n config_class = ClusterConfig\\n else:\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/31\",\n \"pr_id\": 617956141\n },\n {\n \"diff\": \"diff --git a/examples/README.md b/examples/README.md\\nindex be636e63c..434a230ea 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -28,7 +28,7 @@ pip install datasets, transformers\\n \\n The same script can be run in any of the following configurations:\\n - single CPU or single GPU\\n-- multi GPUS (using PyTorch distributed mode)\\n+- multi GPUs (using PyTorch distributed mode)\\n - (multi) TPUs\\n - fp16 (mixed-precision) or fp32 (normal precision)\\n \\n@@ -57,8 +57,8 @@ To run it in each of these various modes, use the following commands:\\n ```\\n * from any server with Accelerate launcher\\n ```bash\\n- accelerate launch --fb16 ./nlp_example.py\\n-- multi GPUS (using PyTorch distributed mode)\\n+ accelerate launch --fp16 ./nlp_example.py\\n+- multi GPUs (using PyTorch distributed mode)\\n * With Accelerate config and launcher\\n ```bash\\n accelerate config # This will create a config file on your server\\n@@ -103,7 +103,7 @@ The [cv_example.py](./cv_example.py) script is a simple example to fine-tune a R\\n \\n The same script can be run in any of the following configurations:\\n - single CPU or single GPU\\n-- multi GPUS (using PyTorch distributed mode)\\n+- multi GPUs (using PyTorch distributed mode)\\n - (multi) TPUs\\n - fp16 (mixed-precision) or fp32 (normal precision)\\n \\n@@ -145,8 +145,8 @@ To run it in each of these various modes, use the following commands:\\n ```\\n * from any server with Accelerate launcher\\n ```bash\\n- accelerate launch --fb16 ./cv_example.py --data_dir path_to_data\\n-- multi GPUS (using PyTorch distributed mode)\\n+ accelerate launch --fp16 ./cv_example.py --data_dir path_to_data\\n+- multi GPUs (using PyTorch distributed mode)\\n * With Accelerate config and launcher\\n ```bash\\n accelerate config # This will create a config file on your server\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/28\",\n \"pr_id\": 617200861\n },\n {\n \"diff\": \"diff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex efdeb8f88..ceef4fc91 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -144,6 +144,11 @@ Supported integrations\\n quicktour\\n installation\\n \\n+.. toctree::\\n+ :maxdepth: 2\\n+ :caption: Guides\\n+\\n+ sagemaker\\n \\n .. toctree::\\n :maxdepth: 2\\ndiff --git a/docs/source/sagemaker.rst b/docs/source/sagemaker.rst\\nnew file mode 100644\\nindex 000000000..b889c99b3\\n--- /dev/null\\n+++ b/docs/source/sagemaker.rst\\n@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\n+\\n+After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n+\\n+.. code-block:: \\n+\\n+ pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n+Accelerate is not in the DLC yet (will soon be added!) so to use it within Amazon SageMaker you need to create a\\n+``requirements.txt`` in the same directory where your training script is located and add it as dependency.\\n+\\n+.. code-block:: \\n+\\n+ accelerate\\n+\\n+You should also add any other dependencies you have to this ``requirements.txt``.\\n+\\n+\\n+Configure π€ Accelerate\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n+the π€ Accelerate CLI.\\n+\\n+.. code-block:: \\n+\\n+ accelerate config\\n+ # In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n+\\n+.. note::\\n+ π€ Accelerate is not saving any of your credentials.\\n+\\n+\\n+Prepare a π€ Accelerate fine-tuning script\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n+after training you need to specify either ``/opt/ml/model`` or use ``os.environ[\\\"SM_MODEL_DIR\\\"]`` as your save\\n+directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+\\n+.. code-block:: diff\\n+\\n+ - torch.save('/opt/ml/model`)\\n+ + accelerator.save('/opt/ml/model')\\n+\\n+\\n+.. warning::\\n+ SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to\\n+ specify type as bool in your script and provide an explicit True or False value for this hyperparameter. `[REF]\\n+ <https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script>`__.\\n+\\n+\\n+Launch Training\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can launch your training with π€ Accelerate CLI with\\n+\\n+.. code-block:: \\n+\\n+ accelerate launch path_to_script.py --args_to_the_script\\n+\\n+\\n+This will launch your training script using your configuration. The only thing you have to do is provide all the\\n+arguments needed by your training script as named arguments.\\n+\\n+**Examples**\\n+\\n+.. note::\\n+ If you run one of the example scripts, don't forget to add ``accelerator.save('/opt/ml/model')`` to it.\\n+\\n+.. code-block:: \\n+\\n+ accelerate launch ./examples/sagemaker_example.py \\n+\\n+\\n+Outputs:\\n+\\n+.. code-block:: \\n+\\n+ Configuring Amazon SageMaker environment\\n+ Converting Arguments to Hyperparameters\\n+ Creating Estimator\\n+ 2021-04-08 11:56:50 Starting - Starting the training job...\\n+ 2021-04-08 11:57:13 Starting - Launching requested ML instancesProfilerReport-1617883008: InProgress\\n+ .........\\n+ 2021-04-08 11:58:54 Starting - Preparing the instances for training.........\\n+ 2021-04-08 12:00:24 Downloading - Downloading input data\\n+ 2021-04-08 12:00:24 Training - Downloading the training image..................\\n+ 2021-04-08 12:03:39 Training - Training image download completed. Training in progress..\\n+ ........\\n+ epoch 0: {'accuracy': 0.7598039215686274, 'f1': 0.8178438661710037}\\n+ epoch 1: {'accuracy': 0.8357843137254902, 'f1': 0.882249560632689}\\n+ epoch 2: {'accuracy': 0.8406862745098039, 'f1': 0.8869565217391304}\\n+ ........\\n+ 2021-04-08 12:05:40 Uploading - Uploading generated training model\\n+ 2021-04-08 12:05:40 Completed - Training job completed\\n+ Training seconds: 331\\n+ Billable seconds: 331\\n+ You can find your model data at: s3://your-bucket/accelerate-sagemaker-1-2021-04-08-11-56-47-108/output/model.tar.gz\\n+\\n+\\n+\\n+Advanced Features\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Distributed Training: Data Parallelism\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+*currently in development, will be supported soon.*\\n+\\n+Distributed Training: Model Parallelism\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+*currently in development, will be supported soon.*\\n+\\n+Python packages and dependencies\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. If you\\n+want to use different/other Python packages you can do this by adding them to the ``requirements.txt``. These packages\\n+will be installed before your training script is started.\\n+\\n+Remote scripts: Use scripts located on Github\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+*undecided if feature is needed. Contact us if you would like this feature.*\\n+\\n+Use Spot Instances\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+*undecided if feature is needed. Contact us if you would like this feature.*\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex aad2b8b65..220c6ddcc 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n training_function(config, args)\\ndiff --git a/examples/requirements.txt b/examples/requirements.txt\\nnew file mode 100644\\nindex 000000000..65b6b04c3\\n--- /dev/null\\n+++ b/examples/requirements.txt\\n@@ -0,0 +1 @@\\n+accelerate # used to be installed in Amazon SageMaker environment\\n\\\\ No newline at end of file\\ndiff --git a/setup.py b/setup.py\\nindex e2ce2cfbc..b2700c015 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -56,7 +56,7 @@\\n ]\\n },\\n python_requires=\\\">=3.6.0\\\",\\n- install_requires=[\\\"torch>=1.4.0\\\"],\\n+ install_requires=[\\\"torch>=1.4.0\\\", \\\"pyaml>=20.4.0\\\"],\\n extras_require=extras,\\n classifiers=[\\n \\\"Development Status :: 5 - Production/Stable\\\",\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex fe2cb122a..a05debfda 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -42,13 +42,19 @@ def load_config_from_file(config_file):\\n config_file = config_file if config_file is not None else default_config_file\\n with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n if config_file.endswith(\\\".json\\\"):\\n- if json.load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE):\\n+ if (\\n+ json.load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE)\\n+ is ComputeEnvironment.LOCAL_MACHINE\\n+ ):\\n config_class = ClusterConfig\\n else:\\n config_class = SageMakerConfig\\n return config_class.from_json_file(json_file=config_file)\\n else:\\n- if yaml.safe_load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE):\\n+ if (\\n+ yaml.safe_load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE)\\n+ is ComputeEnvironment.LOCAL_MACHINE\\n+ ):\\n config_class = ClusterConfig\\n else:\\n config_class = SageMakerConfig\\n@@ -121,5 +127,5 @@ class SageMakerConfig(BaseConfig):\\n region: str = \\\"us-east-1\\\"\\n num_machines: int = 1\\n base_job_name: str = f\\\"accelerate-sagemaker-{num_machines}\\\"\\n- pytroch_version: str = \\\"1.6\\\"\\n+ pytorch_version: str = \\\"1.6\\\"\\n transformers_version: str = \\\"4.4\\\"\\ndiff --git a/src/accelerate/commands/config/sagemaker.py b/src/accelerate/commands/config/sagemaker.py\\nindex 25fd3e6cb..feff0aecf 100644\\n--- a/src/accelerate/commands/config/sagemaker.py\\n+++ b/src/accelerate/commands/config/sagemaker.py\\n@@ -97,7 +97,8 @@ def get_sagemaker_input():\\n os.environ[\\\"AWS_PROFILE\\\"] = aws_profile\\n else:\\n print(\\n- \\\"Accelerate will expose AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables on the machine\\\"\\n+ \\\"Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,\\\"\\n+ \\\"`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`\\\"\\n )\\n aws_access_key_id = _ask_field(\\\"AWS Access Key ID: \\\")\\n os.environ[\\\"AWS_ACCESS_KEY_ID\\\"] = aws_access_key_id\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex cd3ae65cc..382636253 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -20,10 +20,14 @@\\n import os\\n import subprocess\\n import sys\\n+from ast import literal_eval\\n from pathlib import Path\\n+from typing import Dict, List\\n \\n from accelerate.commands.config import default_config_file, load_config_from_file\\n+from accelerate.commands.config.config_args import SageMakerConfig\\n from accelerate.state import ComputeEnvironment, DistributedType\\n+from accelerate.utils import is_sagemaker_available\\n \\n \\n class _AddOneArg:\\n@@ -80,6 +84,18 @@ def launch_command_parser(subparsers=None):\\n default=None,\\n help=\\\"The name of the main function to be executed in your script (only for TPU training).\\\",\\n )\\n+ parser.add_argument(\\n+ \\\"--aws_access_key_id\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"The AWS_ACCESS_KEY_ID used to launch the Amazon SageMaker training job\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--aws_secret_access_key\\\",\\n+ type=str,\\n+ default=None,\\n+ help=\\\"The AWS_SECRET_ACCESS_KEY used to launch the Amazon SageMaker training job\\\",\\n+ )\\n parser.add_argument(\\n \\\"training_script\\\",\\n type=str,\\n@@ -168,11 +184,107 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ # raise an error if element is store_true or store_false\\n+ raise ValueError(\\n+ \\\"SageMaker doesnβt support argparse actions for `store_true` or `store_false`. Please define explicit types\\\"\\n+ )\\n+ else: # raise an error if last element is store_true or store_false\\n+ raise ValueError(\\n+ \\\"SageMaker doesnβt support argparse actions for `store_true` or `store_false`. Please define explicit types\\\"\\n+ )\\n+ # adds argument to parser based on action_store true\\n+ if action is None:\\n+ parser.add_argument(argument, type=_infer_type)\\n+ else:\\n+ parser.add_argument(argument, action=action)\\n+\\n+ return {\\n+ key: (literal_eval(value) if value == \\\"True\\\" or value == \\\"False\\\" else value)\\n+ for key, value in parser.parse_args(nargs).__dict__.items()\\n+ }\\n+\\n+\\n+def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n+ if not is_sagemaker_available():\\n+ raise ImportError(\\n+ \\\"Please install sagemaker to be able to launch training on Amazon SageMaker with `pip install accelerate[sagemaker]`\\\"\\n+ )\\n+ from sagemaker.huggingface import HuggingFace\\n+\\n+ # configure environment\\n+ print(\\\"Configuring Amazon SageMaker environment\\\")\\n+ os.environ[\\\"AWS_DEFAULT_REGION\\\"] = sagemaker_config.region\\n+\\n+ # configure credentials\\n+ if sagemaker_config.profile is not None:\\n+ os.environ[\\\"AWS_PROFILE\\\"] = sagemaker_config.profile\\n+ elif args.aws_access_key_id is not None and args.aws_secret_access_key is not None:\\n+ os.environ[\\\"AWS_ACCESS_KEY_ID\\\"] = args.aws_access_key_id\\n+ os.environ[\\\"AWS_SECRET_ACCESS_KEY\\\"] = args.aws_secret_access_key\\n+ else:\\n+ raise EnvironmentError(\\n+ \\\"You need to provide an aws_access_key_id and aws_secret_access_key when not using aws_profile\\\"\\n+ )\\n+\\n+ # extract needed arguments\\n+ source_dir = os.path.dirname(args.training_script)\\n+ if not source_dir: # checks if string is empty\\n+ source_dir = \\\".\\\"\\n+ entry_point = os.path.basename(args.training_script)\\n+ if not entry_point.endswith(\\\".py\\\"):\\n+ raise ValueError(f'Your training script should be a python script and not \\\"{entry_point}\\\"')\\n+\\n+ print(\\\"Converting Arguments to Hyperparameters\\\")\\n+ hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n+\\n+ environment = {\\\"USE_FP16\\\": args.fp16} # Environment variables to be set for use during training job\\n+\\n+ # configure distribution set up\\n+ distribution = None # TODO: not yet implemented\\n+\\n+ # configure session\\n+ print(\\\"Creating Estimator\\\")\\n+ huggingface_estimator = HuggingFace(\\n+ entry_point=entry_point,\\n+ source_dir=source_dir,\\n+ role=sagemaker_config.iam_role_name,\\n+ transformers_version=\\\"4.4\\\",\\n+ pytorch_version=\\\"1.6\\\",\\n+ py_version=\\\"py36\\\",\\n+ base_job_name=sagemaker_config.base_job_name,\\n+ instance_count=sagemaker_config.num_machines,\\n+ instance_type=sagemaker_config.ec2_instance_type,\\n+ debugger_hook_config=False,\\n+ distribution=distribution,\\n+ hyperparameters=hyperparameters,\\n+ environment=environment,\\n )\\n \\n+ huggingface_estimator.fit()\\n+ print(f\\\"You can find your model data at: {huggingface_estimator.model_data}\\\")\\n+\\n \\n def launch_command(args):\\n # Sanity checks\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 21b635996..68299c790 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -31,6 +31,10 @@ def is_boto3_available():\\n return importlib.util.find_spec(\\\"boto3\\\") is not None\\n \\n \\n+def is_sagemaker_available():\\n+ return importlib.util.find_spec(\\\"sagemaker\\\") is not None\\n+\\n+\\n class RNGType(Enum):\\n TORCH = \\\"torch\\\"\\n CUDA = \\\"cuda\\\"\\ndiff --git a/tests/test_sagemaker.py b/tests/test_sagemaker.py\\nnew file mode 100644\\nindex 000000000..f2d587a39\\n--- /dev/null\\n+++ b/tests/test_sagemaker.py\\n@@ -0,0 +1,62 @@\\n+import unittest\\n+from dataclasses import dataclass\\n+\\n+import pytest\\n+from accelerate.commands.config.config_args import SageMakerConfig\\n+from accelerate.commands.launch import _convert_nargs_to_dict\\n+from accelerate.state import ComputeEnvironment\\n+\\n+\\n+@dataclass\\n+class MockLaunchConfig(SageMakerConfig):\\n+ compute_environment = ComputeEnvironment.AMAZON_SAGEMAKER\\n+ fp16 = True\\n+ ec2_instance_type = \\\"ml.p3.2xlarge\\\"\\n+ iam_role_name = \\\"accelerate_sagemaker_execution_role\\\"\\n+ profile = \\\"hf-sm\\\"\\n+ region = \\\"us-east-1\\\"\\n+ num_machines = 1\\n+ base_job_name = \\\"accelerate-sagemaker-1\\\"\\n+ pytorch_version = \\\"1.6\\\"\\n+ transformers_version = \\\"4.4\\\"\\n+ training_script = \\\"train.py\\\"\\n+ success_training_script_args = [\\n+ \\\"--model_name_or_path\\\",\\n+ \\\"bert\\\",\\n+ \\\"--do_train\\\",\\n+ \\\"False\\\",\\n+ \\\"--epochs\\\",\\n+ \\\"3\\\",\\n+ \\\"--learning_rate\\\",\\n+ \\\"5e-5\\\",\\n+ \\\"--max_steps\\\",\\n+ \\\"50.5\\\",\\n+ ]\\n+ fail_training_script_args = [\\n+ \\\"--model_name_or_path\\\",\\n+ \\\"bert\\\",\\n+ \\\"--do_train\\\",\\n+ \\\"--do_test\\\",\\n+ \\\"False\\\",\\n+ \\\"--do_predict\\\",\\n+ \\\"--epochs\\\",\\n+ \\\"3\\\",\\n+ \\\"--learning_rate\\\",\\n+ \\\"5e-5\\\",\\n+ \\\"--max_steps\\\",\\n+ \\\"50.5\\\",\\n+ ]\\n+\\n+\\n+class SageMakerLaunch(unittest.TestCase):\\n+ def test_args_convert(self):\\n+ # If no defaults are changed, `to_kwargs` returns an empty dict.\\n+ converted_args = _convert_nargs_to_dict(MockLaunchConfig.success_training_script_args)\\n+ assert isinstance(converted_args[\\\"model_name_or_path\\\"], str)\\n+ assert isinstance(converted_args[\\\"do_train\\\"], bool)\\n+ assert isinstance(converted_args[\\\"epochs\\\"], int)\\n+ assert isinstance(converted_args[\\\"learning_rate\\\"], float)\\n+ assert isinstance(converted_args[\\\"max_steps\\\"], float)\\n+\\n+ with pytest.raises(ValueError):\\n+ _convert_nargs_to_dict(MockLaunchConfig.fail_training_script_args)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n## Getting Started\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+<!---\\n+Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+---\\n+\\n+## Getting Started: Train a π€ Transformers Model\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nπ€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. π€ Accelerate is not in the DLC yet (swill soon be added!) so to use it within Amazon SageMaker you need to create a `requirements.txt` in the same directory where your training script is located and add it as dependency.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+<!---\\n+Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+---\\n+\\n+## Getting Started: Train a π€ Transformers Model\\n+\\n+### Setup & Installation\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not have an AWS account yet learn more [here](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). \\n+\\n+After you have your AWS Account you need to install the `sagemaker` sdk for π€ Accelerate with. \\n+\\n+```python\\n+pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+```\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. To be able to use π€ Accelerate within Amazon SageMaker you need to create a `requirements.txt` in the same directory where your training script is located and add it as dependency.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nYou should also add any other dependencies you have to this `requirements.txt`. \\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+<!---\\n+Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+---\\n+\\n+## Getting Started: Train a π€ Transformers Model\\n+\\n+### Setup & Installation\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not have an AWS account yet learn more [here](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). \\n+\\n+After you have your AWS Account you need to install the `sagemaker` sdk for π€ Accelerate with. \\n+\\n+```python\\n+pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+```\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. To be able to use π€ Accelerate within Amazon SageMaker you need to create a `requirements.txt` in the same directory where your training script is located and add it as dependency.\\n+\\n+```python\\n+accelerate\\n+```\\n+\\n+You can also add other dependencies to this `requirements.txt`. \",\n \"from_author\": false\n },\n {\n \"body\": \"What do you mean here? Shouldn't it be in the example?\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+<!---\\n+Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+---\\n+\\n+## Getting Started: Train a π€ Transformers Model\\n+\\n+### Setup & Installation\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not have an AWS account yet learn more [here](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). \\n+\\n+After you have your AWS Account you need to install the `sagemaker` sdk for π€ Accelerate with. \\n+\\n+```python\\n+pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+```\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. To be able to use π€ Accelerate within Amazon SageMaker you need to create a `requirements.txt` in the same directory where your training script is located and add it as dependency.\\n+\\n+```python\\n+accelerate\\n+```\\n+\\n+You can also add other dependencies to this `requirements.txt`. \\n+\\n+\\n+### Configure π€ Accelerate \\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with the π€ Accelerate CLI. \\n+\\n+```bash\\n+accelerate config\\n+# In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+```\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit. \\n+\\n+_**Note**: π€ Accelerate is not saving any of your credentials._\\n+\\n+\\n+### Prepare a π€ Accelerate fine-tuning script.\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model after training you need to specify either `/opt/ml/model` or use `os.environ[\\\"SM_MODEL_DIR\\\"]` as your save directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+```diff\\n+- torch.save()\\n++ accelerator.save('/opt/ml/model')\\n+```\\n+\\n+### Launch Training\\n+\\n+You can launch your training with π€ Accelerate CLI with\\n+\\n+```bash\\n+accelerate launch path_to_script.py --args_to_the_script\\n+```\\n+\\n+This will launch your training script using your configuration. The only thing you have to do is provide all the arguments needed by your training script as named arguments.\\n+\\n+**Examples**\\n+\\n+_**Note**: If you run one of the example scripts, don't for get to add `accelerator.save('/opt/ml/model')`to it._\",\n \"from_author\": false\n },\n {\n \"body\": \"I see you did something for those later on, is it still necessary? We should make sure we support those as they are very common, or if they are not, it should be made clear in the docs.\",\n \"diff_hunk\": \"@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"Should we amke one folder for each example? The CV example would require more.\",\n \"diff_hunk\": \"@@ -0,0 +1 @@\\n+accelerate # used to be installed in Amazon SageMaker environment\",\n \"from_author\": false\n },\n {\n \"body\": \"There should be something for `store_false` too.\",\n \"diff_hunk\": \"@@ -168,11 +184,100 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ action = \\\"store_true\\\"\\n+ else: # action_true parameter is last element\\n+ action = \\\"store_true\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"The current example doesn't show how to save models at all. So that's why I added it here.\",\n \"diff_hunk\": \"@@ -0,0 +1,134 @@\\n+<!---\\n+Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+you may not use this file except in compliance with the License.\\n+You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+Unless required by applicable law or agreed to in writing, software\\n+distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+See the License for the specific language governing permissions and\\n+limitations under the License.\\n+-->\\n+\\n+# Amazon SageMaker\\n+\\n+Hugging Face and Amazon introduced new [Hugging Face Deep Learning Containers (DLCs)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers) to make it easier than ever to train Hugging Face Transformer models in [Amazon SageMaker](https://aws.amazon.com/sagemaker/).\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+---\\n+\\n+## Getting Started: Train a π€ Transformers Model\\n+\\n+### Setup & Installation\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not have an AWS account yet learn more [here](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). \\n+\\n+After you have your AWS Account you need to install the `sagemaker` sdk for π€ Accelerate with. \\n+\\n+```python\\n+pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+```\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with `transformers`, `datasets` and `tokenizers` pre-installed. To be able to use π€ Accelerate within Amazon SageMaker you need to create a `requirements.txt` in the same directory where your training script is located and add it as dependency.\\n+\\n+```python\\n+accelerate\\n+```\\n+\\n+You can also add other dependencies to this `requirements.txt`. \\n+\\n+\\n+### Configure π€ Accelerate \\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with the π€ Accelerate CLI. \\n+\\n+```bash\\n+accelerate config\\n+# In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+```\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit. \\n+\\n+_**Note**: π€ Accelerate is not saving any of your credentials._\\n+\\n+\\n+### Prepare a π€ Accelerate fine-tuning script.\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model after training you need to specify either `/opt/ml/model` or use `os.environ[\\\"SM_MODEL_DIR\\\"]` as your save directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+```diff\\n+- torch.save()\\n++ accelerator.save('/opt/ml/model')\\n+```\\n+\\n+### Launch Training\\n+\\n+You can launch your training with π€ Accelerate CLI with\\n+\\n+```bash\\n+accelerate launch path_to_script.py --args_to_the_script\\n+```\\n+\\n+This will launch your training script using your configuration. The only thing you have to do is provide all the arguments needed by your training script as named arguments.\\n+\\n+**Examples**\\n+\\n+_**Note**: If you run one of the example scripts, don't for get to add `accelerator.save('/opt/ml/model')`to it._\",\n \"from_author\": true\n },\n {\n \"body\": \"SageMaker cannot pass `store_true` or `store_false` to a script executed. \\r\\n\\r\\n> Note that SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to specify type as bool in your script and provide an explicit True or False value for this hyperparameter when instantiating PyTorch Estimator.\\r\\n\\r\\nhttps://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script\\r\\n\\r\\nshould we add it to the documentation then? \",\n \"diff_hunk\": \"@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"for the CV example to work we would only need to add `timm`. `torchvision` should be inside the DLC since it uses the AWS PyTorch DLC as base\\r\\n\",\n \"diff_hunk\": \"@@ -0,0 +1 @@\\n+accelerate # used to be installed in Amazon SageMaker environment\",\n \"from_author\": true\n },\n {\n \"body\": \"puh. I that even possible? like how can someone cloud tell the difference between `store_true` and `store_false` without knowing the script... \",\n \"diff_hunk\": \"@@ -168,11 +184,100 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ action = \\\"store_true\\\"\\n+ else: # action_true parameter is last element\\n+ action = \\\"store_true\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"Yes, it should be properly documented.\",\n \"diff_hunk\": \"@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\",\n \"from_author\": false\n },\n {\n \"body\": \"I have no idea what you're doing it here then. Also I though the script could not have `--store_true`/`--store_false`\\r\\n\\r\\nOn top of the documentation, we should add a nice error message here if the parser has arguments with `--store_true`/`--store_false`.\",\n \"diff_hunk\": \"@@ -168,11 +184,100 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ action = \\\"store_true\\\"\\n+ else: # action_true parameter is last element\\n+ action = \\\"store_true\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"I reworked the documentation to use `.rst` to highlight it as a warning. ([see PR comment](https://github.com/huggingface/accelerate/pull/26#issuecomment-818525901))\",\n \"diff_hunk\": \"@@ -162,8 +162,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n- parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", type=bool, default=False, help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", type=bool, default=False, help=\\\"If passed, will train on the CPU.\\\")\",\n \"from_author\": true\n },\n {\n \"body\": \"For SageMaker to work I needed to convert the `args.training_script_args` from `--foo bar --john 2 --store_true --another key` to\\r\\n ```python\\r\\n{\\r\\n\\\"foo\\\":\\\"bar\\\",\\r\\n\\\"john\\\": 2,\\r\\n\\\"store_true\\\": True,\\r\\n\\\"another\\\": \\\"key\\\"\\r\\n}\\r\\n```\\r\\nTo achieve this I built this dynamic args parser, which takes the `args.training_script_args` and creates an `argsparser` out of it to apply afterward on `args.training_script_args` to create this `dict`. \\r\\n\\r\\nWhile creating this I haven't thought of `store_false`, since I never have seen it in real use, that's why I expected that there is only `store_true` and implemented it like that. \\r\\n\",\n \"diff_hunk\": \"@@ -168,11 +184,100 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ action = \\\"store_true\\\"\\n+ else: # action_true parameter is last element\\n+ action = \\\"store_true\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"Should we add `timm` to the `requirements.txt` to make both examples runnable out of the box?\",\n \"diff_hunk\": \"@@ -0,0 +1 @@\\n+accelerate # used to be installed in Amazon SageMaker environment\",\n \"from_author\": true\n },\n {\n \"body\": \"As discussed I adjusted the convert script to raise an error if someone uses `store` actions and added a case into the test. \",\n \"diff_hunk\": \"@@ -168,11 +184,100 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ action = \\\"store_true\\\"\\n+ else: # action_true parameter is last element\\n+ action = \\\"store_true\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"```suggestion\\r\\nhave an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`_.\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n <https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script>`__.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`_.\\n+\\n+After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n+\\n+.. code-block:: \\n+\\n+ pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n+Accelerate is not in the DLC yet (swill soon be added!) so to use it within Amazon SageMaker you need to create a\\n+``requirements.txt`` in the same directory where your training script is located and add it as dependency.\\n+\\n+.. code-block:: \\n+\\n+ accelerate\\n+\\n+You should also add any other dependencies you have to this ``requirements.txt``.\\n+\\n+\\n+Configure π€ Accelerate\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n+the π€ Accelerate CLI.\\n+\\n+.. code-block:: \\n+\\n+ accelerate config\\n+ # In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n+\\n+.. note::\\n+ π€ Accelerate is not saving any of your credentials.\\n+\\n+\\n+Prepare a π€ Accelerate fine-tuning script\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n+after training you need to specify either ``/opt/ml/model`` or use ``os.environ[\\\"SM_MODEL_DIR\\\"]`` as your save\\n+directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+\\n+.. code-block:: diff\\n+\\n+ - torch.save()\\n+ + accelerator.save('/opt/ml/model')\\n+\\n+\\n+.. warning::\\n+ SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to\\n+ specify type as bool in your script and provide an explicit True or False value for this hyperparameter. `[REF]\\n+ <https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script>`_\",\n \"from_author\": false\n },\n {\n \"body\": \"fp16 might not be accepted by the script so it should not be added like this. It should be added in the env instead, in the variable `\\\"USE_FP16\\\"` (which is what accelerate will look for).\",\n \"diff_hunk\": \"@@ -168,11 +184,105 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n-def sagemaker_launcher(sagemaker_config, args):\\n- raise NotImplementedError(\\n- \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+def _convert_nargs_to_dict(nargs: List[str]) -> Dict[str, str]:\\n+ if len(nargs) < 0:\\n+ return {}\\n+ # helper function to infer type for argsparser\\n+\\n+ def _infer_type(s):\\n+ try:\\n+ s = float(s)\\n+\\n+ if s // 1 == s:\\n+ return int(s)\\n+ return s\\n+ except ValueError:\\n+ return s\\n+\\n+ parser = argparse.ArgumentParser()\\n+ _, unknown = parser.parse_known_args(nargs)\\n+ for index, argument in enumerate(unknown):\\n+ if argument.startswith((\\\"-\\\", \\\"--\\\")):\\n+ action = None\\n+ if index + 1 < len(unknown): # checks if next index would be in list\\n+ if unknown[index + 1].startswith((\\\"-\\\", \\\"--\\\")): # checks if next element is an key\\n+ # raise an error if element is store_true or store_false\\n+ raise ValueError(\\n+ \\\"SageMaker doesnβt support argparse actions for `store_true` or `store_false`. Please define explicit types\\\"\\n+ )\\n+ else: # raise an error if last element is store_true or store_false\\n+ raise ValueError(\\n+ \\\"SageMaker doesnβt support argparse actions for `store_true` or `store_false`. Please define explicit types\\\"\\n+ )\\n+ # adds argument to parser based on action_store true\\n+ if action is None:\\n+ parser.add_argument(argument, type=_infer_type)\\n+ else:\\n+ parser.add_argument(argument, action=action)\\n+\\n+ return {\\n+ key: (literal_eval(value) if value == \\\"True\\\" or value == \\\"False\\\" else value)\\n+ for key, value in parser.parse_args(nargs).__dict__.items()\\n+ }\\n+\\n+\\n+def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):\\n+ if not is_sagemaker_available():\\n+ raise ImportError(\\n+ \\\"Please install sagemaker to be able to launch training on Amazon SageMaker with `pip install accelerate[sagemaker]`\\\"\\n+ )\\n+ from sagemaker.huggingface import HuggingFace\\n+\\n+ # configure environment\\n+ print(\\\"Configuring Amazon SageMaker environment\\\")\\n+ os.environ[\\\"AWS_DEFAULT_REGION\\\"] = sagemaker_config.region\\n+\\n+ # configure credentials\\n+ if sagemaker_config.profile is not None:\\n+ os.environ[\\\"AWS_PROFILE\\\"] = sagemaker_config.profile\\n+ elif args.aws_access_key_id is not None and args.aws_secret_access_key is not None:\\n+ os.environ[\\\"AWS_ACCESS_KEY_ID\\\"] = args.aws_access_key_id\\n+ os.environ[\\\"AWS_SECRET_ACCESS_KEY\\\"] = args.aws_secret_access_key\\n+ else:\\n+ raise EnvironmentError(\\n+ \\\"You need to provide an aws_access_key_id and aws_secret_access_key when not using aws_profile\\\"\\n+ )\\n+\\n+ # extract needed arguments\\n+ source_dir = os.path.dirname(args.training_script)\\n+ if not source_dir: # checks if string is empty\\n+ source_dir = \\\".\\\"\\n+ entry_point = os.path.basename(args.training_script)\\n+ if not entry_point.endswith(\\\".py\\\"):\\n+ raise ValueError(f'Your training script should be a python script and not \\\"{entry_point}\\\"')\\n+\\n+ print(\\\"Converting Arguments to Hyperparameters\\\")\\n+ converted_hyperparameters = _convert_nargs_to_dict(args.training_script_args)\\n+ hyperparameters = {\\\"fp16\\\": args.fp16, **converted_hyperparameters}\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\nAccelerate is not in the DLC yet (will soon be added!) so to use it within Amazon SageMaker you need to create a\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\n+\\n+After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n+\\n+.. code-block:: \\n+\\n+ pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n+Accelerate is not in the DLC yet (swill soon be added!) so to use it within Amazon SageMaker you need to create a\",\n \"from_author\": false\n },\n {\n \"body\": \"I would also add the `/opt/ml/model` here for consistency\\r\\n```suggestion\\r\\n - torch.save('/opt/ml/model`)\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\n+\\n+After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n+\\n+.. code-block:: \\n+\\n+ pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n+Accelerate is not in the DLC yet (swill soon be added!) so to use it within Amazon SageMaker you need to create a\\n+``requirements.txt`` in the same directory where your training script is located and add it as dependency.\\n+\\n+.. code-block:: \\n+\\n+ accelerate\\n+\\n+You should also add any other dependencies you have to this ``requirements.txt``.\\n+\\n+\\n+Configure π€ Accelerate\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n+the π€ Accelerate CLI.\\n+\\n+.. code-block:: \\n+\\n+ accelerate config\\n+ # In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n+\\n+.. note::\\n+ π€ Accelerate is not saving any of your credentials.\\n+\\n+\\n+Prepare a π€ Accelerate fine-tuning script\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n+after training you need to specify either ``/opt/ml/model`` or use ``os.environ[\\\"SM_MODEL_DIR\\\"]`` as your save\\n+directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+\\n+.. code-block:: diff\\n+\\n+ - torch.save()\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n If you run one of the example scripts, don't forget to add ``accelerator.save('/opt/ml/model')`` to it.\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,169 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+Amazon SageMaker\\n+=======================================================================================================================\\n+\\n+Hugging Face and Amazon introduced new `Hugging Face Deep Learning Containers (DLCs)\\n+<https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers>`_ to\\n+make it easier than ever to train Hugging Face Transformer models in `Amazon SageMaker\\n+<https://aws.amazon.com/sagemaker/>`_.\\n+\\n+To learn how to use the new π€ DLCs with the Amazon SageMaker to run your π€ Accelerate scripts and raw training loops.0\\n+\\n+\\n+\\n+Getting Started\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+Setup & Installation\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+\\n+Before you can run your π€ Accelerate scripts on Amazon SageMaker you need to sign up for an AWS account. If you do not\\n+have an AWS account yet learn more `here <https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html>`__.\\n+\\n+After you have your AWS Account you need to install the ``sagemaker`` sdk for π€ Accelerate with.\\n+\\n+.. code-block:: \\n+\\n+ pip install \\\"accelerate[sagemaker]\\\" --upgrade\\n+\\n+\\n+π€ Accelerate currently uses the π€ DLCs, with ``transformers``, ``datasets`` and ``tokenizers`` pre-installed. π€\\n+Accelerate is not in the DLC yet (swill soon be added!) so to use it within Amazon SageMaker you need to create a\\n+``requirements.txt`` in the same directory where your training script is located and add it as dependency.\\n+\\n+.. code-block:: \\n+\\n+ accelerate\\n+\\n+You should also add any other dependencies you have to this ``requirements.txt``.\\n+\\n+\\n+Configure π€ Accelerate\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can configure the launch configuration for Amazon SageMaker the same as you do for non SageMaker training jobs with\\n+the π€ Accelerate CLI.\\n+\\n+.. code-block:: \\n+\\n+ accelerate config\\n+ # In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 1\\n+\\n+\\n+π€ Accelerate will go through a questionnaire about your Amazon SageMaker setup and create a config file you can edit.\\n+\\n+.. note::\\n+ π€ Accelerate is not saving any of your credentials.\\n+\\n+\\n+Prepare a π€ Accelerate fine-tuning script\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+The training script is very similar to a training script you might run outside of SageMaker, but to save your model\\n+after training you need to specify either ``/opt/ml/model`` or use ``os.environ[\\\"SM_MODEL_DIR\\\"]`` as your save\\n+directory. After training, artifacts in this directory are uploaded to S3.\\n+\\n+\\n+.. code-block:: diff\\n+\\n+ - torch.save()\\n+ + accelerator.save('/opt/ml/model')\\n+\\n+\\n+.. warning::\\n+ SageMaker doesnβt support argparse actions. If you want to use, for example, boolean hyperparameters, you need to\\n+ specify type as bool in your script and provide an explicit True or False value for this hyperparameter. `[REF]\\n+ <https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#prepare-a-pytorch-training-script>`__.\\n+\\n+\\n+Launch Training\\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\n+\\n+You can launch your training with π€ Accelerate CLI with\\n+\\n+.. code-block:: \\n+\\n+ accelerate launch path_to_script.py --args_to_the_script\\n+\\n+\\n+This will launch your training script using your configuration. The only thing you have to do is provide all the\\n+arguments needed by your training script as named arguments.\\n+\\n+**Examples**\\n+\\n+.. note::\\n+ If you run one of the example scripts, don't for get to add ``accelerator.save('/opt/ml/model')`` to it.\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"\\r\\n\",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/26\",\n \"pr_id\": 612316809\n },\n {\n \"diff\": \"diff --git a/docs/source/conf.py b/docs/source/conf.py\\nindex 7d6210327..016feb77f 100644\\n--- a/docs/source/conf.py\\n+++ b/docs/source/conf.py\\n@@ -14,17 +14,18 @@\\n #\\n import os\\n import sys\\n-sys.path.insert(0, os.path.abspath('../../src'))\\n+\\n+sys.path.insert(0, os.path.abspath(\\\"../../src\\\"))\\n \\n \\n # -- Project information -----------------------------------------------------\\n \\n-project = u'accelerate'\\n-copyright = u'2020, The Hugging Face Team, Licenced under the Apache License, Version 2.0'\\n-author = u'huggingface'\\n+project = \\\"accelerate\\\"\\n+copyright = \\\"2020, The Hugging Face Team, Licenced under the Apache License, Version 2.0\\\"\\n+author = \\\"huggingface\\\"\\n \\n # The short X.Y version\\n-version = u'0.1.0'\\n+version = \\\"0.1.0\\\"\\n \\n # -- General configuration ---------------------------------------------------\\n \\n@@ -36,27 +37,28 @@\\n # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom\\n # ones.\\n extensions = [\\n- 'sphinx.ext.autodoc',\\n- 'sphinx.ext.extlinks',\\n- 'sphinx.ext.coverage',\\n- 'sphinx.ext.napoleon',\\n- 'recommonmark',\\n- 'sphinx.ext.viewcode',\\n- 'sphinx_markdown_tables',\\n- 'sphinx_copybutton'\\n+ \\\"sphinx.ext.autodoc\\\",\\n+ \\\"sphinx.ext.extlinks\\\",\\n+ \\\"sphinx.ext.coverage\\\",\\n+ \\\"sphinx.ext.napoleon\\\",\\n+ \\\"recommonmark\\\",\\n+ \\\"sphinx.ext.viewcode\\\",\\n+ \\\"sphinx_markdown_tables\\\",\\n+ \\\"sphinx_copybutton\\\",\\n+ \\\"sphinxext.opengraph\\\",\\n ]\\n \\n # Add any paths that contain templates here, relative to this directory.\\n-templates_path = ['_templates']\\n+templates_path = [\\\"_templates\\\"]\\n \\n # The suffix(es) of source filenames.\\n # You can specify multiple suffix as a list of string:\\n #\\n-source_suffix = ['.rst', '.md']\\n+source_suffix = [\\\".rst\\\", \\\".md\\\"]\\n # source_suffix = '.rst'\\n \\n # The master toctree document.\\n-master_doc = 'index'\\n+master_doc = \\\"index\\\"\\n \\n # The language for content autogenerated by Sphinx. Refer to documentation\\n # for a list of supported languages.\\n@@ -68,7 +70,7 @@\\n # List of patterns, relative to source directory, that match files and\\n # directories to ignore when looking for source files.\\n # This pattern also affects html_static_path and html_extra_path.\\n-exclude_patterns = [u'_build', 'Thumbs.db', '.DS_Store']\\n+exclude_patterns = [\\\"_build\\\", \\\"Thumbs.db\\\", \\\".DS_Store\\\"]\\n \\n # The name of the Pygments (syntax highlighting) style to use.\\n pygments_style = None\\n@@ -82,20 +84,31 @@\\n # The theme to use for HTML and HTML Help pages. See the documentation for\\n # a list of builtin themes.\\n #\\n-html_theme = 'sphinx_rtd_theme'\\n+html_theme = \\\"sphinx_rtd_theme\\\"\\n \\n # Theme options are theme-specific and customize the look and feel of a theme\\n # further. For a list of options available for each theme, see the\\n # documentation.\\n #\\n-html_theme_options = {\\n- 'analytics_id': 'UA-83738774-2'\\n-}\\n+html_theme_options = {\\\"analytics_id\\\": \\\"UA-83738774-2\\\"}\\n+\\n+# Configuration for OpenGraph and Twitter Card Tags.\\n+# These are responsible for creating nice shareable social images https://ahrefs.com/blog/open-graph-meta-tags/\\n+# https://ogp.me/#type_website\\n+ogp_image = \\\"https://huggingface.co/front/thumbnails/docs/accelerate.png\\\"\\n+ogp_description = \\\"Run your raw PyTorch training script on any kind of device. π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed setting (multi-GPUs, TPUs etc.)\\\"\\n+ogp_description_length = 160\\n+\\n+ogp_custom_meta_tags = [\\n+ f'<meta name=\\\"twitter:image\\\" content=\\\"{ogp_image}\\\">',\\n+ f'<meta name=\\\"twitter:description\\\" content=\\\"{ogp_description}\\\">',\\n+]\\n+\\n \\n # Add any paths that contain custom static files (such as style sheets) here,\\n # relative to this directory. They are copied after the builtin static files,\\n # so a file named \\\"default.css\\\" will overwrite the builtin \\\"default.css\\\".\\n-html_static_path = ['_static']\\n+html_static_path = [\\\"_static\\\"]\\n \\n # Custom sidebar templates, must be a dictionary that maps document names\\n # to template names.\\n@@ -107,17 +120,17 @@\\n #\\n # html_sidebars = {}\\n \\n-# This must be the name of an image file (path relative to the configuration \\n-# directory) that is the favicon of the docs. Modern browsers use this as \\n-# the icon for tabs, windows and bookmarks. It should be a Windows-style \\n+# This must be the name of an image file (path relative to the configuration\\n+# directory) that is the favicon of the docs. Modern browsers use this as\\n+# the icon for tabs, windows and bookmarks. It should be a Windows-style\\n # icon file (.ico).\\n-html_favicon = 'favicon.ico'\\n+html_favicon = \\\"favicon.ico\\\"\\n \\n \\n # -- Options for HTMLHelp output ---------------------------------------------\\n \\n # Output file base name for HTML help builder.\\n-htmlhelp_basename = 'acceleratedoc'\\n+htmlhelp_basename = \\\"acceleratedoc\\\"\\n \\n \\n # -- Options for LaTeX output ------------------------------------------------\\n@@ -126,15 +139,12 @@\\n # The paper size ('letterpaper' or 'a4paper').\\n #\\n # 'papersize': 'letterpaper',\\n-\\n # The font size ('10pt', '11pt' or '12pt').\\n #\\n # 'pointsize': '10pt',\\n-\\n # Additional stuff for the LaTeX preamble.\\n #\\n # 'preamble': '',\\n-\\n # Latex figure (float) alignment\\n #\\n # 'figure_align': 'htbp',\\n@@ -144,8 +154,7 @@\\n # (source start file, target name, title,\\n # author, documentclass [howto, manual, or own class]).\\n latex_documents = [\\n- (master_doc, 'accelerate.tex', u'accelerate Documentation',\\n- u'huggingface', 'manual'),\\n+ (master_doc, \\\"accelerate.tex\\\", \\\"accelerate Documentation\\\", \\\"huggingface\\\", \\\"manual\\\"),\\n ]\\n \\n \\n@@ -153,10 +162,7 @@\\n \\n # One entry per manual page. List of tuples\\n # (source start file, name, description, authors, manual section).\\n-man_pages = [\\n- (master_doc, 'accelerate', u'accelerate Documentation',\\n- [author], 1)\\n-]\\n+man_pages = [(master_doc, \\\"accelerate\\\", \\\"accelerate Documentation\\\", [author], 1)]\\n \\n \\n # -- Options for Texinfo output ----------------------------------------------\\n@@ -165,9 +171,15 @@\\n # (source start file, target name, title, author,\\n # dir menu entry, description, category)\\n texinfo_documents = [\\n- (master_doc, 'accelerate', u'accelerate Documentation',\\n- author, 'accelerate', 'One line description of project.',\\n- 'Miscellaneous'),\\n+ (\\n+ master_doc,\\n+ \\\"accelerate\\\",\\n+ \\\"accelerate Documentation\\\",\\n+ author,\\n+ \\\"accelerate\\\",\\n+ \\\"One line description of project.\\\",\\n+ \\\"Miscellaneous\\\",\\n+ ),\\n ]\\n \\n \\n@@ -186,11 +198,13 @@\\n # epub_uid = ''\\n \\n # A list of files that should not be packed into the epub file.\\n-epub_exclude_files = ['search.html']\\n+epub_exclude_files = [\\\"search.html\\\"]\\n+\\n \\n def setup(app):\\n- app.add_css_file('css/huggingface.css')\\n- app.add_css_file('css/code-snippets.css')\\n- app.add_js_file('js/custom.js')\\n+ app.add_css_file(\\\"css/huggingface.css\\\")\\n+ app.add_css_file(\\\"css/code-snippets.css\\\")\\n+ app.add_js_file(\\\"js/custom.js\\\")\\n+\\n \\n # -- Extension configuration -------------------------------------------------\\ndiff --git a/setup.py b/setup.py\\nindex b6722e124..e2ce2cfbc 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -24,6 +24,7 @@\\n \\\"sphinx-markdown-tables\\\",\\n \\\"sphinx-rtd-theme==0.4.3\\\",\\n \\\"sphinx-copybutton\\\",\\n+ \\\"sphinxext-opengraph==0.4.1\\\",\\n ]\\n extras[\\\"test\\\"] = [\\n \\\"pytest\\\",\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"FYI the moon-landing PR has been merged and deployed :)\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/25\",\n \"pr_id\": 610386427\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nindex 5b0dd00ba..fe2cb122a 100644\\n--- a/src/accelerate/commands/config/config_args.py\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -42,13 +42,13 @@ def load_config_from_file(config_file):\\n config_file = config_file if config_file is not None else default_config_file\\n with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n if config_file.endswith(\\\".json\\\"):\\n- if json.load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.LOCAL_MACHINE:\\n+ if json.load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE):\\n config_class = ClusterConfig\\n else:\\n config_class = SageMakerConfig\\n return config_class.from_json_file(json_file=config_file)\\n else:\\n- if yaml.safe_load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.LOCAL_MACHINE:\\n+ if yaml.safe_load(f).get(\\\"compute_environment\\\", ComputeEnvironment.LOCAL_MACHINE):\\n config_class = ClusterConfig\\n else:\\n config_class = SageMakerConfig\\n@@ -73,7 +73,10 @@ def to_dict(self):\\n def from_json_file(cls, json_file=None):\\n json_file = default_json_config_file if json_file is None else json_file\\n with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n- return cls(**json.load(f))\\n+ config_dict = json.load(f)\\n+ if \\\"compute_environment\\\" not in config_dict:\\n+ config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ return cls(**config_dict)\\n \\n def to_json_file(self, json_file):\\n with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n@@ -84,7 +87,10 @@ def to_json_file(self, json_file):\\n def from_yaml_file(cls, yaml_file=None):\\n yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n- return cls(**yaml.safe_load(f))\\n+ config_dict = yaml.safe_load(f)\\n+ if \\\"compute_environment\\\" not in config_dict:\\n+ config_dict[\\\"compute_environment\\\"] = ComputeEnvironment.LOCAL_MACHINE\\n+ return cls(**config_dict)\\n \\n def to_yaml_file(self, yaml_file):\\n with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"No problem @philschmid, I should have caught it during the review :-) \",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/23\",\n \"pr_id\": 604294677\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 68d6866b5..77c6b6ebf 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -53,38 +53,38 @@ limitations under the License.\\n Here is an example:\\n \\n ```diff\\n-import torch\\n-import torch.nn.functional as F\\n-from datasets import load_dataset\\n+ import torch\\n+ import torch.nn.functional as F\\n+ from datasets import load_dataset\\n \\n + from accelerate import Accelerator\\n + accelerator = Accelerator()\\n - device = 'cpu'\\n + device = accelerator.device\\n \\n-model = torch.nn.Transformer().to(device)\\n-optim = torch.optim.Adam(model.parameters())\\n+ model = torch.nn.Transformer().to(device)\\n+ optim = torch.optim.Adam(model.parameters())\\n \\n-dataset = load_dataset('my_dataset')\\n-data = torch.utils.data.Dataloader(dataset)\\n+ dataset = load_dataset('my_dataset')\\n+ data = torch.utils.data.Dataloader(dataset)\\n \\n + model, optim, data = accelerator.prepare(model, optim, data)\\n \\n-model.train()\\n-for epoch in range(10):\\n- for source, targets in data:\\n- source = source.to(device)\\n- targets = targets.to(device)\\n+ model.train()\\n+ for epoch in range(10):\\n+ for source, targets in data:\\n+ source = source.to(device)\\n+ targets = targets.to(device)\\n \\n- optimizer.zero_grad()\\n+ optimizer.zero_grad()\\n \\n- output = model(source, targets)\\n- loss = F.cross_entropy(output, targets)\\n+ output = model(source, targets)\\n+ loss = F.cross_entropy(output, targets)\\n \\n + accelerator.backward(loss)\\n - loss.backward()\\n \\n- optimizer.step()\\n+ optimizer.step()\\n ```\\n \\n As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).\\n@@ -94,9 +94,9 @@ In particular, the same code can then be run without modification on your local\\n π€ Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:\\n \\n ```diff\\n-import torch\\n-import torch.nn.functional as F\\n-from datasets import load_dataset\\n+ import torch\\n+ import torch.nn.functional as F\\n+ from datasets import load_dataset\\n \\n + from accelerate import Accelerator\\n + accelerator = Accelerator()\\n@@ -104,28 +104,28 @@ from datasets import load_dataset\\n \\n + model = torch.nn.Transformer()\\n - model = torch.nn.Transformer().to(device)\\n-optim = torch.optim.Adam(model.parameters())\\n+ optim = torch.optim.Adam(model.parameters())\\n \\n-dataset = load_dataset('my_dataset')\\n-data = torch.utils.data.Dataloader(dataset)\\n+ dataset = load_dataset('my_dataset')\\n+ data = torch.utils.data.Dataloader(dataset)\\n \\n + model, optim, data = accelerator.prepare(model, optim, data)\\n \\n-model.train()\\n-for epoch in range(10):\\n- for source, targets in data:\\n+ model.train()\\n+ for epoch in range(10):\\n+ for source, targets in data:\\n - source = source.to(device)\\n - targets = targets.to(device)\\n \\n- optimizer.zero_grad()\\n+ optimizer.zero_grad()\\n \\n- output = model(source, targets)\\n- loss = F.cross_entropy(output, targets)\\n+ output = model(source, targets)\\n+ loss = F.cross_entropy(output, targets)\\n \\n + accelerator.backward(loss)\\n - loss.backward()\\n \\n- optimizer.step()\\n+ optimizer.step()\\n ```\\n \\n ## Launching script\\ndiff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex 57933888d..efdeb8f88 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -47,53 +47,58 @@ A traditional training loop in PyTorch looks like this:\\n \\n Changing it to work with accelerate is really easy and only adds a few lines of code:\\n \\n-.. code-block:: python\\n-\\n- from accelerate import Accelerator\\n-\\n- accelerator = Accelerator()\\n- # Use the device given by the `accelerator` object.\\n- device = accelerator.device\\n- my_model.to(device)\\n- # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n- my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n- my_model, my_optimizer, my_training_dataloader\\n- )\\n-\\n- for batch in my_training_dataloader:\\n- my_optimizer.zero_grad()\\n- inputs, targets = batch\\n- inputs = inputs.to(device)\\n- targets = targets.to(device)\\n- outputs = my_model(inputs)\\n- loss = my_loss_function(outputs, targets)\\n- # Just a small change for the backward instruction\\n- accelerate.backward(loss)\\n- my_optimizer.step()\\n+.. code-block:: diff\\n+\\n+ + from accelerate import Accelerator\\n+\\n+ + accelerator = Accelerator()\\n+ # Use the device given by the `accelerator` object.\\n+ + device = accelerator.device\\n+ my_model.to(device)\\n+ # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n+ + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n+ + my_model, my_optimizer, my_training_dataloader\\n+ + )\\n+\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ inputs = inputs.to(device)\\n+ targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ # Just a small change for the backward instruction\\n+ - loss.backward()\\n+ + accelerate.backward(loss)\\n+ my_optimizer.step()\\n \\n and with this, your script can now run in a distributed environment (multi-GPU, TPU).\\n \\n You can even simplify your script a bit by letting π€ Accelerate handle the device placement for you (which is safer,\\n especially for TPU training):\\n \\n-.. code-block:: python\\n-\\n- from accelerate import Accelerator\\n-\\n- accelerator = Accelerator()\\n- # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n- my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n- my_model, my_optimizer, my_training_dataloader\\n- )\\n-\\n- for batch in my_training_dataloader:\\n- my_optimizer.zero_grad()\\n- inputs, targets = batch\\n- outputs = my_model(inputs)\\n- loss = my_loss_function(outputs, targets)\\n- # Just a small change for the backward instruction\\n- accelerate.backward(loss)\\n- my_optimizer.step()\\n+.. code-block:: diff\\n+\\n+ + from accelerate import Accelerator\\n+\\n+ + accelerator = Accelerator()\\n+ - my_model.to(device)\\n+ # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`\\n+ + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(\\n+ + my_model, my_optimizer, my_training_dataloader\\n+ + )\\n+\\n+ for batch in my_training_dataloader:\\n+ my_optimizer.zero_grad()\\n+ inputs, targets = batch\\n+ - inputs = inputs.to(device)\\n+ - targets = targets.to(device)\\n+ outputs = my_model(inputs)\\n+ loss = my_loss_function(outputs, targets)\\n+ # Just a small change for the backward instruction\\n+ - loss.backward()\\n+ + accelerate.backward(loss)\\n+ my_optimizer.step()\\n \\n \\n Script launcher\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 31c94ef81..1d56f9e4b 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -359,7 +359,7 @@ The random number generator synchronization will by default synchronize:\\n - the main random number generator in PyTorch <=1.5.1\\n \\n You can choose which random number generator(s) to synchronize with the :obj:`rng_types` argument of the main\\n-:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator`s to avoid\\n+:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator` to avoid\\n setting the same seed in the main random number generator in all processes.\\n \\n .. Warning::\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/22\",\n \"pr_id\": 604022867\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex e67a4cee1..a8c11b887 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -198,10 +198,10 @@ def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n new_tensor = tensor.new_zeros(tuple(new_size)) + pad_index\\n if pad_first:\\n indices = tuple(\\n- slice(max_size - old_size[dim], max_size) if i == dim else slice(None) for i in range(len(size))\\n+ slice(max_size - old_size[dim], max_size) if i == dim else slice(None) for i in range(len(new_size))\\n )\\n else:\\n- indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(size)))\\n+ indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(new_size)))\\n new_tensor[indices] = tensor\\n return new_tensor\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/21\",\n \"pr_id\": 602836841\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 219b93248..68d6866b5 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -52,36 +52,23 @@ limitations under the License.\\n \\n Here is an example:\\n \\n-<table>\\n-<tr>\\n-<th> Original training code <br> (CPU or mono-GPU only)</th>\\n-<th> With Accelerate <br> (CPU/GPU/multi-GPUs/TPUs/fp16) </th>\\n-</tr>\\n-<tr>\\n-<td>\\n-\\n-```python\\n+```diff\\n import torch\\n import torch.nn.functional as F\\n from datasets import load_dataset\\n \\n-\\n-\\n-device = 'cpu'\\n++ from accelerate import Accelerator\\n++ accelerator = Accelerator()\\n+- device = 'cpu'\\n++ device = accelerator.device\\n \\n model = torch.nn.Transformer().to(device)\\n-optim = torch.optim.Adam(\\n- model.parameters()\\n-)\\n+optim = torch.optim.Adam(model.parameters())\\n \\n dataset = load_dataset('my_dataset')\\n-data = torch.utils.data.Dataloader(\\n- dataset\\n-)\\n-\\n-\\n-\\n+data = torch.utils.data.Dataloader(dataset)\\n \\n++ model, optim, data = accelerator.prepare(model, optim, data)\\n \\n model.train()\\n for epoch in range(10):\\n@@ -92,166 +79,55 @@ for epoch in range(10):\\n optimizer.zero_grad()\\n \\n output = model(source, targets)\\n- loss = F.cross_entropy(\\n- output, targets\\n- )\\n-\\n- loss.backward()\\n-\\n- optimizer.step()\\n-```\\n-\\n-</td>\\n-<td>\\n-\\n-```python\\n- import torch\\n- import torch.nn.functional as F\\n- from datasets import load_dataset\\n-\\n-+ from accelerate import Accelerator\\n-+ accelerator = Accelerator()\\n-+ device = accelerator.device\\n-\\n- model = torch.nn.Transformer().to(device)\\n- optim = torch.optim.Adam(\\n- model.parameters()\\n- )\\n-\\n- dataset = load_dataset('my_dataset')\\n- data = torch.utils.data.Dataloader(\\n- dataset\\n- )\\n-\\n-+ model, optim, data = accelerator.prepare(\\n-+ model, optim, data\\n-+ )\\n-\\n- model.train()\\n- for epoch in range(10):\\n- for source, targets in data:\\n- source = source.to(device)\\n- targets = targets.to(device)\\n-\\n- optimizer.zero_grad()\\n-\\n- output = model(source, targets)\\n- loss = F.cross_entropy(\\n- output, targets\\n- )\\n+ loss = F.cross_entropy(output, targets)\\n \\n + accelerator.backward(loss)\\n+- loss.backward()\\n \\n- optimizer.step()\\n+ optimizer.step()\\n ```\\n \\n-</td>\\n-</tr>\\n-</table>\\n-\\n As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).\\n \\n In particular, the same code can then be run without modification on your local machine for debugging or your training environment.\\n \\n π€ Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:\\n \\n-<table>\\n-<tr>\\n-<th> Original training code <br> (CPU or mono-GPU only)</th>\\n-<th> With Accelerate <br> (CPU/GPU/multi-GPUs/TPUs/fp16) </th>\\n-</tr>\\n-<tr>\\n-<td>\\n-\\n-```python\\n+```diff\\n import torch\\n import torch.nn.functional as F\\n from datasets import load_dataset\\n \\n++ from accelerate import Accelerator\\n++ accelerator = Accelerator()\\n+- device = 'cpu'\\n \\n-\\n-device = 'cpu'\\n-\\n-model = torch.nn.Transformer().to(device)\\n-optim = torch.optim.Adam(\\n- model.parameters()\\n-)\\n++ model = torch.nn.Transformer()\\n+- model = torch.nn.Transformer().to(device)\\n+optim = torch.optim.Adam(model.parameters())\\n \\n dataset = load_dataset('my_dataset')\\n-data = torch.utils.data.Dataloader(\\n- dataset\\n-)\\n-\\n-\\n-\\n+data = torch.utils.data.Dataloader(dataset)\\n \\n++ model, optim, data = accelerator.prepare(model, optim, data)\\n \\n model.train()\\n for epoch in range(10):\\n for source, targets in data:\\n- source = source.to(device)\\n- targets = targets.to(device)\\n+- source = source.to(device)\\n+- targets = targets.to(device)\\n \\n optimizer.zero_grad()\\n \\n output = model(source, targets)\\n- loss = F.cross_entropy(\\n- output, targets\\n- )\\n-\\n- loss.backward()\\n-\\n- optimizer.step()\\n-```\\n-\\n-</td>\\n-<td>\\n-\\n-```python\\n- import torch\\n- import torch.nn.functional as F\\n- from datasets import load_dataset\\n-\\n-+ from accelerate import Accelerator\\n-+ accelerator = Accelerator()\\n--\\n-\\n-+ model = torch.nn.Transformer()\\n- optim = torch.optim.Adam(\\n- model.parameters()\\n- )\\n-\\n- dataset = load_dataset('my_dataset')\\n- data = torch.utils.data.Dataloader(\\n- dataset\\n- )\\n-\\n-+ model, optim, data = accelerator.prepare(\\n-+ model, optim, data\\n-+ )\\n-\\n- model.train()\\n- for epoch in range(10):\\n- for source, targets in data:\\n--\\n--\\n-\\n- optimizer.zero_grad()\\n-\\n- output = model(source, targets)\\n- loss = F.cross_entropy(\\n- output, targets\\n- )\\n+ loss = F.cross_entropy(output, targets)\\n \\n + accelerator.backward(loss)\\n+- loss.backward()\\n \\n- optimizer.step()\\n+ optimizer.step()\\n ```\\n \\n-</td>\\n-</tr>\\n-</table>\\n-\\n ## Launching script\\n \\n π€ Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment before launching the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/20\",\n \"pr_id\": 601929380\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 1e3ac4e89..31c94ef81 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -130,6 +130,13 @@ do with the :meth:`~accelerate.Accelerator.gather` method.\\n Any instruction using your training dataloader length (for instance if you need the number of total training steps\\n to create a learning rate scheduler) should go after the call to :meth:`~accelerate.Accelerator.prepare`.\\n \\n+.. Warning::\\n+\\n+ The :meth:`~accelerate.Accelerator.gather` method requires the tensors to be all the same size on each process. If\\n+ you have tensors of different sizes on each process (for instance when dynamically padding to the maximum length in\\n+ a batch), you should use the :meth:`~accelerate.Accelerator.pad_across_processes` method to pad you tensor to the\\n+ biggest size across processes.\\n+\\n \\n Launching your distributed script\\n -----------------------------------------------------------------------------------------------------------------------\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex d9f7cf1bc..75539559e 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -22,7 +22,7 @@\\n from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n from .state import AcceleratorState, DistributedType\\n-from .utils import RNGType, extract_model_from_parallel, gather, save, wait_for_everyone\\n+from .utils import RNGType, extract_model_from_parallel, gather, pad_across_processes, save, wait_for_everyone\\n \\n \\n class Accelerator:\\n@@ -289,6 +289,23 @@ def gather(self, tensor):\\n \\\"\\\"\\\"\\n return gather(tensor)\\n \\n+ def pad_across_processes(self, tensor, dim=0, pad_index=0, pad_first=False):\\n+ \\\"\\\"\\\"\\n+ Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so\\n+ they can safely be gathered.\\n+\\n+ Args:\\n+ tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to gather.\\n+ dim (:obj:`int`, `optional`, defaults to 0):\\n+ The dimension on which to pad.\\n+ pad_index (:obj:`int`, `optional`, defaults to 0):\\n+ The value with which to pad.\\n+ pad_first (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ Whether to pad at the beginning or the end.\\n+ \\\"\\\"\\\"\\n+ return pad_across_processes(tensor, dim=dim, pad_index=pad_index, pad_first=pad_first)\\n+\\n def unwrap_model(self, model):\\n \\\"\\\"\\\"\\n Unwraps the :obj:`model` from the additional layer possible added by :meth:`~accelerate.Accelerator.prepare`.\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex f3a9ae92a..96368ba7b 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -21,7 +21,6 @@\\n import subprocess\\n import sys\\n from pathlib import Path\\n-from typing import Optional\\n \\n from accelerate.commands.config import LaunchConfig, default_config_file\\n from accelerate.state import DistributedType\\n@@ -68,9 +67,7 @@ def launch_command_parser(subparsers=None):\\n parser.add_argument(\\n \\\"--machine_rank\\\", type=int, default=0, help=\\\"The rank of the machine on which this script is launched.\\\"\\n )\\n- parser.add_argument(\\n- \\\"--main_process_ip\\\", type=str, default=None, help=\\\"The IP address of the machine of rank 0.\\\"\\n- )\\n+ parser.add_argument(\\\"--main_process_ip\\\", type=str, default=None, help=\\\"The IP address of the machine of rank 0.\\\")\\n parser.add_argument(\\n \\\"--main_process_port\\\",\\n type=int,\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 61a39fc95..e67a4cee1 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -148,7 +148,7 @@ def _gpu_gather(tensor):\\n \\n def gather(tensor):\\n \\\"\\\"\\\"\\n- Recusrively gather tensor in a nested list/tuple/dictionary of tensors from all devices.\\n+ Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.\\n \\n Args:\\n tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n@@ -165,6 +165,47 @@ def gather(tensor):\\n return tensor\\n \\n \\n+def pad_across_processes(tensor, dim=0, pad_index=0, pad_first=False):\\n+ \\\"\\\"\\\"\\n+ Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so they\\n+ can safely be gathered.\\n+\\n+ Args:\\n+ tensor (nested list/tuple/dictionary of :obj:`torch.Tensor`):\\n+ The data to gather.\\n+ dim (:obj:`int`, `optional`, defaults to 0):\\n+ The dimension on which to pad.\\n+ pad_index (:obj:`int`, `optional`, defaults to 0):\\n+ The value with which to pad.\\n+ pad_first (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n+ Whether to pad at the beginning or the end.\\n+ \\\"\\\"\\\"\\n+ if isinstance(tensor, (list, tuple)):\\n+ return type(tensor)(pad_across_processes(t, dim=dim, pad_index=pad_index) for t in tensor)\\n+ elif isinstance(tensor, dict):\\n+ return type(tensor)({k: pad_across_processes(v, dim=dim, pad_index=pad_index) for k, v in tensor.items()})\\n+ elif not isinstance(tensor, torch.Tensor):\\n+ raise TypeError(f\\\"Can't pad the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors.\\\")\\n+\\n+ # Gather all sizes\\n+ size = torch.tensor(tensor.shape, device=tensor.device)[None]\\n+ sizes = gather(size).cpu()\\n+ # Then pad to the maximum size\\n+ max_size = max(s[dim] for s in sizes)\\n+ old_size = tensor.shape\\n+ new_size = list(old_size)\\n+ new_size[dim] = max_size\\n+ new_tensor = tensor.new_zeros(tuple(new_size)) + pad_index\\n+ if pad_first:\\n+ indices = tuple(\\n+ slice(max_size - old_size[dim], max_size) if i == dim else slice(None) for i in range(len(size))\\n+ )\\n+ else:\\n+ indices = tuple(slice(0, old_size[dim]) if i == dim else slice(None) for i in range(len(size)))\\n+ new_tensor[indices] = tensor\\n+ return new_tensor\\n+\\n+\\n def wait_for_everyone():\\n \\\"\\\"\\\"\\n Introduces a blocking point in the script, making sure all processes have reached this point before continuing.\\ndiff --git a/tests/test_multigpu.py b/tests/test_multigpu.py\\nindex ce69a3db3..7ffbd94f8 100644\\n--- a/tests/test_multigpu.py\\n+++ b/tests/test_multigpu.py\\n@@ -20,6 +20,7 @@\\n import torch\\n \\n import accelerate\\n+from accelerate import Accelerator\\n from accelerate.test_utils import execute_subprocess_async, require_multi_gpu\\n \\n \\n@@ -39,3 +40,43 @@ def test_multi_gpu(self):\\n \\\"\\\"\\\".split()\\n cmd = [sys.executable] + distributed_args\\n execute_subprocess_async(cmd, env=os.environ.copy())\\n+\\n+ @require_multi_gpu\\n+ def test_pad_across_processes(self):\\n+ distributed_args = f\\\"\\\"\\\"\\n+ -m torch.distributed.launch\\n+ --nproc_per_node={torch.cuda.device_count()}\\n+ --use_env\\n+ {inspect.getfile(self.__class__)}\\n+ \\\"\\\"\\\".split()\\n+ cmd = [sys.executable] + distributed_args\\n+ execute_subprocess_async(cmd, env=os.environ.copy())\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ accelerator = Accelerator()\\n+ shape = (accelerator.state.process_index + 2, 10)\\n+ tensor = torch.randint(0, 10, shape).to(accelerator.device)\\n+\\n+ error_msg = \\\"\\\"\\n+\\n+ tensor1 = accelerator.pad_across_processes(tensor)\\n+ if tensor1.shape[0] != accelerator.state.num_processes + 1:\\n+ error_msg += f\\\"Found shape {tensor1.shape} but should have {accelerator.state.num_processes + 1} at dim 0.\\\"\\n+ if not torch.equal(tensor1[: accelerator.state.process_index + 2], tensor):\\n+ error_msg += \\\"Tensors have different values.\\\"\\n+ if not torch.all(tensor1[accelerator.state.process_index + 2 :] == 0):\\n+ error_msg += \\\"Padding was not done with the right value (0).\\\"\\n+\\n+ tensor2 = accelerator.pad_across_processes(tensor, pad_first=True)\\n+ if tensor2.shape[0] != accelerator.state.num_processes + 1:\\n+ error_msg += f\\\"Found shape {tensor2.shape} but should have {accelerator.state.num_processes + 1} at dim 0.\\\"\\n+ index = accelerator.state.num_processes - accelerator.state.process_index - 1\\n+ if not torch.equal(tensor2[index:], tensor):\\n+ error_msg += \\\"Tensors have different values.\\\"\\n+ if not torch.all(tensor2[:index] == 0):\\n+ error_msg += \\\"Padding was not done with the right value (0).\\\"\\n+\\n+ # Raise error at the end to make sure we don't stop at the first failure.\\n+ if len(error_msg) > 0:\\n+ raise ValueError(error_msg)\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/19\",\n \"pr_id\": 601823127\n },\n {\n \"diff\": \"diff --git a/.github/workflows/quality.yml b/.github/workflows/quality.yml\\nnew file mode 100644\\nindex 000000000..9b54a269f\\n--- /dev/null\\n+++ b/.github/workflows/quality.yml\\n@@ -0,0 +1,17 @@\\n+name: Quality Check\\n+\\n+on: [pull_request]\\n+\\n+jobs:\\n+ quality:\\n+ runs-on: ubuntu-latest\\n+ steps:\\n+ - uses: actions/checkout@v2\\n+ - name: Set up Python 3.6\\n+ uses: actions/setup-python@v2\\n+ with:\\n+ python-version: 3.6\\n+ - name: Install Python dependencies\\n+ run: pip install -e .[quality]\\n+ - name: Run Quality check\\n+ run: make quality\\n\\\\ No newline at end of file\\ndiff --git a/.github/workflows/test.yml b/.github/workflows/test.yml\\nnew file mode 100644\\nindex 000000000..aa04063d8\\n--- /dev/null\\n+++ b/.github/workflows/test.yml\\n@@ -0,0 +1,17 @@\\n+name: Run Tests\\n+\\n+on: [pull_request]\\n+\\n+jobs:\\n+ test:\\n+ runs-on: ubuntu-latest\\n+ steps:\\n+ - uses: actions/checkout@v2\\n+ - name: Set up Python 3.6\\n+ uses: actions/setup-python@v2\\n+ with:\\n+ python-version: 3.6\\n+ - name: Install Python dependencies\\n+ run: pip install -e .[test]\\n+ - name: Run Tests\\n+ run: make test\\n\\\\ No newline at end of file\\ndiff --git a/setup.py b/setup.py\\nindex 7a7a6a9cd..0fdc5e785 100644\\n--- a/setup.py\\n+++ b/setup.py\\n@@ -17,7 +17,21 @@\\n \\n extras = {}\\n extras[\\\"quality\\\"] = [\\\"black >= 20.8b1\\\", \\\"isort >= 5.5.4\\\", \\\"flake8 >= 3.8.3\\\"]\\n-extras[\\\"docs\\\"] = [\\\"recommonmark\\\", \\\"sphinx==3.2.1\\\", \\\"sphinx-markdown-tables\\\", \\\"sphinx-rtd-theme==0.4.3\\\", \\\"sphinx-copybutton\\\"]\\n+extras[\\\"docs\\\"] = [\\n+ \\\"recommonmark\\\",\\n+ \\\"sphinx==3.2.1\\\",\\n+ \\\"sphinx-markdown-tables\\\",\\n+ \\\"sphinx-rtd-theme==0.4.3\\\",\\n+ \\\"sphinx-copybutton\\\",\\n+]\\n+extras[\\\"test\\\"] = [\\n+ \\\"pytest\\\",\\n+ \\\"pytest-xdist\\\",\\n+]\\n+\\n+extras[\\\"sagemaker\\\"] = [\\n+ \\\"sagemaker\\\", # boto3 is a required package in sagemaker\\n+]\\n \\n setup(\\n name=\\\"accelerate\\\",\\n@@ -32,11 +46,13 @@\\n url=\\\"https://github.com/huggingface/accelerate\\\",\\n package_dir={\\\"\\\": \\\"src\\\"},\\n packages=find_packages(\\\"src\\\"),\\n- entry_points={\\\"console_scripts\\\": [\\n- \\\"accelerate=accelerate.commands.accelerate_cli:main\\\",\\n- \\\"accelerate-config=accelerate.commands.config:main\\\",\\n- \\\"accelerate-launch=accelerate.commands.launch:main\\\",\\n- ]},\\n+ entry_points={\\n+ \\\"console_scripts\\\": [\\n+ \\\"accelerate=accelerate.commands.accelerate_cli:main\\\",\\n+ \\\"accelerate-config=accelerate.commands.config:main\\\",\\n+ \\\"accelerate-launch=accelerate.commands.launch:main\\\",\\n+ ]\\n+ },\\n python_requires=\\\">=3.6.0\\\",\\n install_requires=[\\\"torch>=1.4.0\\\"],\\n extras_require=extras,\\ndiff --git a/src/accelerate/commands/config.py b/src/accelerate/commands/config.py\\ndeleted file mode 100644\\nindex c32905932..000000000\\n--- a/src/accelerate/commands/config.py\\n+++ /dev/null\\n@@ -1,218 +0,0 @@\\n-#!/usr/bin/env python\\n-\\n-# Copyright 2021 The HuggingFace Team. All rights reserved.\\n-#\\n-# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n-# you may not use this file except in compliance with the License.\\n-# You may obtain a copy of the License at\\n-#\\n-# http://www.apache.org/licenses/LICENSE-2.0\\n-#\\n-# Unless required by applicable law or agreed to in writing, software\\n-# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n-# See the License for the specific language governing permissions and\\n-# limitations under the License.\\n-\\n-import argparse\\n-import json\\n-import os\\n-from dataclasses import dataclass\\n-from enum import Enum\\n-from typing import Optional\\n-\\n-import yaml\\n-from accelerate.state import DistributedType\\n-\\n-\\n-hf_cache_home = os.path.expanduser(\\n- os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n-)\\n-cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n-default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n-default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n-\\n-# For backward compatibility: the default config is the json one if it's the only existing file.\\n-if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n- default_config_file = default_yaml_config_file\\n-else:\\n- default_config_file = default_json_config_file\\n-\\n-\\n-@dataclass\\n-class LaunchConfig:\\n- distributed_type: DistributedType\\n- num_processes: int\\n- fp16: bool\\n- machine_rank: int = 0\\n- num_machines: int = 1\\n- main_process_ip: Optional[str] = None\\n- main_process_port: Optional[int] = None\\n- main_training_function: str = \\\"main\\\"\\n-\\n- def __post_init__(self):\\n- if isinstance(self.distributed_type, str):\\n- self.distributed_type = DistributedType(self.distributed_type)\\n-\\n- def to_dict(self):\\n- result = self.__dict__\\n- # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n- for key, value in result.items():\\n- if isinstance(value, Enum):\\n- result[key] = value.value\\n- return result\\n-\\n- @classmethod\\n- def from_json_file(cls, json_file=None):\\n- json_file = default_json_config_file if json_file is None else json_file\\n- with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n- return cls(**json.load(f))\\n-\\n- def to_json_file(self, json_file):\\n- with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n- content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n- f.write(content)\\n-\\n- @classmethod\\n- def from_yaml_file(cls, yaml_file=None):\\n- yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n- with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n- return cls(**yaml.safe_load(f))\\n-\\n- def to_yaml_file(self, yaml_file):\\n- with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n- yaml.safe_dump(self.to_dict(), f)\\n-\\n-\\n-def config_command_parser(subparsers=None):\\n- if subparsers is not None:\\n- parser = subparsers.add_parser(\\\"config\\\")\\n- else:\\n- parser = argparse.ArgumentParser(\\\"Accelerate config command\\\")\\n-\\n- parser.add_argument(\\n- \\\"--config_file\\\",\\n- default=None,\\n- help=(\\n- \\\"The path to use to store the config file. Will default to a file named default_config.json in the cache \\\"\\n- \\\"location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have \\\"\\n- \\\"such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed \\\"\\n- \\\"with 'huggingface'.\\\"\\n- ),\\n- )\\n-\\n- if subparsers is not None:\\n- parser.set_defaults(func=config_command)\\n- return parser\\n-\\n-\\n-def _ask_field(input_text, convert_value=None, default=None, error_message=None):\\n- ask_again = True\\n- while ask_again:\\n- result = input(input_text)\\n- try:\\n- if default is not None and len(result) == 0:\\n- return default\\n- return convert_value(result) if convert_value is not None else result\\n- except:\\n- if error_message is not None:\\n- print(error_message)\\n-\\n-\\n-def get_user_input():\\n- def _convert_distributed_mode(value):\\n- value = int(value)\\n- return DistributedType([\\\"NO\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\\n-\\n- def _convert_yes_no_to_bool(value):\\n- return {\\\"yes\\\": True, \\\"no\\\": False}[value.lower()]\\n-\\n- distributed_type = _ask_field(\\n- \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-GPU, [2] TPU): \\\",\\n- _convert_distributed_mode,\\n- error_message=\\\"Please enter 0, 1 or 2.\\\",\\n- )\\n-\\n- machine_rank = 0\\n- num_machines = 1\\n- main_process_ip = None\\n- main_process_port = None\\n- if distributed_type == DistributedType.MULTI_GPU:\\n- num_machines = _ask_field(\\n- \\\"How many different machines will you use (use more than 1 for multi-node training)? [1]: \\\",\\n- lambda x: int(x),\\n- default=1,\\n- )\\n- if num_machines > 1:\\n- machine_rank = _ask_field(\\n- \\\"What is the rank of this machine (from 0 to the number of machines - 1 )? [0]: \\\",\\n- lambda x: int(x),\\n- default=0,\\n- )\\n- main_process_ip = _ask_field(\\n- \\\"What is the IP address of the machine that will host the main process? \\\",\\n- )\\n- main_process_ip = _ask_field(\\n- \\\"What is the port you will use to communicate with the main process? \\\",\\n- lambda x: int(x),\\n- )\\n- if distributed_type == DistributedType.TPU:\\n- main_training_function = _ask_field(\\n- \\\"What is the name of the function in your script that should be launched in all parallel scripts? [main]: \\\",\\n- default=\\\"main\\\",\\n- )\\n- else:\\n- main_training_function = \\\"main\\\"\\n-\\n- num_processes = _ask_field(\\n- \\\"How many processes in total will you use? [1]: \\\",\\n- lambda x: int(x),\\n- default=1,\\n- error_message=\\\"Please enter an integer.\\\",\\n- )\\n-\\n- if distributed_type != DistributedType.TPU:\\n- fp16 = _ask_field(\\n- \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n- _convert_yes_no_to_bool,\\n- default=False,\\n- error_message=\\\"Please enter yes or no.\\\",\\n- )\\n- else:\\n- fp16 = False\\n-\\n- return LaunchConfig(\\n- distributed_type=distributed_type,\\n- num_processes=num_processes,\\n- fp16=fp16,\\n- machine_rank=machine_rank,\\n- num_machines=num_machines,\\n- main_process_ip=main_process_ip,\\n- main_process_port=main_process_port,\\n- main_training_function=main_training_function,\\n- )\\n-\\n-\\n-def config_command(args):\\n- config = get_user_input()\\n- if args.config_file is not None:\\n- config_file = args.config_file\\n- else:\\n- if not os.path.isdir(cache_dir):\\n- os.makedirs(cache_dir)\\n- config_file = default_yaml_config_file\\n-\\n- if config_file.endswith(\\\".json\\\"):\\n- config.to_json_file(config_file)\\n- else:\\n- config.to_yaml_file(config_file)\\n-\\n-\\n-def main():\\n- parser = config_command_parser()\\n- args = parser.parse_args()\\n- config_command(args)\\n-\\n-\\n-if __name__ == \\\"__main__\\\":\\n- main()\\ndiff --git a/src/accelerate/commands/config/__init__.py b/src/accelerate/commands/config/__init__.py\\nnew file mode 100644\\nindex 000000000..48ea96ab1\\n--- /dev/null\\n+++ b/src/accelerate/commands/config/__init__.py\\n@@ -0,0 +1,85 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+\\n+from accelerate.state import ComputeEnvironment\\n+\\n+from .cluster import get_cluster_input\\n+from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401\\n+from .config_utils import _ask_field, _convert_compute_environment\\n+from .sagemaker import get_sagemaker_input\\n+\\n+\\n+def get_user_input():\\n+ compute_environment = _ask_field(\\n+ \\\"In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): \\\",\\n+ _convert_compute_environment,\\n+ error_message=\\\"Please enter 0 or 1\\\",\\n+ )\\n+ if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:\\n+ config = get_sagemaker_input()\\n+ else:\\n+ config = get_cluster_input()\\n+ return config\\n+\\n+\\n+def config_command_parser(subparsers=None):\\n+ if subparsers is not None:\\n+ parser = subparsers.add_parser(\\\"config\\\")\\n+ else:\\n+ parser = argparse.ArgumentParser(\\\"Accelerate config command\\\")\\n+\\n+ parser.add_argument(\\n+ \\\"--config_file\\\",\\n+ default=None,\\n+ help=(\\n+ \\\"The path to use to store the config file. Will default to a file named default_config.json in the cache \\\"\\n+ \\\"location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have \\\"\\n+ \\\"such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed \\\"\\n+ \\\"with 'huggingface'.\\\"\\n+ ),\\n+ )\\n+\\n+ if subparsers is not None:\\n+ parser.set_defaults(func=config_command)\\n+ return parser\\n+\\n+\\n+def config_command(args):\\n+ config = get_user_input()\\n+ if args.config_file is not None:\\n+ config_file = args.config_file\\n+ else:\\n+ if not os.path.isdir(cache_dir):\\n+ os.makedirs(cache_dir)\\n+ config_file = default_yaml_config_file\\n+\\n+ if config_file.endswith(\\\".json\\\"):\\n+ config.to_json_file(config_file)\\n+ else:\\n+ config.to_yaml_file(config_file)\\n+\\n+\\n+def main():\\n+ parser = config_command_parser()\\n+ args = parser.parse_args()\\n+ config_command(args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py\\nnew file mode 100644\\nindex 000000000..a9e412f7d\\n--- /dev/null\\n+++ b/src/accelerate/commands/config/cluster.py\\n@@ -0,0 +1,88 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from accelerate.state import ComputeEnvironment, DistributedType\\n+\\n+from .config_args import ClusterConfig\\n+from .config_utils import _ask_field, _convert_distributed_mode, _convert_yes_no_to_bool\\n+\\n+\\n+def get_cluster_input():\\n+ distributed_type = _ask_field(\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] multi-GPU, [2] TPU): \\\",\\n+ _convert_distributed_mode,\\n+ error_message=\\\"Please enter 0, 1 or 2.\\\",\\n+ )\\n+\\n+ machine_rank = 0\\n+ num_machines = 1\\n+ main_process_ip = None\\n+ main_process_port = None\\n+ if distributed_type == DistributedType.MULTI_GPU:\\n+ num_machines = _ask_field(\\n+ \\\"How many different machines will you use (use more than 1 for multi-node training)? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ )\\n+ if num_machines > 1:\\n+ machine_rank = _ask_field(\\n+ \\\"What is the rank of this machine (from 0 to the number of machines - 1 )? [0]: \\\",\\n+ lambda x: int(x),\\n+ default=0,\\n+ )\\n+ main_process_ip = _ask_field(\\n+ \\\"What is the IP address of the machine that will host the main process? \\\",\\n+ )\\n+ main_process_ip = _ask_field(\\n+ \\\"What is the port you will use to communicate with the main process? \\\",\\n+ lambda x: int(x),\\n+ )\\n+ if distributed_type == DistributedType.TPU:\\n+ main_training_function = _ask_field(\\n+ \\\"What is the name of the function in your script that should be launched in all parallel scripts? [main]: \\\",\\n+ default=\\\"main\\\",\\n+ )\\n+ else:\\n+ main_training_function = \\\"main\\\"\\n+\\n+ num_processes = _ask_field(\\n+ \\\"How many processes in total will you use? [1]: \\\",\\n+ lambda x: int(x),\\n+ default=1,\\n+ error_message=\\\"Please enter an integer.\\\",\\n+ )\\n+\\n+ if distributed_type != DistributedType.TPU:\\n+ fp16 = _ask_field(\\n+ \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+ else:\\n+ fp16 = False\\n+\\n+ return ClusterConfig(\\n+ compute_environment=ComputeEnvironment.LOCAL_MACHINE,\\n+ distributed_type=distributed_type,\\n+ num_processes=num_processes,\\n+ fp16=fp16,\\n+ machine_rank=machine_rank,\\n+ num_machines=num_machines,\\n+ main_process_ip=main_process_ip,\\n+ main_process_port=main_process_port,\\n+ main_training_function=main_training_function,\\n+ )\\ndiff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py\\nnew file mode 100644\\nindex 000000000..5b0dd00ba\\n--- /dev/null\\n+++ b/src/accelerate/commands/config/config_args.py\\n@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from enum import Enum\\n+from typing import Optional, Union\\n+\\n+import yaml\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+hf_cache_home = os.path.expanduser(\\n+ os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n+)\\n+cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n+\\n+\\n+def load_config_from_file(config_file):\\n+ config_file = config_file if config_file is not None else default_config_file\\n+ with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ if config_file.endswith(\\\".json\\\"):\\n+ if json.load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.LOCAL_MACHINE:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_json_file(json_file=config_file)\\n+ else:\\n+ if yaml.safe_load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.LOCAL_MACHINE:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_yaml_file(yaml_file=config_file)\\n+\\n+\\n+@dataclass\\n+class BaseConfig:\\n+ compute_environment: ComputeEnvironment\\n+ distributed_type: Union[DistributedType, SageMakerDistributedType]\\n+ fp16: bool\\n+\\n+ def to_dict(self):\\n+ result = self.__dict__\\n+ # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n+ for key, value in result.items():\\n+ if isinstance(value, Enum):\\n+ result[key] = value.value\\n+ return result\\n+\\n+ @classmethod\\n+ def from_json_file(cls, json_file=None):\\n+ json_file = default_json_config_file if json_file is None else json_file\\n+ with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**json.load(f))\\n+\\n+ def to_json_file(self, json_file):\\n+ with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n+ f.write(content)\\n+\\n+ @classmethod\\n+ def from_yaml_file(cls, yaml_file=None):\\n+ yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n+ with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**yaml.safe_load(f))\\n+\\n+ def to_yaml_file(self, yaml_file):\\n+ with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ yaml.safe_dump(self.to_dict(), f)\\n+\\n+ def __post_init__(self):\\n+ if isinstance(self.compute_environment, str):\\n+ self.compute_environment = ComputeEnvironment(self.compute_environment)\\n+ if isinstance(self.distributed_type, str):\\n+ self.distributed_type = DistributedType(self.distributed_type)\\n+\\n+\\n+@dataclass\\n+class ClusterConfig(BaseConfig):\\n+ num_processes: int\\n+ machine_rank: int = 0\\n+ num_machines: int = 1\\n+ main_process_ip: Optional[str] = None\\n+ main_process_port: Optional[int] = None\\n+ main_training_function: str = \\\"main\\\"\\n+\\n+\\n+@dataclass\\n+class SageMakerConfig(BaseConfig):\\n+ ec2_instance_type: str\\n+ iam_role_name: str\\n+ profile: Optional[str] = None\\n+ region: str = \\\"us-east-1\\\"\\n+ num_machines: int = 1\\n+ base_job_name: str = f\\\"accelerate-sagemaker-{num_machines}\\\"\\n+ pytroch_version: str = \\\"1.6\\\"\\n+ transformers_version: str = \\\"4.4\\\"\\ndiff --git a/src/accelerate/commands/config/config_utils.py b/src/accelerate/commands/config/config_utils.py\\nnew file mode 100644\\nindex 000000000..dd14965f7\\n--- /dev/null\\n+++ b/src/accelerate/commands/config/config_utils.py\\n@@ -0,0 +1,49 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+def _ask_field(input_text, convert_value=None, default=None, error_message=None):\\n+ ask_again = True\\n+ while ask_again:\\n+ result = input(input_text)\\n+ try:\\n+ if default is not None and len(result) == 0:\\n+ return default\\n+ return convert_value(result) if convert_value is not None else result\\n+ except:\\n+ if error_message is not None:\\n+ print(error_message)\\n+\\n+\\n+def _convert_compute_environment(value):\\n+ value = int(value)\\n+ return ComputeEnvironment([\\\"LOCAL_MACHINE\\\", \\\"AMAZON_SAGEMAKER\\\"][value])\\n+\\n+\\n+def _convert_distributed_mode(value):\\n+ value = int(value)\\n+ return DistributedType([\\\"NO\\\", \\\"MULTI_GPU\\\", \\\"TPU\\\"][value])\\n+\\n+\\n+def _convert_sagemaker_distributed_mode(value):\\n+ value = int(value)\\n+ return SageMakerDistributedType([\\\"NO\\\", \\\"DATA_PARALLEL\\\", \\\"MODEL_PARALLEL\\\"][value])\\n+\\n+\\n+def _convert_yes_no_to_bool(value):\\n+ return {\\\"yes\\\": True, \\\"no\\\": False}[value.lower()]\\ndiff --git a/src/accelerate/commands/config/sagemaker.py b/src/accelerate/commands/config/sagemaker.py\\nnew file mode 100644\\nindex 000000000..25fd3e6cb\\n--- /dev/null\\n+++ b/src/accelerate/commands/config/sagemaker.py\\n@@ -0,0 +1,157 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import json\\n+import os\\n+\\n+from accelerate.state import ComputeEnvironment, SageMakerDistributedType\\n+from accelerate.utils import is_boto3_available\\n+\\n+from .config_args import SageMakerConfig\\n+from .config_utils import _ask_field, _convert_sagemaker_distributed_mode, _convert_yes_no_to_bool\\n+\\n+\\n+if is_boto3_available():\\n+ import boto3 # noqa: F401\\n+\\n+\\n+def _create_iam_role_for_sagemaker(role_name):\\n+ iam_client = boto3.client(\\\"iam\\\")\\n+\\n+ sagemaker_trust_policy = {\\n+ \\\"Version\\\": \\\"2012-10-17\\\",\\n+ \\\"Statement\\\": [\\n+ {\\\"Effect\\\": \\\"Allow\\\", \\\"Principal\\\": {\\\"Service\\\": \\\"sagemaker.amazonaws.com\\\"}, \\\"Action\\\": \\\"sts:AssumeRole\\\"}\\n+ ],\\n+ }\\n+ try:\\n+ # create the role, associated with the chosen trust policy\\n+ iam_client.create_role(\\n+ RoleName=role_name, AssumeRolePolicyDocument=json.dumps(sagemaker_trust_policy, indent=2)\\n+ )\\n+ policy_document = {\\n+ \\\"Version\\\": \\\"2012-10-17\\\",\\n+ \\\"Statement\\\": [\\n+ {\\n+ \\\"Effect\\\": \\\"Allow\\\",\\n+ \\\"Action\\\": [\\n+ \\\"sagemaker:*\\\",\\n+ \\\"ecr:GetDownloadUrlForLayer\\\",\\n+ \\\"ecr:BatchGetImage\\\",\\n+ \\\"ecr:BatchCheckLayerAvailability\\\",\\n+ \\\"ecr:GetAuthorizationToken\\\",\\n+ \\\"cloudwatch:PutMetricData\\\",\\n+ \\\"cloudwatch:GetMetricData\\\",\\n+ \\\"cloudwatch:GetMetricStatistics\\\",\\n+ \\\"cloudwatch:ListMetrics\\\",\\n+ \\\"logs:CreateLogGroup\\\",\\n+ \\\"logs:CreateLogStream\\\",\\n+ \\\"logs:DescribeLogStreams\\\",\\n+ \\\"logs:PutLogEvents\\\",\\n+ \\\"logs:GetLogEvents\\\",\\n+ \\\"s3:CreateBucket\\\",\\n+ \\\"s3:ListBucket\\\",\\n+ \\\"s3:GetBucketLocation\\\",\\n+ \\\"s3:GetObject\\\",\\n+ \\\"s3:PutObject\\\",\\n+ ],\\n+ \\\"Resource\\\": \\\"*\\\",\\n+ }\\n+ ],\\n+ }\\n+ # attach policy to role\\n+ iam_client.put_role_policy(\\n+ RoleName=role_name,\\n+ PolicyName=f\\\"{role_name}_policy_permission\\\",\\n+ PolicyDocument=json.dumps(policy_document, indent=2),\\n+ )\\n+ except iam_client.exceptions.EntityAlreadyExistsException:\\n+ print(f\\\"role {role_name} already exists. Using existing one\\\")\\n+\\n+\\n+def _get_iam_role_arn(role_name):\\n+ iam_client = boto3.client(\\\"iam\\\")\\n+ return iam_client.get_role(RoleName=role_name)[\\\"Role\\\"][\\\"Arn\\\"]\\n+\\n+\\n+def get_sagemaker_input():\\n+ credentials_configuration = _ask_field(\\n+ \\\"How do you want to authorize? ([0] AWS Profile, [1] Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)): \\\",\\n+ lambda x: int(x),\\n+ )\\n+ aws_profile = None\\n+ if credentials_configuration == 0:\\n+ aws_profile = _ask_field(\\\"Enter your AWS Profile name: [default] \\\", default=\\\"default\\\")\\n+ os.environ[\\\"AWS_PROFILE\\\"] = aws_profile\\n+ else:\\n+ print(\\n+ \\\"Accelerate will expose AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables on the machine\\\"\\n+ )\\n+ aws_access_key_id = _ask_field(\\\"AWS Access Key ID: \\\")\\n+ os.environ[\\\"AWS_ACCESS_KEY_ID\\\"] = aws_access_key_id\\n+\\n+ aws_secret_access_key = _ask_field(\\\"AWS Secret Access Key: \\\")\\n+ os.environ[\\\"AWS_SECRET_ACCESS_KEY\\\"] = aws_secret_access_key\\n+\\n+ aws_region = _ask_field(\\\"Enter your AWS Region: [us-east-1]\\\", default=\\\"us-east-1\\\")\\n+ os.environ[\\\"AWS_DEFAULT_REGION\\\"] = aws_region\\n+\\n+ role_management = _ask_field(\\n+ \\\"Do you already have an IAM Role for executing Amazon SageMaker Training Jobs? ([0] provide IAM Role name, [1] create new IAM role using credentials: \\\",\\n+ lambda x: int(x),\\n+ )\\n+ if role_management == 0:\\n+ iam_role_name = _ask_field(\\\"Enter your IAM role name: \\\")\\n+ else:\\n+ iam_role_name = \\\"accelerate_sagemaker_execution_role\\\"\\n+ print(f'Accelerate will create an iam role \\\"{iam_role_name}\\\" using the provided credentials')\\n+ _create_iam_role_for_sagemaker(iam_role_name)\\n+\\n+ distributed_type = _ask_field(\\n+ \\\"Which type of machine are you using? ([0] No distributed training, [1] data parallelism, [2] model parallelism): \\\",\\n+ _convert_sagemaker_distributed_mode,\\n+ error_message=\\\"Please enter 0, 1 or 2\\\",\\n+ )\\n+\\n+ # using the best two instances for single-gpu training or multi-gpu -> can turn into question to make it more diverse\\n+ ec2_instance_type = \\\"ml.p3.2xlarge\\\" if distributed_type == SageMakerDistributedType.NO else \\\"ml.p3dn.24xlarge\\\"\\n+ num_machines = 1\\n+ if (\\n+ distributed_type == SageMakerDistributedType.DATA_PARALLEL\\n+ or distributed_type == SageMakerDistributedType.MODEL_PARALLEL\\n+ ):\\n+ raise NotImplementedError(\\\"Model or Data Parallelism is not implemented yet. We are working on it\\\")\\n+ num_machines = _ask_field(\\n+ \\\"How many machines do you want use? [2]: \\\",\\n+ lambda x: int(x),\\n+ default=2,\\n+ )\\n+ fp16 = _ask_field(\\n+ \\\"Do you wish to use FP16 (mixed precision)? [yes/NO]: \\\",\\n+ _convert_yes_no_to_bool,\\n+ default=False,\\n+ error_message=\\\"Please enter yes or no.\\\",\\n+ )\\n+\\n+ return SageMakerConfig(\\n+ compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER,\\n+ distributed_type=distributed_type,\\n+ ec2_instance_type=ec2_instance_type,\\n+ profile=aws_profile,\\n+ region=aws_region,\\n+ iam_role_name=iam_role_name,\\n+ fp16=fp16,\\n+ num_machines=num_machines,\\n+ )\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex 061c289ea..b8e1e8156 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -23,8 +23,8 @@\\n from pathlib import Path\\n from typing import Optional\\n \\n-from accelerate.commands.config import LaunchConfig, default_config_file\\n-from accelerate.state import DistributedType\\n+from accelerate.commands.config import default_config_file, load_config_from_file\\n+from accelerate.state import ComputeEnvironment, DistributedType\\n \\n \\n class _AddOneArg:\\n@@ -171,6 +171,12 @@ def tpu_launcher(args):\\n xmp.spawn(main_function, args=(), nprocs=args.num_processes)\\n \\n \\n+def sagemaker_launcher(sagemaker_config, args):\\n+ raise NotImplementedError(\\n+ \\\"Support for starting SageMaker training is not yet implemented. But you can create configs for it.\\\"\\n+ )\\n+\\n+\\n def launch_command(args):\\n # Sanity checks\\n if args.multi_gpu and args.tpu:\\n@@ -178,15 +184,15 @@ def launch_command(args):\\n \\n # Get the default from the config file.\\n if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n- defaults = LaunchConfig.from_json_file(json_file=args.config_file)\\n+ defaults = load_config_from_file(args.config_file)\\n if not args.multi_gpu and not args.tpu:\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n args.tpu = defaults.distributed_type == DistributedType.TPU\\n- if args.num_processes is None:\\n+ if args.num_processes is None and defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n args.num_processes = defaults.num_processes\\n if not args.fp16:\\n args.fp16 = defaults.fp16\\n- if args.main_training_function is None:\\n+ if args.main_training_function is None and defaults.compute_environment == ComputeEnvironment.LOCAL_MACHINE:\\n args.main_training_function = defaults.main_training_function\\n else:\\n if args.num_processes is None:\\n@@ -197,6 +203,8 @@ def launch_command(args):\\n multi_gpu_launcher(args)\\n elif args.tpu and not args.cpu:\\n tpu_launcher(args)\\n+ elif defaults.compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:\\n+ sagemaker_launcher(defaults, args)\\n else:\\n simple_launcher(args)\\n \\ndiff --git a/src/accelerate/state.py b/src/accelerate/state.py\\nindex 5f150add9..55831be0f 100644\\n--- a/src/accelerate/state.py\\n+++ b/src/accelerate/state.py\\n@@ -53,6 +53,38 @@ class DistributedType(str, Enum):\\n TPU = \\\"TPU\\\"\\n \\n \\n+class SageMakerDistributedType(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of distributed environment.\\n+\\n+ Values:\\n+\\n+ - **NO** -- Not a distributed environment, just a single process.\\n+ - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.\\n+ - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.\\n+ NO = \\\"NO\\\"\\n+ DATA_PARALLEL = \\\"DATA_PARALLEL\\\"\\n+ MODEL_PARALLEL = \\\"MODEL_PARALLEL\\\"\\n+\\n+\\n+class ComputeEnvironment(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of the compute environment.\\n+\\n+ Values:\\n+\\n+ - **LOCAL_MACHINE** -- private/custom cluster hardware.\\n+ - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.\\n+ LOCAL_MACHINE = \\\"LOCAL_MACHINE\\\"\\n+ AMAZON_SAGEMAKER = \\\"AMAZON_SAGEMAKER\\\"\\n+\\n+\\n # Inspired by Alex Martelli's 'Borg'.\\n class AcceleratorState:\\n \\\"\\\"\\\"\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 61a39fc95..ca2d558b0 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -12,6 +12,7 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+import importlib\\n import random\\n from enum import Enum\\n from typing import List, Optional, Union\\n@@ -26,6 +27,10 @@\\n import torch_xla.core.xla_model as xm\\n \\n \\n+def is_boto3_available():\\n+ return importlib.util.find_spec(\\\"boto3\\\") is not None\\n+\\n+\\n class RNGType(Enum):\\n TORCH = \\\"torch\\\"\\n CUDA = \\\"cuda\\\"\\n\",\n \"code_comments\": [\n {\n \"body\": \"decoupled input gathering from main config `get_user_input()` into the separate options\",\n \"diff_hunk\": \"@@ -0,0 +1,88 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+from accelerate.state import ComputeEnvironment, DistributedType\\n+\\n+from .config_args import ClusterConfig\\n+from .config_utils import _ask_field, _convert_distributed_mode, _convert_yes_no_to_bool\\n+\\n+\\n+def get_cluster_input():\",\n \"from_author\": true\n },\n {\n \"body\": \"Determines which config flow should be used. \",\n \"diff_hunk\": \"@@ -0,0 +1,85 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+\\n+from accelerate.state import ComputeEnvironment\\n+\\n+from .cluster import get_cluster_input\\n+from .config_args import cache_dir, default_yaml_config_file\\n+from .config_utils import _ask_field, _convert_compute_environment\\n+from .sagemaker import get_sagemaker_input\\n+\\n+\\n+def get_user_input():\\n+ compute_environment = _ask_field(\",\n \"from_author\": true\n },\n {\n \"body\": \"create a separate file to merge all configuration `dataclasses`. We can also think about moving them so `state.py`\",\n \"diff_hunk\": \"@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\",\n \"from_author\": true\n },\n {\n \"body\": \"general loading function for determining if config file is `json` or `yaml` and which configuration is used for loading. Open for suggestions on how to identify the `config_class` easier. \",\n \"diff_hunk\": \"@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from enum import Enum\\n+from typing import Optional, Union\\n+\\n+import yaml\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+hf_cache_home = os.path.expanduser(\\n+ os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n+)\\n+cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n+\\n+\\n+def load_config_from_file(config_file):\",\n \"from_author\": true\n },\n {\n \"body\": \"base class contains overlapping properties and methods. \",\n \"diff_hunk\": \"@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from enum import Enum\\n+from typing import Optional, Union\\n+\\n+import yaml\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+hf_cache_home = os.path.expanduser(\\n+ os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n+)\\n+cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n+\\n+\\n+def load_config_from_file(config_file):\\n+ config_file = config_file if config_file is not None else default_config_file\\n+ with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ if config_file.endswith(\\\".json\\\"):\\n+ if json.load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_json_file(json_file=config_file)\\n+ else:\\n+ if yaml.safe_load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_yaml_file(yaml_file=config_file)\\n+\\n+\\n+@dataclass\\n+class BaseConfig:\",\n \"from_author\": true\n },\n {\n \"body\": \"kept `num_machines` in specialist class due to `dataclass` -> `Dataclass fields without default value cannot appear after data fields with default values`. \",\n \"diff_hunk\": \"@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from enum import Enum\\n+from typing import Optional, Union\\n+\\n+import yaml\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+hf_cache_home = os.path.expanduser(\\n+ os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n+)\\n+cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n+\\n+\\n+def load_config_from_file(config_file):\\n+ config_file = config_file if config_file is not None else default_config_file\\n+ with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ if config_file.endswith(\\\".json\\\"):\\n+ if json.load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_json_file(json_file=config_file)\\n+ else:\\n+ if yaml.safe_load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_yaml_file(yaml_file=config_file)\\n+\\n+\\n+@dataclass\\n+class BaseConfig:\\n+ compute_environment: ComputeEnvironment\\n+ distributed_type: Union[DistributedType, SageMakerDistributedType]\\n+ fp16: bool\\n+\\n+ def to_dict(self):\\n+ result = self.__dict__\\n+ # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n+ for key, value in result.items():\\n+ if isinstance(value, Enum):\\n+ result[key] = value.value\\n+ return result\\n+\\n+ @classmethod\\n+ def from_json_file(cls, json_file=None):\\n+ json_file = default_json_config_file if json_file is None else json_file\\n+ with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**json.load(f))\\n+\\n+ def to_json_file(self, json_file):\\n+ with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n+ f.write(content)\\n+\\n+ @classmethod\\n+ def from_yaml_file(cls, yaml_file=None):\\n+ yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n+ with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**yaml.safe_load(f))\\n+\\n+ def to_yaml_file(self, yaml_file):\\n+ with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ yaml.safe_dump(self.to_dict(), f)\\n+\\n+ def __post_init__(self):\\n+ if isinstance(self.distributed_type, str):\\n+ self.compute_environment = ComputeEnvironment(self.compute_environment)\\n+ if isinstance(self.distributed_type, str):\\n+ self.distributed_type = DistributedType(self.distributed_type)\\n+\\n+\\n+@dataclass\\n+class ClusterConfig(BaseConfig):\\n+ num_processes: int\\n+ machine_rank: int = 0\\n+ num_machines: int = 1\",\n \"from_author\": true\n },\n {\n \"body\": \"open for better naming\",\n \"diff_hunk\": \"@@ -53,6 +53,38 @@ class DistributedType(str, Enum):\\n TPU = \\\"TPU\\\"\\n \\n \\n+class SageMakerDistributedType(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of distributed environment.\\n+\\n+ Values:\\n+\\n+ - **NO** -- Not a distributed environment, just a single process.\\n+ - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.\\n+ - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.\\n+ NO = \\\"NO\\\"\\n+ DATA_PARALLEL = \\\"DATA_PARALLEL\\\"\\n+ MODEL_PARALLEL = \\\"MODEL_PARALLEL\\\"\\n+\\n+\\n+class ComputeEnvironment(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of the compute environment.\\n+\\n+ Values:\\n+\\n+ - **CUSTOM_CLUSTER** -- private/custom cluster hardware.\\n+ - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.\\n+ CUSTOM_CLUSTER = \\\"CUSTOM_CLUSTER\\\"\",\n \"from_author\": true\n },\n {\n \"body\": \"This is a bit weird so would remove one .config by adding `config_command_parser` in the intermediate init.\",\n \"diff_hunk\": \"@@ -16,7 +16,7 @@\\n \\n from argparse import ArgumentParser\\n \\n-from accelerate.commands.config import config_command_parser\\n+from accelerate.commands.config.config import config_command_parser\",\n \"from_author\": false\n },\n {\n \"body\": \"Custom Cluster does sound a bit too complicated for the base config.\\r\\n```suggestion\\r\\n \\\"In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): \\\",\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,85 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import argparse\\n+import os\\n+\\n+from accelerate.state import ComputeEnvironment\\n+\\n+from .cluster import get_cluster_input\\n+from .config_args import cache_dir, default_yaml_config_file\\n+from .config_utils import _ask_field, _convert_compute_environment\\n+from .sagemaker import get_sagemaker_input\\n+\\n+\\n+def get_user_input():\\n+ compute_environment = _ask_field(\\n+ \\\"In which compute environment are you running? ([0] Custom Cluster, [1] AWS (Amazon SageMaker)): \\\",\",\n \"from_author\": false\n },\n {\n \"body\": \"```suggestion\\r\\n if isinstance(self.compute_environment, str):\\r\\n```\",\n \"diff_hunk\": \"@@ -0,0 +1,119 @@\\n+#!/usr/bin/env python\\n+\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import json\\n+import os\\n+from dataclasses import dataclass\\n+from enum import Enum\\n+from typing import Optional, Union\\n+\\n+import yaml\\n+from accelerate.state import ComputeEnvironment, DistributedType, SageMakerDistributedType\\n+\\n+\\n+hf_cache_home = os.path.expanduser(\\n+ os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n+)\\n+cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n+\\n+\\n+def load_config_from_file(config_file):\\n+ config_file = config_file if config_file is not None else default_config_file\\n+ with open(config_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ if config_file.endswith(\\\".json\\\"):\\n+ if json.load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_json_file(json_file=config_file)\\n+ else:\\n+ if yaml.safe_load(f)[\\\"compute_environment\\\"] == ComputeEnvironment.CUSTOM_CLUSTER:\\n+ config_class = ClusterConfig\\n+ else:\\n+ config_class = SageMakerConfig\\n+ return config_class.from_yaml_file(yaml_file=config_file)\\n+\\n+\\n+@dataclass\\n+class BaseConfig:\\n+ compute_environment: ComputeEnvironment\\n+ distributed_type: Union[DistributedType, SageMakerDistributedType]\\n+ fp16: bool\\n+\\n+ def to_dict(self):\\n+ result = self.__dict__\\n+ # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n+ for key, value in result.items():\\n+ if isinstance(value, Enum):\\n+ result[key] = value.value\\n+ return result\\n+\\n+ @classmethod\\n+ def from_json_file(cls, json_file=None):\\n+ json_file = default_json_config_file if json_file is None else json_file\\n+ with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**json.load(f))\\n+\\n+ def to_json_file(self, json_file):\\n+ with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n+ f.write(content)\\n+\\n+ @classmethod\\n+ def from_yaml_file(cls, yaml_file=None):\\n+ yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n+ with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**yaml.safe_load(f))\\n+\\n+ def to_yaml_file(self, yaml_file):\\n+ with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ yaml.safe_dump(self.to_dict(), f)\\n+\\n+ def __post_init__(self):\\n+ if isinstance(self.distributed_type, str):\",\n \"from_author\": false\n },\n {\n \"body\": \"Would also put those two functions in the intermediate init `accelerate.commands.config.__init__.py`\",\n \"diff_hunk\": \"@@ -23,8 +23,8 @@\\n from pathlib import Path\\n from typing import Optional\\n \\n-from accelerate.commands.config import LaunchConfig, default_config_file\\n-from accelerate.state import DistributedType\\n+from accelerate.commands.config.config_args import default_config_file, load_config_from_file\",\n \"from_author\": false\n },\n {\n \"body\": \"I think `LOCAL_MACHINE` is better.\",\n \"diff_hunk\": \"@@ -53,6 +53,38 @@ class DistributedType(str, Enum):\\n TPU = \\\"TPU\\\"\\n \\n \\n+class SageMakerDistributedType(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of distributed environment.\\n+\\n+ Values:\\n+\\n+ - **NO** -- Not a distributed environment, just a single process.\\n+ - **DATA_PARALLEL** -- using sagemaker distributed data parallelism.\\n+ - **MODEL_PARALLEL** -- using sagemaker distributed model parallelism.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.\\n+ NO = \\\"NO\\\"\\n+ DATA_PARALLEL = \\\"DATA_PARALLEL\\\"\\n+ MODEL_PARALLEL = \\\"MODEL_PARALLEL\\\"\\n+\\n+\\n+class ComputeEnvironment(str, Enum):\\n+ \\\"\\\"\\\"\\n+ Represents a type of the compute environment.\\n+\\n+ Values:\\n+\\n+ - **CUSTOM_CLUSTER** -- private/custom cluster hardware.\\n+ - **AMAZON_SAGEMAKER** -- Amazon SageMaker as compute environment.\\n+ \\\"\\\"\\\"\\n+\\n+ # Subclassing str as well as Enum allows the `ComputeEnvironment` to be JSON-serializable out of the box.\\n+ CUSTOM_CLUSTER = \\\"CUSTOM_CLUSTER\\\"\",\n \"from_author\": false\n },\n {\n \"body\": \"Would define a public `is_boto3_available()` function instead of a private variable.\",\n \"diff_hunk\": \"@@ -25,6 +26,8 @@\\n if is_tpu_available():\\n import torch_xla.core.xla_model as xm\\n \\n+_has_boto3 = importlib.util.find_spec(\\\"boto3\\\") is not None\\n+\",\n \"from_author\": false\n },\n {\n \"body\": \"I think we can add an extra \\\"sagemaker\\\" with boto3 inside.\",\n \"diff_hunk\": \"@@ -17,8 +17,17 @@\\n \\n extras = {}\\n extras[\\\"quality\\\"] = [\\\"black >= 20.8b1\\\", \\\"isort >= 5.5.4\\\", \\\"flake8 >= 3.8.3\\\"]\\n-extras[\\\"docs\\\"] = [\\\"recommonmark\\\", \\\"sphinx==3.2.1\\\", \\\"sphinx-markdown-tables\\\", \\\"sphinx-rtd-theme==0.4.3\\\", \\\"sphinx-copybutton\\\"]\\n-\\n+extras[\\\"docs\\\"] = [\\n+ \\\"recommonmark\\\",\\n+ \\\"sphinx==3.2.1\\\",\\n+ \\\"sphinx-markdown-tables\\\",\\n+ \\\"sphinx-rtd-theme==0.4.3\\\",\\n+ \\\"sphinx-copybutton\\\",\\n+]\\n+extras[\\\"test\\\"] = [\\n+ \\\"pytest\\\",\\n+ \\\"pytest-xdist\\\",\\n+]\\n setup(\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"I canΒ΄t reproduce why `quality` is failing. I created a complete new conda env with the same packages. \",\n \"from_author\": true\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/17\",\n \"pr_id\": 601085053\n },\n {\n \"diff\": \"diff --git a/src/accelerate/commands/config.py b/src/accelerate/commands/config.py\\nindex e6b5582a8..c32905932 100644\\n--- a/src/accelerate/commands/config.py\\n+++ b/src/accelerate/commands/config.py\\n@@ -18,8 +18,10 @@\\n import json\\n import os\\n from dataclasses import dataclass\\n+from enum import Enum\\n from typing import Optional\\n \\n+import yaml\\n from accelerate.state import DistributedType\\n \\n \\n@@ -27,7 +29,14 @@\\n os.getenv(\\\"HF_HOME\\\", os.path.join(os.getenv(\\\"XDG_CACHE_HOME\\\", \\\"~/.cache\\\"), \\\"huggingface\\\"))\\n )\\n cache_dir = os.path.join(hf_cache_home, \\\"accelerate\\\")\\n-default_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_json_config_file = os.path.join(cache_dir, \\\"default_config.json\\\")\\n+default_yaml_config_file = os.path.join(cache_dir, \\\"default_config.yaml\\\")\\n+\\n+# For backward compatibility: the default config is the json one if it's the only existing file.\\n+if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):\\n+ default_config_file = default_yaml_config_file\\n+else:\\n+ default_config_file = default_json_config_file\\n \\n \\n @dataclass\\n@@ -41,17 +50,39 @@ class LaunchConfig:\\n main_process_port: Optional[int] = None\\n main_training_function: str = \\\"main\\\"\\n \\n+ def __post_init__(self):\\n+ if isinstance(self.distributed_type, str):\\n+ self.distributed_type = DistributedType(self.distributed_type)\\n+\\n+ def to_dict(self):\\n+ result = self.__dict__\\n+ # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n+ for key, value in result.items():\\n+ if isinstance(value, Enum):\\n+ result[key] = value.value\\n+ return result\\n+\\n @classmethod\\n def from_json_file(cls, json_file=None):\\n- json_file = default_config_file if json_file is None else json_file\\n+ json_file = default_json_config_file if json_file is None else json_file\\n with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return cls(**json.load(f))\\n \\n def to_json_file(self, json_file):\\n with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n- content = json.dumps(self.__dict__, indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n+ content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n f.write(content)\\n \\n+ @classmethod\\n+ def from_yaml_file(cls, yaml_file=None):\\n+ yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n+ with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**yaml.safe_load(f))\\n+\\n+ def to_yaml_file(self, yaml_file):\\n+ with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ yaml.safe_dump(self.to_dict(), f)\\n+\\n \\n def config_command_parser(subparsers=None):\\n if subparsers is not None:\\n@@ -169,9 +200,12 @@ def config_command(args):\\n else:\\n if not os.path.isdir(cache_dir):\\n os.makedirs(cache_dir)\\n- config_file = default_config_file\\n+ config_file = default_yaml_config_file\\n \\n- config.to_json_file(config_file)\\n+ if config_file.endswith(\\\".json\\\"):\\n+ config.to_json_file(config_file)\\n+ else:\\n+ config.to_yaml_file(config_file)\\n \\n \\n def main():\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n yaml.safe_dump(self.to_dict(), f)\\r\\n```\\r\\n\\r\\n> safe_dump(data, stream=None) serializes the given Python object into the stream. If stream is None, it returns the produced stream. safe_dump produces only standard YAML tags and cannot represent an arbitrary Python object.\",\n \"diff_hunk\": \"@@ -41,17 +50,39 @@ class LaunchConfig:\\n main_process_port: Optional[int] = None\\n main_training_function: str = \\\"main\\\"\\n \\n+ def __post_init__(self):\\n+ if isinstance(self.distributed_type, str):\\n+ self.distributed_type = DistributedType(self.distributed_type)\\n+\\n+ def to_dict(self):\\n+ result = self.__dict__\\n+ # For serialization, it's best to convert Enums to strings (or their underlying value type).\\n+ for key, value in result.items():\\n+ if isinstance(value, Enum):\\n+ result[key] = value.value\\n+ return result\\n+\\n @classmethod\\n def from_json_file(cls, json_file=None):\\n- json_file = default_config_file if json_file is None else json_file\\n+ json_file = default_json_config_file if json_file is None else json_file\\n with open(json_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n return cls(**json.load(f))\\n \\n def to_json_file(self, json_file):\\n with open(json_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n- content = json.dumps(self.__dict__, indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n+ content = json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\\n f.write(content)\\n \\n+ @classmethod\\n+ def from_yaml_file(cls, yaml_file=None):\\n+ yaml_file = default_yaml_config_file if yaml_file is None else yaml_file\\n+ with open(yaml_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n+ return cls(**yaml.safe_load(f))\\n+\\n+ def to_yaml_file(self, yaml_file):\\n+ with open(yaml_file, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n+ yaml.dump(self.to_dict(), f)\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/16\",\n \"pr_id\": 599807671\n },\n {\n \"diff\": \"diff --git a/docs/source/index.rst b/docs/source/index.rst\\nindex 065329a1d..57933888d 100644\\n--- a/docs/source/index.rst\\n+++ b/docs/source/index.rst\\n@@ -145,4 +145,5 @@ Supported integrations\\n :caption: API reference\\n \\n accelerator\\n+ kwargs\\n internal\\ndiff --git a/docs/source/kwargs.rst b/docs/source/kwargs.rst\\nnew file mode 100644\\nindex 000000000..61f42cd11\\n--- /dev/null\\n+++ b/docs/source/kwargs.rst\\n@@ -0,0 +1,30 @@\\n+.. \\n+ Copyright 2021 The HuggingFace Team. All rights reserved.\\n+\\n+ Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); you may not use this file except in compliance with\\n+ the License. You may obtain a copy of the License at\\n+\\n+ http://www.apache.org/licenses/LICENSE-2.0\\n+\\n+ Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\\n+ an \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\\n+ specific language governing permissions and limitations under the License.\\n+\\n+\\n+Kwargs Handlers\\n+=======================================================================================================================\\n+\\n+The following objects can be passed to the main :class:`~accelerate.Accelerator` to customize how some PyTorch objects\\n+related to distributed training or mixed precision are created.\\n+\\n+\\n+DistributedDataParallelKwargs\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+.. autoclass:: accelerate.DistributedDataParallelKwargs\\n+\\n+\\n+GradScalerKwargs\\n+-----------------------------------------------------------------------------------------------------------------------\\n+\\n+.. autoclass:: accelerate.GradScalerKwargs\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nindex 862fbce15..f4164613f 100644\\n--- a/examples/cv_example.py\\n+++ b/examples/cv_example.py\\n@@ -22,7 +22,6 @@\\n from torch.utils.data import DataLoader, Dataset\\n \\n import PIL\\n-import torchvision\\n from accelerate import Accelerator\\n from timm import create_model\\n from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 13333c4a4..aad2b8b65 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -14,6 +14,7 @@\\n # limitations under the License.\\n import argparse\\n \\n+import torch\\n from torch.utils.data import DataLoader\\n \\n from accelerate import Accelerator, DistributedType\\ndiff --git a/src/accelerate/__init__.py b/src/accelerate/__init__.py\\nindex 1cc471903..da4f7402e 100644\\n--- a/src/accelerate/__init__.py\\n+++ b/src/accelerate/__init__.py\\n@@ -5,5 +5,6 @@\\n __version__ = \\\"0.1.0\\\"\\n \\n from .accelerator import Accelerator\\n+from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs\\n from .state import DistributedType\\n from .utils import synchronize_rng_states\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 4707e0afe..d9f7cf1bc 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -19,6 +19,7 @@\\n from packaging import version\\n \\n from .data_loader import prepare_data_loader\\n+from .kwargs_handlers import DistributedDataParallelKwargs, GradScalerKwargs, KwargsHandler\\n from .optimizer import AcceleratedOptimizer\\n from .state import AcceleratorState, DistributedType\\n from .utils import RNGType, extract_model_from_parallel, gather, save, wait_for_everyone\\n@@ -56,6 +57,9 @@ class Accelerator:\\n \\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n+ kwargs_handlers (list of kwargs handlers, `optional`)\\n+ A list of :obj:`KwargHandler` to customize how the objects related to distributed training or mixed\\n+ precision are created. See :doc:`kwargs` for more information.\\n \\n Attributes\\n \\n@@ -70,18 +74,37 @@ def __init__(\\n fp16: bool = None,\\n cpu: bool = False,\\n rng_types: Optional[List[Union[str, RNGType]]] = None,\\n+ kwargs_handlers: Optional[List[KwargsHandler]] = None,\\n ):\\n self.state = AcceleratorState(fp16=fp16, cpu=cpu, _from_accelerator=True)\\n \\n self.device_placement = device_placement\\n self.split_batches = split_batches\\n \\n+ # Kwargs handlers\\n+ self.ddp_handler = None\\n+ self.scaler_handler = None\\n+ if kwargs_handlers is not None:\\n+ for handler in kwargs_handlers:\\n+ assert isinstance(handler, KwargsHandler), f\\\"Unsupported kwargs handler passed: {handler}.\\\"\\n+ if isinstance(handler, DistributedDataParallelKwargs):\\n+ if self.ddp_handler is not None:\\n+ raise ValueError(\\\"You can only pass one `DistributedDataParallelKwargs` in `kwargs_handler`.\\\")\\n+ else:\\n+ self.ddp_handler = handler\\n+ elif isinstance(handler, GradScalerKwargs):\\n+ if self.scaler_handler is not None:\\n+ raise ValueError(\\\"You can only pass one `GradScalerKwargs` in `kwargs_handler`.\\\")\\n+ else:\\n+ self.scaler_handler = handler\\n+\\n # Mixed precision attributes\\n self.scaler = None\\n self.native_amp = False\\n if self.state.use_fp16:\\n self.native_amp = version.parse(torch.__version__) >= version.parse(\\\"1.6\\\")\\n- self.scaler = torch.cuda.amp.GradScaler()\\n+ kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}\\n+ self.scaler = torch.cuda.amp.GradScaler(**kwargs)\\n \\n # Internal references to the training objects\\n self._optimizers = []\\n@@ -187,16 +210,18 @@ def prepare(self, *args):\\n if isinstance(obj, torch.optim.Optimizer):\\n obj._switch_parameters(mapping)\\n \\n- return result\\n+ return result if len(result) > 1 else result[0]\\n \\n def prepare_model(self, model):\\n if self.device_placement:\\n model = model.to(self.device)\\n if self.distributed_type == DistributedType.MULTI_GPU:\\n+ kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}\\n model = torch.nn.parallel.DistributedDataParallel(\\n model,\\n device_ids=[self.local_process_index],\\n output_device=self.local_process_index,\\n+ **kwargs,\\n )\\n if self.native_amp:\\n model.forward = torch.cuda.amp.autocast()(model.forward)\\ndiff --git a/src/accelerate/kwargs_handlers.py b/src/accelerate/kwargs_handlers.py\\nnew file mode 100644\\nindex 000000000..7f52d6639\\n--- /dev/null\\n+++ b/src/accelerate/kwargs_handlers.py\\n@@ -0,0 +1,73 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import copy\\n+from dataclasses import dataclass\\n+\\n+\\n+class KwargsHandler:\\n+ \\\"\\\"\\\"\\n+ Internal mixin that implements a :obj:`to_kwargs()` method for a dataclass.\\n+ \\\"\\\"\\\"\\n+\\n+ def to_dict(self):\\n+ return copy.deepcopy(self.__dict__)\\n+\\n+ def to_kwargs(self):\\n+ \\\"\\\"\\\"\\n+ Returns a dictionary containing the attributes with values different from the default of this class.\\n+ \\\"\\\"\\\"\\n+ default_dict = self.__class__().to_dict()\\n+ this_dict = self.to_dict()\\n+ return {k: v for k, v in this_dict.items() if default_dict[k] != v}\\n+\\n+\\n+@dataclass\\n+class DistributedDataParallelKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your :class:`~accelerate.Accelerator` to customize how your model is wrapped in a\\n+ :obj:`torch.nn.parallel.DistributedDataParallel`. Please refer to the documentation of this `wrapper\\n+ <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__ for more information\\n+ on each argument.\\n+\\n+ .. warning::\\n+\\n+ :obj:`gradient_as_bucket_view` is only available in PyTorch 1.7.0 and later versions.\\n+ \\\"\\\"\\\"\\n+\\n+ dim: int = 0\\n+ broadcast_buffers: bool = True\\n+ bucket_cap_mb: int = 25\\n+ find_unused_parameters: bool = False\\n+ check_reduction: bool = False\\n+ gradient_as_bucket_view: bool = False\\n+\\n+\\n+@dataclass\\n+class GradScalerKwargs(KwargsHandler):\\n+ \\\"\\\"\\\"\\n+ Use this object in your :class:`~accelerate.Accelerator` to customize the behavior of mixed precision, specifically\\n+ how the :obj:`torch.cuda.amp.GradScaler` used is created. Please refer to the documentation of this `scaler\\n+ <https://pytorch.org/docs/stable/amp.html?highlight=gradscaler>`__ for more information on each argument.\\n+\\n+ .. warning::\\n+\\n+ :obj:`GradScaler` is only available in PyTorch 1.5.0 and later versions.\\n+ \\\"\\\"\\\"\\n+\\n+ init_scale: float = 65536.0\\n+ growth_factor: float = 2.0\\n+ backoff_factor: float = 0.5\\n+ growth_interval: int = 2000\\n+ enabled: bool = True\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex a8b95d2d2..55d00ab5d 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -64,7 +64,7 @@ def param_groups(self):\\n return self.optimizer.param_groups\\n \\n @param_groups.setter\\n- def param_group(self, param_groups):\\n+ def param_groups(self, param_groups):\\n self.optimizer.param_groups = param_groups\\n \\n @property\\n@@ -72,7 +72,7 @@ def defaults(self):\\n return self.optimizer.defaults\\n \\n @defaults.setter\\n- def param_group(self, defaults):\\n+ def defaults(self, defaults):\\n self.optimizer.defaults = defaults\\n \\n def add_param_group(self, param_group):\\ndiff --git a/src/accelerate/test_utils/__init__.py b/src/accelerate/test_utils/__init__.py\\nindex bb9f0f66e..03aef45b3 100644\\n--- a/src/accelerate/test_utils/__init__.py\\n+++ b/src/accelerate/test_utils/__init__.py\\n@@ -2,5 +2,5 @@\\n # There's no way to ignore \\\"F401 '...' imported but unused\\\" warnings in this\\n # module, but to preserve other warnings. So, don't check this module at all.\\n \\n-from .testing import are_the_same_tensors, execute_subprocess_async, require_multi_gpu, require_tpu\\n+from .testing import are_the_same_tensors, execute_subprocess_async, require_cuda, require_multi_gpu, require_tpu\\n from .training import RegressionDataset, RegressionModel\\ndiff --git a/src/accelerate/test_utils/testing.py b/src/accelerate/test_utils/testing.py\\nindex d01b5276e..507f16eb8 100644\\n--- a/src/accelerate/test_utils/testing.py\\n+++ b/src/accelerate/test_utils/testing.py\\n@@ -33,10 +33,19 @@ def are_the_same_tensors(tensor):\\n return True\\n \\n \\n+def require_cuda(test_case):\\n+ \\\"\\\"\\\"\\n+ Decorator marking a test that requires CUDA. These tests are skipped when there are no GPU available.\\n+ \\\"\\\"\\\"\\n+ if not torch.cuda.is_available():\\n+ return unittest.skip(\\\"test requires a GPU\\\")(test_case)\\n+ else:\\n+ return test_case\\n+\\n+\\n def require_tpu(test_case):\\n \\\"\\\"\\\"\\n Decorator marking a test that requires TPUs. These tests are skipped when there are no TPUs available.\\n-\\n \\\"\\\"\\\"\\n if not is_tpu_available():\\n return unittest.skip(\\\"test requires TPU\\\")(test_case)\\ndiff --git a/tests/test_kwargs_handlers.py b/tests/test_kwargs_handlers.py\\nnew file mode 100644\\nindex 000000000..aaf15de0c\\n--- /dev/null\\n+++ b/tests/test_kwargs_handlers.py\\n@@ -0,0 +1,96 @@\\n+# Copyright 2021 The HuggingFace Team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+\\n+import inspect\\n+import os\\n+import sys\\n+import unittest\\n+from dataclasses import dataclass\\n+\\n+import torch\\n+\\n+from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs\\n+from accelerate.kwargs_handlers import KwargsHandler\\n+from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu\\n+\\n+\\n+@dataclass\\n+class MockClass(KwargsHandler):\\n+ a: int = 0\\n+ b: bool = False\\n+ c: float = 3.0\\n+\\n+\\n+class DataLoaderTester(unittest.TestCase):\\n+ def test_kwargs_handler(self):\\n+ # If no defaults are changed, `to_kwargs` returns an empty dict.\\n+ self.assertDictEqual(MockClass().to_kwargs(), {})\\n+ self.assertDictEqual(MockClass(a=2).to_kwargs(), {\\\"a\\\": 2})\\n+ self.assertDictEqual(MockClass(a=2, b=True).to_kwargs(), {\\\"a\\\": 2, \\\"b\\\": True})\\n+ self.assertDictEqual(MockClass(a=2, c=2.25).to_kwargs(), {\\\"a\\\": 2, \\\"c\\\": 2.25})\\n+\\n+ @require_cuda\\n+ def test_grad_scaler_kwargs(self):\\n+ # If no defaults are changed, `to_kwargs` returns an empty dict.\\n+ scaler_handler = GradScalerKwargs(init_scale=1024, growth_factor=2)\\n+ accelerator = Accelerator(fp16=True, kwargs_handlers=[scaler_handler])\\n+ print(accelerator.use_fp16)\\n+ scaler = accelerator.scaler\\n+\\n+ # Check the kwargs have been applied\\n+ self.assertEqual(scaler._init_scale, 1024.0)\\n+ self.assertEqual(scaler._growth_factor, 2.0)\\n+\\n+ # Check the other values are at the default\\n+ self.assertEqual(scaler._backoff_factor, 0.5)\\n+ self.assertEqual(scaler._growth_interval, 2000)\\n+ self.assertEqual(scaler._enabled, True)\\n+\\n+ @require_multi_gpu\\n+ def test_ddp_kwargs(self):\\n+ distributed_args = f\\\"\\\"\\\"\\n+ -m torch.distributed.launch\\n+ --nproc_per_node={torch.cuda.device_count()}\\n+ --use_env\\n+ {inspect.getfile(self.__class__)}\\n+ \\\"\\\"\\\".split()\\n+ cmd = [sys.executable] + distributed_args\\n+ execute_subprocess_async(cmd, env=os.environ.copy())\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ ddp_scaler = DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True)\\n+ accelerator = Accelerator(kwargs_handlers=[ddp_scaler])\\n+ model = torch.nn.Linear(100, 200)\\n+ model = accelerator.prepare(model)\\n+\\n+ # Check the values changed in kwargs\\n+ error_msg = \\\"\\\"\\n+ observed_bucket_cap_map = model.bucket_bytes_cap // (1024 * 1024)\\n+ if observed_bucket_cap_map != 15:\\n+ error_msg += f\\\"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\\\\n\\\"\\n+ if model.find_unused_parameters is not True:\\n+ error_msg += f\\\"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\\\\n\\\"\\n+\\n+ # Check the values of the defaults\\n+ if model.dim != 0:\\n+ error_msg += f\\\"Default value not respected, should have `0` but found {model.dim}.\\\\n\\\"\\n+ if model.broadcast_buffers is not True:\\n+ error_msg += f\\\"Default value not respected, should have `True` but found {model.broadcast_buffers}.\\\\n\\\"\\n+ if model.gradient_as_bucket_view is not False:\\n+ error_msg += f\\\"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\\\\n\\\"\\n+\\n+ # Raise error at the end to make sure we don't stop at the first failure.\\n+ if len(error_msg) > 0:\\n+ raise ValueError(error_msg)\\n\",\n \"code_comments\": [\n {\n \"body\": \"Unrelated to this PR, this is to make quality pass.\",\n \"diff_hunk\": \"@@ -22,7 +22,6 @@\\n from torch.utils.data import DataLoader, Dataset\\n \\n import PIL\\n-import torchvision\",\n \"from_author\": true\n },\n {\n \"body\": \"Unrelated to this PR, this is to make quality pass.\",\n \"diff_hunk\": \"@@ -14,6 +14,7 @@\\n # limitations under the License.\\n import argparse\\n \\n+import torch\",\n \"from_author\": true\n },\n {\n \"body\": \"Unrelated to this PR, this is to make quality pass.\",\n \"diff_hunk\": \"@@ -64,15 +64,15 @@ def param_groups(self):\\n return self.optimizer.param_groups\\n \\n @param_groups.setter\\n- def param_group(self, param_groups):\\n+ def param_groups(self, param_groups):\",\n \"from_author\": true\n },\n {\n \"body\": \"Unrelated to this PR, this is to make quality pass.\",\n \"diff_hunk\": \"@@ -64,15 +64,15 @@ def param_groups(self):\\n return self.optimizer.param_groups\\n \\n @param_groups.setter\\n- def param_group(self, param_groups):\\n+ def param_groups(self, param_groups):\\n self.optimizer.param_groups = param_groups\\n \\n @property\\n def defaults(self):\\n return self.optimizer.defaults\\n \\n @defaults.setter\\n- def param_group(self, defaults):\\n+ def defaults(self, defaults):\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/15\",\n \"pr_id\": 598136435\n },\n {\n \"diff\": \"diff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 54ef3c12f..61a39fc95 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -105,10 +105,7 @@ def send_to_device(tensor, device):\\n elif isinstance(tensor, dict):\\n return type(tensor)({k: send_to_device(v, device) for k, v in tensor.items()})\\n elif not hasattr(tensor, \\\"to\\\"):\\n- raise TypeError(\\n- f\\\"Can't send the values of type {type(tensor)} to device {device}, only of nested list/tuple/dicts \\\"\\n- \\\"of tensors or objects having a `to` method.\\\"\\n- )\\n+ return tensor\\n return tensor.to(device)\\n \\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/13\",\n \"pr_id\": 595121308\n },\n {\n \"diff\": \"diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex 0a86f41b9..1e3ac4e89 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -207,7 +207,8 @@ lof of time. In practice, that means you must take special care to have all your\\n shape (so no dynamic padding for instance if you are in an NLP problem) and should not use layer with for loops that\\n have different lengths depending on the inputs (such as an LSTM) or the training will be excruciatingly slow.\\n \\n-To introduce special behavior in your script for TPUs you can check the :obj:`distributed_type` of your :obj:`accelerator`:\\n+To introduce special behavior in your script for TPUs you can check the :obj:`distributed_type` of your\\n+:obj:`accelerator`:\\n \\n .. code-block:: python\\n \\n@@ -356,9 +357,10 @@ setting the same seed in the main random number generator in all processes.\\n \\n .. Warning::\\n \\n- Synchronization the main torch (or CUDA or XLA) random number generator will affect any other potential random artifacts you could have in your\\n- dataset (like random data augmentation) in the sense all processes will get the same random numbers from the torch\\n- random modules (so will apply the same random data augmentation if it's controlled by torch).\\n+ Synchronization the main torch (or CUDA or XLA) random number generator will affect any other potential random\\n+ artifacts you could have in your dataset (like random data augmentation) in the sense all processes will get the\\n+ same random numbers from the torch random modules (so will apply the same random data augmentation if it's\\n+ controlled by torch).\\n \\n .. Note::\\n \\ndiff --git a/examples/README.md b/examples/README.md\\nindex 30b376cef..be636e63c 100644\\n--- a/examples/README.md\\n+++ b/examples/README.md\\n@@ -18,7 +18,13 @@ limitations under the License.\\n \\n ## Simple NLP example\\n \\n-The [nlp_example.py](./nlp_example.py) script is a simple example to train a Bert model on a classification task ([GLUE's MRPC]()).\\n+The [nlp_example.py](./nlp_example.py) script is a simple example to train a Bert model on a classification task ([GLUE's MRPC](https://www.microsoft.com/en-us/download/details.aspx?id=52398)).\\n+\\n+Prior to running it you should install π€ Dataset and π€ Transformers:\\n+\\n+```bash\\n+pip install datasets, transformers\\n+```\\n \\n The same script can be run in any of the following configurations:\\n - single CPU or single GPU\\n@@ -89,3 +95,91 @@ To run it in each of these various modes, use the following commands:\\n ```\\n * In PyTorch:\\n Add an `xmp.spawn` line in your script as you usually do.\\n+\\n+\\n+## Simple vision example\\n+\\n+The [cv_example.py](./cv_example.py) script is a simple example to fine-tune a ResNet-50 on a classification task ([Ofxord-IIT Pet Dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/)).\\n+\\n+The same script can be run in any of the following configurations:\\n+- single CPU or single GPU\\n+- multi GPUS (using PyTorch distributed mode)\\n+- (multi) TPUs\\n+- fp16 (mixed-precision) or fp32 (normal precision)\\n+\\n+Prior to running it you should install timm and torchvision:\\n+\\n+```bash\\n+pip install timm, torchvision\\n+```\\n+\\n+and you should download the data with the following commands:\\n+\\n+```bash\\n+wget https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz\\n+tar -xzf images.tar.gz\\n+```\\n+\\n+To run it in each of these various modes, use the following commands:\\n+- single CPU:\\n+ * from a server without GPU\\n+ ```bash\\n+ python ./cv_example.py --data_dir path_to_data\\n+ ```\\n+ * from any server by passing `cpu=True` to the `Accelerator`.\\n+ ```bash\\n+ python ./cv_example.py --data_dir path_to_data --cpu\\n+ ```\\n+ * from any server with Accelerate launcher\\n+ ```bash\\n+ accelerate launch --cpu ./cv_example.py --data_dir path_to_data\\n+ ```\\n+- single GPU:\\n+ ```bash\\n+ python ./nlp_example.py # from a server with a GPU\\n+ ```\\n+- with fp16 (mixed-precision)\\n+ * from any server by passing `fp16=True` to the `Accelerator`.\\n+ ```bash\\n+ python ./cv_example.py --data_dir path_to_data --fp16\\n+ ```\\n+ * from any server with Accelerate launcher\\n+ ```bash\\n+ accelerate launch --fb16 ./cv_example.py --data_dir path_to_data\\n+- multi GPUS (using PyTorch distributed mode)\\n+ * With Accelerate config and launcher\\n+ ```bash\\n+ accelerate config # This will create a config file on your server\\n+ accelerate launch ./cv_example.py --data_dir path_to_data # This will run the script on your server\\n+ ```\\n+ * With traditional PyTorch launcher\\n+ ```bash\\n+ python -m torch.distributed.launch --nproc_per_node 2 --use_env ./cv_example.py --data_dir path_to_data\\n+ ```\\n+- multi GPUs, multi node (several machines, using PyTorch distributed mode)\\n+ * With Accelerate config and launcher, on each machine:\\n+ ```bash\\n+ accelerate config # This will create a config file on each server\\n+ accelerate launch ./cv_example.py --data_dir path_to_data # This will run the script on each server\\n+ ```\\n+ * With PyTorch launcher only\\n+ ```bash\\n+ python -m torch.distributed.launch --nproc_per_node 2 \\\\\\n+ --use_env \\\\\\n+ --node_rank 0 \\\\\\n+ --master_addr master_node_ip_address \\\\\\n+ ./cv_example.py --data_dir path_to_data # On the first server\\n+ python -m torch.distributed.launch --nproc_per_node 2 \\\\\\n+ --use_env \\\\\\n+ --node_rank 1 \\\\\\n+ --master_addr master_node_ip_address \\\\\\n+ ./cv_example.py --data_dir path_to_data # On the second server\\n+ ```\\n+- (multi) TPUs\\n+ * With Accelerate config and launcher\\n+ ```bash\\n+ accelerate config # This will create a config file on your TPU server\\n+ accelerate launch ./cv_example.py --data_dir path_to_data # This will run the script on each server\\n+ ```\\n+ * In PyTorch:\\n+ Add an `xmp.spawn` line in your script as you usually do.\\ndiff --git a/examples/cv_example.py b/examples/cv_example.py\\nnew file mode 100644\\nindex 000000000..862fbce15\\n--- /dev/null\\n+++ b/examples/cv_example.py\\n@@ -0,0 +1,198 @@\\n+# coding=utf-8\\n+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.\\n+#\\n+# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n+# you may not use this file except in compliance with the License.\\n+# You may obtain a copy of the License at\\n+#\\n+# http://www.apache.org/licenses/LICENSE-2.0\\n+#\\n+# Unless required by applicable law or agreed to in writing, software\\n+# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n+# See the License for the specific language governing permissions and\\n+# limitations under the License.\\n+import argparse\\n+import os\\n+import re\\n+\\n+import numpy as np\\n+import torch\\n+from torch.optim.lr_scheduler import OneCycleLR\\n+from torch.utils.data import DataLoader, Dataset\\n+\\n+import PIL\\n+import torchvision\\n+from accelerate import Accelerator\\n+from timm import create_model\\n+from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor\\n+\\n+\\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example trains a ResNet50 on the Oxford-IIT Pet Dataset\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n+#\\n+########################################################################\\n+\\n+\\n+# Function to get the label from the filename\\n+def extract_label(fname):\\n+ stem = fname.split(os.path.sep)[-1]\\n+ return re.search(r\\\"^(.*)_\\\\d+\\\\.jpg$\\\", stem).groups()[0]\\n+\\n+\\n+class PetsDataset(Dataset):\\n+ def __init__(self, file_names, image_transform=None, label_to_id=None):\\n+ self.file_names = file_names\\n+ self.image_transform = image_transform\\n+ self.label_to_id = label_to_id\\n+\\n+ def __len__(self):\\n+ return len(self.file_names)\\n+\\n+ def __getitem__(self, idx):\\n+ fname = self.file_names[idx]\\n+ raw_image = PIL.Image.open(fname)\\n+ image = raw_image.convert(\\\"RGB\\\")\\n+ if self.image_transform is not None:\\n+ image = self.image_transform(image)\\n+ label = extract_label(fname)\\n+ if self.label_to_id is not None:\\n+ label = self.label_to_id[label]\\n+ return {\\\"image\\\": image, \\\"label\\\": label}\\n+\\n+\\n+def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu)\\n+\\n+ # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n+ lr = config[\\\"lr\\\"]\\n+ num_epochs = int(config[\\\"num_epochs\\\"])\\n+ seed = int(config[\\\"seed\\\"])\\n+ batch_size = int(config[\\\"batch_size\\\"])\\n+ image_size = config[\\\"image_size\\\"]\\n+ if not isinstance(image_size, (list, tuple)):\\n+ image_size = (image_size, image_size)\\n+\\n+ # Grab all the image filenames\\n+ file_names = [os.path.join(args.data_dir, fname) for fname in os.listdir(args.data_dir) if fname.endswith(\\\".jpg\\\")]\\n+\\n+ # Build the label correspondences\\n+ all_labels = [extract_label(fname) for fname in file_names]\\n+ id_to_label = list(set(all_labels))\\n+ id_to_label.sort()\\n+ label_to_id = {lbl: i for i, lbl in enumerate(id_to_label)}\\n+\\n+ # Set the seed before splitting the data.\\n+ np.random.seed(seed)\\n+ torch.manual_seed(seed)\\n+ torch.cuda.manual_seed_all(seed)\\n+\\n+ # Split our filenames between train and validation\\n+ random_perm = np.random.permutation(len(file_names))\\n+ cut = int(0.8 * len(file_names))\\n+ train_split = random_perm[:cut]\\n+ eval_split = random_perm[cut:]\\n+\\n+ # For training we use a simple RandomResizedCrop\\n+ train_tfm = Compose([RandomResizedCrop(image_size, scale=(0.5, 1.0)), ToTensor()])\\n+ train_dataset = PetsDataset(\\n+ [file_names[i] for i in train_split], image_transform=train_tfm, label_to_id=label_to_id\\n+ )\\n+\\n+ # For evaluation, we use a deterministic Resize\\n+ eval_tfm = Compose([Resize(image_size), ToTensor()])\\n+ eval_dataset = PetsDataset([file_names[i] for i in eval_split], image_transform=eval_tfm, label_to_id=label_to_id)\\n+\\n+ # Instantiate dataloaders.\\n+ train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)\\n+ eval_dataloader = DataLoader(eval_dataset, shuffle=False, batch_size=batch_size, num_workers=4)\\n+\\n+ # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n+ model = create_model(\\\"resnet50d\\\", pretrained=True, num_classes=len(label_to_id))\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+ model = model.to(accelerator.device)\\n+\\n+ # Freezing the base model\\n+ for param in model.parameters():\\n+ param.requires_grad = False\\n+ for param in model.get_classifier().parameters():\\n+ param.requires_grad = True\\n+\\n+ # We normalize the batches of images to be a bit faster.\\n+ mean = torch.tensor(model.default_cfg[\\\"mean\\\"])[None, :, None, None].to(accelerator.device)\\n+ std = torch.tensor(model.default_cfg[\\\"std\\\"])[None, :, None, None].to(accelerator.device)\\n+\\n+ # Instantiate optimizer\\n+ optimizer = torch.optim.Adam(params=model.parameters(), lr=lr / 25)\\n+\\n+ # Prepare everything\\n+ # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the\\n+ # prepare method.\\n+ model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(\\n+ model, optimizer, train_dataloader, eval_dataloader\\n+ )\\n+\\n+ # Instantiate learning rate scheduler after preparing the training dataloader as the prepare method\\n+ # may change its length.\\n+ lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=lr, epochs=num_epochs, steps_per_epoch=len(train_dataloader))\\n+\\n+ # Now we train the model\\n+ for epoch in range(num_epochs):\\n+ model.train()\\n+ for step, batch in enumerate(train_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n+ inputs = (batch[\\\"image\\\"] - mean) / std\\n+ outputs = model(inputs)\\n+ loss = torch.nn.functional.cross_entropy(outputs, batch[\\\"label\\\"])\\n+ accelerator.backward(loss)\\n+ optimizer.step()\\n+ lr_scheduler.step()\\n+ optimizer.zero_grad()\\n+\\n+ model.eval()\\n+ accurate = 0\\n+ num_elems = 0\\n+ for step, batch in enumerate(eval_dataloader):\\n+ # We could avoid this line since we set the accelerator with `device_placement=True`.\\n+ batch = {k: v.to(accelerator.device) for k, v in batch.items()}\\n+ inputs = (batch[\\\"image\\\"] - mean) / std\\n+ with torch.no_grad():\\n+ outputs = model(inputs)\\n+ predictions = outputs.argmax(dim=-1)\\n+ accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch[\\\"label\\\"])\\n+ num_elems += accurate_preds.shape[0]\\n+ accurate += accurate_preds.long().sum()\\n+\\n+ eval_metric = accurate.item() / num_elems\\n+ # Use accelerator.print to print only on the main process.\\n+ accelerator.print(f\\\"epoch {epoch}: {100 * eval_metric:.2f}\\\")\\n+\\n+\\n+def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\\"--data_dir\\\", required=True, help=\\\"The data folder on disk.\\\")\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n+ args = parser.parse_args()\\n+ config = {\\\"lr\\\": 3e-2, \\\"num_epochs\\\": 3, \\\"seed\\\": 42, \\\"batch_size\\\": 64, \\\"image_size\\\": 224}\\n+ training_function(config, args)\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+ main()\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 859309a7a..13333c4a4 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -30,7 +30,7 @@\\n ########################################################################\\n # This is a fully working simple example to use Accelerate\\n #\\n-# This example train a Bert base model on GLUE MRPC\\n+# This example trains a Bert base model on GLUE MRPC\\n # in any of the following settings (with the same script):\\n # - single CPU or single GPU\\n # - multi GPUS (using PyTorch distributed mode)\\n@@ -127,7 +127,7 @@ def collate_fn(examples):\\n num_training_steps=len(train_dataloader) * num_epochs,\\n )\\n \\n- # Now we train the model - We prune bad trials after each epoch if needed\\n+ # Now we train the model\\n for epoch in range(num_epochs):\\n model.train()\\n for step, batch in enumerate(train_dataloader):\\n@@ -146,7 +146,8 @@ def collate_fn(examples):\\n for step, batch in enumerate(eval_dataloader):\\n # We could avoid this line since we set the accelerator with `device_placement=True`.\\n batch.to(accelerator.device)\\n- outputs = model(**batch)\\n+ with torch.no_grad():\\n+ outputs = model(**batch)\\n predictions = outputs.logits.argmax(dim=-1)\\n metric.add_batch(\\n predictions=accelerator.gather(predictions),\\n@@ -160,16 +161,8 @@ def collate_fn(examples):\\n \\n def main():\\n parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n- parser.add_argument(\\n- \\\"--fp16\\\",\\n- action=\\\"store_true\\\",\\n- help=\\\"If passed, will use FP16 training.\\\",\\n- )\\n- parser.add_argument(\\n- \\\"--cpu\\\",\\n- action=\\\"store_true\\\",\\n- help=\\\"If passed, will train on the CPU.\\\",\\n- )\\n+ parser.add_argument(\\\"--fp16\\\", action=\\\"store_true\\\", help=\\\"If passed, will use FP16 training.\\\")\\n+ parser.add_argument(\\\"--cpu\\\", action=\\\"store_true\\\", help=\\\"If passed, will train on the CPU.\\\")\\n args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n training_function(config, args)\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 4bb404c39..4707e0afe 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -51,9 +51,9 @@ class Accelerator:\\n - :obj:`\\\"torch\\\"`: the base torch random number generator\\n - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n- - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler\\n- in your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n- \\n+ - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n+ your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n+\\n Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n >= 1.6.\\n \\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex fa364ef6e..061c289ea 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -27,10 +27,10 @@\\n from accelerate.state import DistributedType\\n \\n \\n-class _AddOneArg():\\n+class _AddOneArg:\\n def __init__(self, launcher):\\n self.launcher = launcher\\n- \\n+\\n def __call__(self, index):\\n self.launcher()\\n \\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 937e4598d..24a7ad08a 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -339,8 +339,8 @@ def prepare_data_loader(\\n - :obj:`\\\"torch\\\"`: the base torch random number generator\\n - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n- - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler\\n- in your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n+ - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler in\\n+ your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n Returns:\\n :obj:`torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\ndiff --git a/src/accelerate/optimizer.py b/src/accelerate/optimizer.py\\nindex 3a6046325..a8b95d2d2 100644\\n--- a/src/accelerate/optimizer.py\\n+++ b/src/accelerate/optimizer.py\\n@@ -63,6 +63,18 @@ def __init__(self, optimizer, device_placement=True, scaler=None):\\n def param_groups(self):\\n return self.optimizer.param_groups\\n \\n+ @param_groups.setter\\n+ def param_group(self, param_groups):\\n+ self.optimizer.param_groups = param_groups\\n+\\n+ @property\\n+ def defaults(self):\\n+ return self.optimizer.defaults\\n+\\n+ @defaults.setter\\n+ def param_group(self, defaults):\\n+ self.optimizer.defaults = defaults\\n+\\n def add_param_group(self, param_group):\\n self.optimizer.add_param_group(param_group)\\n \\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex 62543a17b..2e5095533 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -14,8 +14,6 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-from packaging import version\\n-\\n import torch\\n from torch.utils.data import DataLoader\\n \\n@@ -24,6 +22,7 @@\\n from accelerate.state import AcceleratorState, DistributedType\\n from accelerate.test_utils import RegressionDataset, RegressionModel, are_the_same_tensors\\n from accelerate.utils import gather, set_seed, synchronize_rng_states\\n+from packaging import version\\n \\n \\n def init_state_check():\\n@@ -201,6 +200,7 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a)\\n assert torch.allclose(old_model.b, model.b)\\n \\n+\\n def main():\\n accelerator = Accelerator()\\n state = accelerator.state\\n@@ -220,5 +220,6 @@ def main():\\n print(\\\"\\\\n**Training integration test**\\\")\\n training_check()\\n \\n+\\n if __name__ == \\\"__main__\\\":\\n main()\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 4a078b475..54ef3c12f 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -61,7 +61,7 @@ def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optiona\\n elif rng_type == RNGType.GENERATOR:\\n assert generator is not None, \\\"Need a generator to synchronize its seed.\\\"\\n rng_state = generator.get_state()\\n- \\n+\\n # Broadcast the rng state from device 0 to other devices\\n state = AcceleratorState()\\n if state.distributed_type == DistributedType.TPU:\\n\",\n \"code_comments\": [\n {\n \"body\": \"PyTorch optimizers are expected to have thos attributes setable, so I'm obliging.\",\n \"diff_hunk\": \"@@ -63,6 +63,18 @@ def __init__(self, optimizer, device_placement=True, scaler=None):\\n def param_groups(self):\\n return self.optimizer.param_groups\\n \\n+ @param_groups.setter\\n+ def param_group(self, param_groups):\\n+ self.optimizer.param_groups = param_groups\\n+\\n+ @property\\n+ def defaults(self):\\n+ return self.optimizer.defaults\\n+\\n+ @defaults.setter\\n+ def param_group(self, defaults):\\n+ self.optimizer.defaults = defaults\",\n \"from_author\": true\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/10\",\n \"pr_id\": 591809725\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 0b28b6a50..219b93248 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -214,7 +214,7 @@ for epoch in range(10):\\n \\n + from accelerate import Accelerator\\n + accelerator = Accelerator()\\n-+ device = accelerator.device\\n+-\\n \\n + model = torch.nn.Transformer()\\n optim = torch.optim.Adam(\\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/9\",\n \"pr_id\": 588693991\n },\n {\n \"diff\": \"diff --git a/docs/source/internal.rst b/docs/source/internal.rst\\nindex 4c6d895b9..2d8f0f453 100644\\n--- a/docs/source/internal.rst\\n+++ b/docs/source/internal.rst\\n@@ -78,6 +78,8 @@ Utilities\\n \\n .. autofunction:: accelerate.utils.set_seed\\n \\n+.. autofunction:: accelerate.utils.synchronize_rng_state\\n+\\n .. autofunction:: accelerate.utils.synchronize_rng_states\\n \\n .. autofunction:: accelerate.utils.wait_for_everyone\\ndiff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst\\nindex f74ca9eea..0a86f41b9 100644\\n--- a/docs/source/quicktour.rst\\n+++ b/docs/source/quicktour.rst\\n@@ -340,20 +340,29 @@ library handles the sharding of your data between processes by changing that :ob\\n \\n The :class:`~accelerate.data_loader.DataLoaderShard` subclasses :obj:`DataLoader` to add the following functionality:\\n \\n-- it synchronizes the torch random number generators of all processes at each new iteration, to ensure any\\n+- it synchronizes the appropriate random number generator of all processes at each new iteration, to ensure any\\n randomization (like shuffling) is done the exact same way across processes.\\n - it puts the batches on the proper device before yielding them (unless you have opted out of\\n :obj:`device_placement=True`).\\n \\n+The random number generator synchronization will by default synchronize:\\n+\\n+- the :obj:`generator` attribute of a given sampler (like the PyTorch :obj:`RandomSampler`) for PyTorch >= 1.6\\n+- the main random number generator in PyTorch <=1.5.1\\n+\\n+You can choose which random number generator(s) to synchronize with the :obj:`rng_types` argument of the main\\n+:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator`s to avoid\\n+setting the same seed in the main random number generator in all processes.\\n+\\n .. Warning::\\n \\n- The random number generator synchronization will affect any other potential random artifacts you could have in your\\n+ Synchronization the main torch (or CUDA or XLA) random number generator will affect any other potential random artifacts you could have in your\\n dataset (like random data augmentation) in the sense all processes will get the same random numbers from the torch\\n- random modules (so will apply the same random data augmentation if it's controlled by torch). While this is usually\\n- fine, you should use the random number generator from the Python :obj:`random` module or NumPy for your data\\n- augmentation if you think this will be a problem.\\n+ random modules (so will apply the same random data augmentation if it's controlled by torch).\\n+\\n+.. Note::\\n \\n- The randomization part of your sampler on the other hand should absolutely be done using the torch random number\\n- generator (like in the traditional :obj:`RandomSampler`).\\n+ The randomization part of your custom sampler, batch sampler or iterable dataset should be done using a local\\n+ :obj:`torch.Generator` object (in PyTorch >= 1.6), see the traditional :obj:`RandomSampler`, as an example.\\n \\n See more details about the internal in the :doc:`Internals page <internal>`.\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex a2f407ba4..4bb404c39 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -12,6 +12,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+from typing import List, Optional, Union\\n+\\n import torch\\n \\n from packaging import version\\n@@ -19,7 +21,7 @@\\n from .data_loader import prepare_data_loader\\n from .optimizer import AcceleratedOptimizer\\n from .state import AcceleratorState, DistributedType\\n-from .utils import extract_model_from_parallel, gather, save, wait_for_everyone\\n+from .utils import RNGType, extract_model_from_parallel, gather, save, wait_for_everyone\\n \\n \\n class Accelerator:\\n@@ -42,6 +44,18 @@ class Accelerator:\\n cpu (:obj:`bool`, `optional`):\\n Whether or not to force the script to execute on CPU. Will ignore GPU available if set to :obj:`True` and\\n force the execution on one process only.\\n+ rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ The list of random number generators to synchronize at the beginning of each iteration in your prepared\\n+ dataloaders. Should be one or several of:\\n+\\n+ - :obj:`\\\"torch\\\"`: the base torch random number generator\\n+ - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler\\n+ in your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n+ \\n+ Will default to :obj:`[\\\"torch\\\"]` for PyTorch versions <=1.5.1 and :obj:`[\\\"generator\\\"]` for PyTorch versions\\n+ >= 1.6.\\n \\n Attributes\\n \\n@@ -50,7 +64,12 @@ class Accelerator:\\n \\\"\\\"\\\"\\n \\n def __init__(\\n- self, device_placement: bool = True, split_batches: bool = False, fp16: bool = None, cpu: bool = False\\n+ self,\\n+ device_placement: bool = True,\\n+ split_batches: bool = False,\\n+ fp16: bool = None,\\n+ cpu: bool = False,\\n+ rng_types: Optional[List[Union[str, RNGType]]] = None,\\n ):\\n self.state = AcceleratorState(fp16=fp16, cpu=cpu, _from_accelerator=True)\\n \\n@@ -67,6 +86,10 @@ def __init__(\\n # Internal references to the training objects\\n self._optimizers = []\\n \\n+ # RNG Types\\n+ if rng_types is None:\\n+ self.rng_types = [\\\"torch\\\"] if version.parse(torch.__version__) <= version.parse(\\\"1.5.1\\\") else [\\\"generator\\\"]\\n+\\n @property\\n def distributed_type(self):\\n return self.state.distributed_type\\n@@ -187,6 +210,7 @@ def prepare_data_loader(self, data_loader):\\n process_index=self.process_index,\\n split_batches=self.split_batches,\\n put_on_device=self.device_placement,\\n+ rng_types=self.rng_types,\\n )\\n \\n def prepare_optimizer(self, optimizer):\\ndiff --git a/src/accelerate/data_loader.py b/src/accelerate/data_loader.py\\nindex 92bfc3c99..937e4598d 100644\\n--- a/src/accelerate/data_loader.py\\n+++ b/src/accelerate/data_loader.py\\n@@ -12,7 +12,7 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n-from typing import Optional\\n+from typing import List, Optional, Union\\n \\n import torch\\n from torch.utils.data import BatchSampler, DataLoader, IterableDataset\\n@@ -20,7 +20,7 @@\\n from packaging import version\\n \\n from .state import AcceleratorState, DistributedType, is_tpu_available\\n-from .utils import send_to_device, synchronize_rng_states\\n+from .utils import RNGType, send_to_device, synchronize_rng_states\\n \\n \\n if is_tpu_available():\\n@@ -262,16 +262,29 @@ class DataLoaderShard(DataLoader):\\n The dataset to use to build this datalaoder.\\n device (:obj:`torch.device`, `optional`):\\n If passed, the device to put all batches on.\\n+ rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ The list of random number generators to synchronize at the beginning of each iteration. Should be one or\\n+ several of:\\n+\\n+ - :obj:`\\\"torch\\\"`: the base torch random number generator\\n+ - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - :obj:`\\\"generator\\\"`: an optional :obj:`torch.Generator`\\n+ generator (:obj:`torch.Generator`, `optional`):\\n+ A random number generator to keep synchronized accross processes.\\n kwargs:\\n All other keyword arguments to pass to the regular :obj:`DataLoader` initialization.\\n \\\"\\\"\\\"\\n \\n- def __init__(self, dataset, device=None, **kwargs):\\n+ def __init__(self, dataset, device=None, rng_types=None, generator=None, **kwargs):\\n super().__init__(dataset, **kwargs)\\n self.device = device\\n+ self.rng_types = rng_types\\n+ self.generator = generator\\n \\n def __iter__(self):\\n- synchronize_rng_states()\\n+ if self.rng_types is not None:\\n+ synchronize_rng_states(self.rng_types, self.generator)\\n state = AcceleratorState()\\n for batch in super().__iter__():\\n if state.distributed_type == DistributedType.TPU:\\n@@ -286,6 +299,7 @@ def prepare_data_loader(\\n process_index: Optional[int] = None,\\n split_batches: bool = False,\\n put_on_device: bool = False,\\n+ rng_types: Optional[List[Union[str, RNGType]]] = None,\\n ) -> DataLoader:\\n \\\"\\\"\\\"\\n Wraps a PyTorch :obj:`DataLoader` to generate batches for one of the processes only.\\n@@ -318,6 +332,15 @@ def prepare_data_loader(\\n put_on_device (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n Whether or not to put the batches on :obj:`device` (only works if the batches are nested list, tuples or\\n dictionaries of tensors).\\n+ rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\\n+ The list of random number generators to synchronize at the beginning of each iteration. Should be one or\\n+ several of:\\n+\\n+ - :obj:`\\\"torch\\\"`: the base torch random number generator\\n+ - :obj:`\\\"cuda\\\"`: the CUDA random number generator (GPU only)\\n+ - :obj:`\\\"xla\\\"`: the XLA random number generator (TPU only)\\n+ - :obj:`\\\"generator\\\"`: the :obj:`torch.Generator` of the sampler (or batch sampler if there is no sampler\\n+ in your dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.\\n \\n Returns:\\n :obj:`torch.utils.data.dataloader.DataLoader`: A new data loader that will yield the portion of the batches\\n@@ -342,9 +365,12 @@ def prepare_data_loader(\\n \\n new_dataset = dataloader.dataset\\n new_batch_sampler = dataloader.batch_sampler\\n+ generator = getattr(dataloader, \\\"generator\\\", None)\\n # No change if no multiprocess\\n if num_processes != 1:\\n if isinstance(new_dataset, IterableDataset):\\n+ if getattr(dataloader.dataset, \\\"generator\\\", None) is not None:\\n+ generator = dataloader.dataset.generator\\n new_dataset = IterableDatasetShard(\\n new_dataset,\\n batch_size=dataloader.batch_size,\\n@@ -355,6 +381,13 @@ def prepare_data_loader(\\n )\\n else:\\n # New batch sampler for the current process.\\n+ if hasattr(dataloader.sampler, \\\"generator\\\"):\\n+ if dataloader.sampler.generator is None:\\n+ dataloader.sampler.generator = torch.Generator()\\n+ generator = dataloader.sampler.generator\\n+ generator.manual_seed(int(torch.empty((), dtype=torch.int64).random_().item()))\\n+ elif getattr(dataloader.batch_sampler, \\\"generator\\\", None) is not None:\\n+ generator = dataloader.batch_sampler.generator\\n new_batch_sampler = BatchSamplerShard(\\n dataloader.batch_sampler,\\n num_processes=num_processes,\\n@@ -369,8 +402,12 @@ def prepare_data_loader(\\n \\\"sampler\\\",\\n \\\"batch_sampler\\\",\\n \\\"drop_last\\\",\\n+ \\\"generator\\\",\\n ]\\n \\n+ if rng_types is not None and generator is None and \\\"generator\\\" in rng_types:\\n+ rng_types.remove(\\\"generator\\\")\\n+\\n kwargs = {\\n k: getattr(dataloader, k, _PYTORCH_DATALOADER_KWARGS[k])\\n for k in _PYTORCH_DATALOADER_KWARGS\\n@@ -380,5 +417,7 @@ def prepare_data_loader(\\n new_dataset,\\n device=device if put_on_device else None,\\n batch_sampler=new_batch_sampler,\\n+ rng_types=rng_types,\\n+ generator=generator,\\n **kwargs,\\n )\\ndiff --git a/src/accelerate/test_utils/test_script.py b/src/accelerate/test_utils/test_script.py\\nindex e8282a319..62543a17b 100644\\n--- a/src/accelerate/test_utils/test_script.py\\n+++ b/src/accelerate/test_utils/test_script.py\\n@@ -14,6 +14,8 @@\\n # See the License for the specific language governing permissions and\\n # limitations under the License.\\n \\n+from packaging import version\\n+\\n import torch\\n from torch.utils.data import DataLoader\\n \\n@@ -34,10 +36,16 @@ def init_state_check():\\n \\n def rng_sync_check():\\n state = AcceleratorState()\\n- synchronize_rng_states()\\n+ synchronize_rng_states([\\\"torch\\\"])\\n assert are_the_same_tensors(torch.get_rng_state())\\n if state.distributed_type == DistributedType.MULTI_GPU:\\n+ synchronize_rng_states([\\\"cuda\\\"])\\n assert are_the_same_tensors(torch.cuda.get_rng_state())\\n+ if version.parse(torch.__version__) >= version.parse(\\\"1.6.0\\\"):\\n+ generator = torch.Generator()\\n+ synchronize_rng_states([\\\"generator\\\"], generator=generator)\\n+ assert are_the_same_tensors(generator.get_state())\\n+\\n if state.local_process_index == 0:\\n print(\\\"All rng are properly synched.\\\")\\n \\n@@ -101,13 +109,14 @@ def dl_preparation_check():\\n print(\\\"Shuffled dataloader passing.\\\")\\n \\n \\n-def mock_training(length, batch_size):\\n+def mock_training(length, batch_size, generator):\\n set_seed(42)\\n+ generator.manual_seed(42)\\n train_set = RegressionDataset(length=length)\\n- train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True)\\n+ train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n model = RegressionModel()\\n optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n- for _ in range(3):\\n+ for epoch in range(3):\\n for batch in train_dl:\\n model.zero_grad()\\n output = model(batch[\\\"x\\\"])\\n@@ -119,21 +128,23 @@ def mock_training(length, batch_size):\\n \\n def training_check():\\n state = AcceleratorState()\\n+ generator = torch.Generator()\\n batch_size = 8\\n length = batch_size * 4 * state.num_processes\\n \\n- train_set, old_model = mock_training(length, batch_size * state.num_processes)\\n+ train_set, old_model = mock_training(length, batch_size * state.num_processes, generator)\\n assert are_the_same_tensors(old_model.a)\\n assert are_the_same_tensors(old_model.b)\\n \\n accelerator = Accelerator()\\n- train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True)\\n+ train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n model = RegressionModel()\\n optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n \\n train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)\\n set_seed(42)\\n- for _ in range(3):\\n+ generator.manual_seed(42)\\n+ for epoch in range(3):\\n for batch in train_dl:\\n model.zero_grad()\\n output = model(batch[\\\"x\\\"])\\n@@ -145,15 +156,16 @@ def training_check():\\n assert torch.allclose(old_model.a, model.a)\\n assert torch.allclose(old_model.b, model.b)\\n \\n- accelerator.print(\\\"Training yielded the same results on one CPU or distributes setup with no batch split.\\\")\\n+ accelerator.print(\\\"Training yielded the same results on one CPU or distributed setup with no batch split.\\\")\\n \\n accelerator = Accelerator(split_batches=True)\\n- train_dl = DataLoader(train_set, batch_size=batch_size * state.num_processes, shuffle=True)\\n+ train_dl = DataLoader(train_set, batch_size=batch_size * state.num_processes, shuffle=True, generator=generator)\\n model = RegressionModel()\\n optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n \\n train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)\\n set_seed(42)\\n+ generator.manual_seed(42)\\n for _ in range(3):\\n for batch in train_dl:\\n model.zero_grad()\\n@@ -170,12 +182,13 @@ def training_check():\\n \\n # Mostly a test that FP16 doesn't crash as the operation inside the model is not converted to FP16\\n accelerator = Accelerator(fp16=True)\\n- train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True)\\n+ train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)\\n model = RegressionModel()\\n optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\\n \\n train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)\\n set_seed(42)\\n+ generator.manual_seed(42)\\n for _ in range(3):\\n for batch in train_dl:\\n model.zero_grad()\\ndiff --git a/src/accelerate/utils.py b/src/accelerate/utils.py\\nindex 9e99d4c7b..4a078b475 100644\\n--- a/src/accelerate/utils.py\\n+++ b/src/accelerate/utils.py\\n@@ -13,6 +13,8 @@\\n # limitations under the License.\\n \\n import random\\n+from enum import Enum\\n+from typing import List, Optional, Union\\n \\n import numpy as np\\n import torch\\n@@ -24,6 +26,13 @@\\n import torch_xla.core.xla_model as xm\\n \\n \\n+class RNGType(Enum):\\n+ TORCH = \\\"torch\\\"\\n+ CUDA = \\\"cuda\\\"\\n+ XLA = \\\"xla\\\"\\n+ GENERATOR = \\\"generator\\\"\\n+\\n+\\n def set_seed(seed: int):\\n \\\"\\\"\\\"\\n Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch``.\\n@@ -36,27 +45,46 @@ def set_seed(seed: int):\\n torch.manual_seed(seed)\\n torch.cuda.manual_seed_all(seed)\\n # ^^ safe to call this function even if cuda is not available\\n+ if is_tpu_available():\\n+ xm.set_rng_state(seed)\\n \\n \\n-def synchronize_rng_states():\\n- \\\"\\\"\\\"\\n- Helper function to synchronize the rng states in distributed training.\\n- \\\"\\\"\\\"\\n+def synchronize_rng_state(rng_type: Optional[RNGType] = None, generator: Optional[torch.Generator] = None):\\n+ # Get the proper rng state\\n+ if rng_type == RNGType.TORCH:\\n+ rng_state = torch.get_rng_state()\\n+ elif rng_type == RNGType.CUDA:\\n+ rng_state = torch.cuda.get_rng_state()\\n+ elif rng_type == RNGType.XLA:\\n+ assert is_tpu_available(), \\\"Can't synchronize XLA seeds on an environment without TPUs.\\\"\\n+ rng_state = torch.tensor(xm.get_rng_state())\\n+ elif rng_type == RNGType.GENERATOR:\\n+ assert generator is not None, \\\"Need a generator to synchronize its seed.\\\"\\n+ rng_state = generator.get_state()\\n+ \\n+ # Broadcast the rng state from device 0 to other devices\\n state = AcceleratorState()\\n if state.distributed_type == DistributedType.TPU:\\n- rng_state = torch.get_rng_state()\\n rng_state = xm.mesh_reduce(\\\"random_seed\\\", rng_state, lambda x: x[0])\\n- torch.set_rng_state(rng_state)\\n elif state.distributed_type == DistributedType.MULTI_GPU:\\n- rng_state = torch.get_rng_state().to(state.device)\\n- # Broadcast the state from process 0 to all the others.\\n+ rng_state = rng_state.to(state.device)\\n torch.distributed.broadcast(rng_state, 0)\\n- torch.set_rng_state(rng_state.cpu())\\n+ rng_state = rng_state.cpu()\\n \\n- # Broadcast the state from process 0 to all the others.\\n- rng_state = torch.cuda.get_rng_state().to(state.device)\\n- torch.distributed.broadcast(rng_state, 0)\\n- torch.cuda.set_rng_state(rng_state.cpu())\\n+ # Set the broadcast rng state\\n+ if rng_type == RNGType.TORCH:\\n+ torch.set_rng_state(rng_state)\\n+ elif rng_type == RNGType.CUDA:\\n+ torch.cuda.set_rng_state(rng_state)\\n+ elif rng_type == RNGType.XLA:\\n+ xm.set_rng_state(rng_state.item())\\n+ elif rng_type == RNGType.GENERATOR:\\n+ generator.set_state(rng_state)\\n+\\n+\\n+def synchronize_rng_states(rng_types: List[Union[str, RNGType]], generator: Optional[torch.Generator] = None):\\n+ for rng_type in rng_types:\\n+ synchronize_rng_state(RNGType(rng_type), generator=generator)\\n \\n \\n def send_to_device(tensor, device):\\n\",\n \"code_comments\": [\n {\n \"body\": \"I like this!\",\n \"diff_hunk\": \"@@ -42,6 +44,18 @@ class Accelerator:\\n cpu (:obj:`bool`, `optional`):\\n Whether or not to force the script to execute on CPU. Will ignore GPU available if set to :obj:`True` and\\n force the execution on one process only.\\n+ rng_types (list of :obj:`str` or :class:`~accelerate.utils.RNGType`):\",\n \"from_author\": false\n },\n {\n \"body\": \"Maybe you can move this comment above if you want to keep it\",\n \"diff_hunk\": \"@@ -35,28 +44,47 @@ def set_seed(seed: int):\\n np.random.seed(seed)\\n torch.manual_seed(seed)\\n torch.cuda.manual_seed_all(seed)\\n+ if is_tpu_available():\\n+ xm.set_rng_state(seed)\\n # ^^ safe to call this function even if cuda is not available\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/8\",\n \"pr_id\": 588461912\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 728976692..0b28b6a50 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -46,9 +46,9 @@ limitations under the License.\\n \\n ## Easy to integrate\\n \\n-π€ Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boiler code needed to use multi-GPUs/TPU/fp16.\\n+π€ Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boilerplate code needed to use multi-GPUs/TPU/fp16.\\n \\n-π€ Accelerate abstracts exactly and only the boiler code related to multi-GPUs/TPU/fp16 and let the rest of your code unchanged.\\n+π€ Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.\\n \\n Here is an example:\\n \\n@@ -149,11 +149,11 @@ for epoch in range(10):\\n </tr>\\n </table>\\n \\n-As you can see on this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).\\n+As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).\\n \\n-The same code can then in particular run without modification on your local machine for debugging or your training environment.\\n+In particular, the same code can then be run without modification on your local machine for debugging or your training environment.\\n \\n-π€ Accelerate even handles the device placement for you (a bit more changes to your code but safer in general), so you can even simplify your training loop further:\\n+π€ Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:\\n \\n <table>\\n <tr>\\n@@ -254,7 +254,7 @@ for epoch in range(10):\\n \\n ## Launching script\\n \\n-π€ Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment then launch the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!\\n+π€ Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment before launching the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!\\n On your machine(s) just run:\\n \\n ```bash\\n@@ -277,7 +277,7 @@ accelerate launch examples/nlp_example.py\\n \\n You should use π€ Accelerate when you want to easily run your training scripts in a distributed environment without having to renounce full control over your training loop. This is not a high-level framework above PyTorch, just a thin wrapper so you don't have to learn a new library, In fact the whole API of π€ Accelerate is in one class, the `Accelerator` object.\\n \\n-## Why shouldn't use π€ Accelerate?\\n+## Why shouldn't I use π€ Accelerate?\\n \\n You shouldn't use π€ Accelerate if you don't want to write a training loop yourself. There are plenty of high-level libraries above PyTorch that will offer you that, π€ Accelerate is not one of them.\\n \\n\",\n \"code_comments\": [],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/7\",\n \"pr_id\": 588102643\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 794176758..728976692 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -140,7 +140,7 @@ for epoch in range(10):\\n output, targets\\n )\\n \\n-+ accelerate.backward(loss)\\n++ accelerator.backward(loss)\\n \\n optimizer.step()\\n ```\\n@@ -243,7 +243,7 @@ for epoch in range(10):\\n output, targets\\n )\\n \\n-+ accelerate.backward(loss)\\n++ accelerator.backward(loss)\\n \\n optimizer.step()\\n ```\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Thanks a lot!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/6\",\n \"pr_id\": 586408354\n },\n {\n \"diff\": \"diff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex e20426857..859309a7a 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -49,6 +49,9 @@\\n \\n \\n def training_function(config, args):\\n+ # Initialize accelerator\\n+ accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu)\\n+\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n num_epochs = int(config[\\\"num_epochs\\\"])\\n@@ -97,14 +100,13 @@ def collate_fn(examples):\\n )\\n \\n set_seed(seed)\\n- # Initialize accelerator\\n- accelerator = Accelerator(fp16=args.fp16, cpu=args.cpu)\\n \\n # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n- # We could avoid this line since we set the accelerator with `device_placement=True`.\\n- # If setting devices manually, this line absolutely needs to be before the optimizer creation otherwise training\\n- # will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n+\\n+ # We could avoid this line since the accelerator is set with `device_placement=True` (default value).\\n+ # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer\\n+ # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).\\n model = model.to(accelerator.device)\\n \\n # Instantiate optimizer\\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Ah thanks a lot for fixing!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/4\",\n \"pr_id\": 585909977\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 3776c7cc2..a9d6c5704 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -270,7 +270,7 @@ accelerate launch my_script.py --args_to_my_script\\n For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):\\n \\n ```bash\\n-accelerate launch examples/glue_example.py --task_name mrpc --model_name_or_path bert-base-cased\\n+accelerate launch examples/nlp_example.py\\n ```\\n \\n ## Why should I use π€ Accelerate?\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\naccelerate launch examples/nlp_example.py\\r\\n```\\r\\nThis one does not take any arg however.\",\n \"diff_hunk\": \"@@ -270,7 +270,7 @@ accelerate launch my_script.py --args_to_my_script\\n For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):\\n \\n ```bash\\n-accelerate launch examples/glue_example.py --task_name mrpc --model_name_or_path bert-base-cased\\n+accelerate launch examples/nlp_example.py --task_name mrpc --model_name_or_path bert-base-cased\",\n \"from_author\": false\n }\n ],\n \"context\": [\n {\n \"body\": \"Thanks a lot!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/3\",\n \"pr_id\": 585905166\n },\n {\n \"diff\": \"diff --git a/README.md b/README.md\\nindex 3776c7cc2..3fa28ba40 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -254,7 +254,7 @@ for epoch in range(10):\\n \\n ## Launching script\\n \\n-π€ Accelerate also provides a CLI tool that allows you to quickly configure and test your training environment then launch the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!\\n+π€ Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment then launch the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!\\n On your machine(s) just run:\\n \\n ```bash\\ndiff --git a/examples/nlp_example.py b/examples/nlp_example.py\\nindex 32ff600a9..e20426857 100644\\n--- a/examples/nlp_example.py\\n+++ b/examples/nlp_example.py\\n@@ -39,7 +39,7 @@\\n #\\n # To run it in each of these various modes, follow the instructions\\n # in the readme for examples:\\n-# https://github.com/huggingface/accelerate/examples\\n+# https://github.com/huggingface/accelerate/tree/main/examples\\n #\\n ########################################################################\\n \\n\",\n \"code_comments\": [],\n \"context\": [\n {\n \"body\": \"Thanks!\",\n \"from_author\": false\n }\n ],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/2\",\n \"pr_id\": 585905045\n },\n {\n \"diff\": \"diff --git a/.gitignore b/.gitignore\\nindex b6e47617d..3b89c957d 100644\\n--- a/.gitignore\\n+++ b/.gitignore\\n@@ -127,3 +127,6 @@ dmypy.json\\n \\n # Pyre type checker\\n .pyre/\\n+\\n+# VSCode\\n+.vscode\\ndiff --git a/README.md b/README.md\\nindex 781eea3c9..fcc20a12a 100644\\n--- a/README.md\\n+++ b/README.md\\n@@ -34,7 +34,98 @@\\n <p>Run your *raw* PyTorch training script on any kind of device\\n </h3>\\n \\n-π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed setting (multi-GPUs, TPUs etc.) while still letting you write your own training loop. The same code can then runs seamlessly on your local machine for debugging or your training environment.\\n+π€ Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boiler code needed to use multi-GPUs/TPU/fp16.\\n+\\n+π€ Accelerate abstracts exactly and only the boiler code related to multi-GPUs/TPU/fp16 and let the rest of your code unchanged.\\n+\\n+Here is an example:\\n+\\n+<table>\\n+<tr>\\n+<th> Original training code (CPU or mono-GPU only)</th>\\n+<th> With Accelerate for CPU/GPU/multi-GPUs/TPUs/fp16 </th>\\n+</tr>\\n+<tr>\\n+<td>\\n+\\n+```python\\n+import torch\\n+import torch.nn.functional as F\\n+from datasets import load_dataset\\n+\\n+\\n+\\n+device = 'cpu'\\n+\\n+model = torch.nn.Transformer().to(device)\\n+optim = torch.optim.Adam(model.parameters())\\n+\\n+dataset = load_dataset('my_dataset')\\n+data = torch.utils.data.Dataloader(dataset)\\n+\\n+\\n+\\n+\\n+model.train()\\n+for epoch in range(10):\\n+ for source, targets in data:\\n+ source = source.to(device)\\n+ targets = targets.to(device)\\n+\\n+ optimizer.zero_grad()\\n+\\n+ output = model(source, targets)\\n+ loss = F.cross_entropy(output, targets)\\n+\\n+ loss.backward()\\n+\\n+ optimizer.step()\\n+```\\n+\\n+</td>\\n+<td>\\n+\\n+```python\\n+ import torch\\n+ import torch.nn.functional as F\\n+ from datasets import load_dataset\\n+\\n++ from accelerate import Accelerator\\n++ accelerator = Accelerator()\\n++ device = accelerator.device\\n+\\n+ model = torch.nn.Transformer().to(device)\\n+ optim = torch.optim.Adam(model.parameters())\\n+\\n+ dataset = load_dataset('my_dataset')\\n+ data = torch.utils.data.Dataloader(dataset)\\n+\\n++ model, optim, data = accelerator.prepare(\\n+ model, optim, data)\\n+\\n+ model.train()\\n+ for epoch in range(10):\\n+ for source, targets in data:\\n+ source = source.to(device)\\n+ targets = targets.to(device)\\n+\\n+ optimizer.zero_grad()\\n+\\n+ output = model(source, targets)\\n+ loss = F.cross_entropy(output, targets)\\n+\\n++ accelerate.backward(loss)\\n+\\n+ optimizer.step()\\n+```\\n+\\n+</td>\\n+</tr>\\n+</table>\\n+\\n+As you can see on this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).\\n+\\n+The same code can then in paticular run without modification on your local machine for debugging or your training environment.\\n \\n π€ Accelerate also provides a CLI tool that allows you to quickly configure and test your training environment then launch the scripts.\\n \\ndiff --git a/examples/README.md b/examples/README.md\\nnew file mode 100644\\nindex 000000000..cb1d2645b\\n--- /dev/null\\n+++ b/examples/README.md\\n@@ -0,0 +1,75 @@\\n+# In this folder we showcase various full examples using `Accelerate`\\n+\\n+## Simple NLP example\\n+\\n+The [simple_example.py](./simple_example.py) script is a simple example to train a Bert model on a classification task ([GLUE's MRPC]()).\\n+\\n+The same script can be run in any of the following configurations:\\n+- single CPU or single GPU\\n+- multi GPUS (using PyTorch distributed mode)\\n+- (multi) TPUs\\n+- fp16 (mixed-precision) or fp32 (normal precision)\\n+\\n+To run it in each of these various modes, use the following commands:\\n+- single CPU:\\n+ * from a server without GPU\\n+ ```bash\\n+ python ./simple_example.py\\n+ ```\\n+ * from any server by passing `cpu=True` to the `Accelerator`.\\n+ ```bash\\n+ python ./simple_example.py --cpu\\n+ ```\\n+ * from any server with Accelerate launcher\\n+ ```bash\\n+ accelerate launch --cpu ./simple_example.py\\n+ ```\\n+- single GPU:\\n+ ```bash\\n+ python ./simple_example.py # from a server with a GPU\\n+ ```\\n+- with fp16 (mixed-precision)\\n+ * from any server by passing `fp16=True` to the `Accelerator`.\\n+ ```bash\\n+ python ./simple_example.py --fp16\\n+ ```\\n+ * from any server with Accelerate launcher\\n+ ```bash\\n+ accelerate launch --fb16 ./simple_example.py\\n+- multi GPUS (using PyTorch distributed mode)\\n+ * With Accelerate config and launcher\\n+ ```bash\\n+ accelerate config # This will create a config file on your server\\n+ accelerate launch ./simple_example.py # This will run the script on your server\\n+ ```\\n+ * With traditional PyTorch launcher\\n+ ```bash\\n+ python -m torch.distributed.launch --nproc_per_node 2 --use_env ./simple_example.py\\n+ ```\\n+- multi GPUs, multi node (several machines, using PyTorch distributed mode)\\n+ * With Accelerate config and launcher, on each machine:\\n+ ```bash\\n+ accelerate config # This will create a config file on each server\\n+ accelerate launch ./simple_example.py # This will run the script on each server\\n+ ```\\n+ * With PyTorch launcher only\\n+ ```bash\\n+ python -m torch.distributed.launch --nproc_per_node 2 \\\\\\n+ --use_env \\\\\\n+ --node_rank 0 \\\\\\n+ --master_addr master_node_ip_address \\\\\\n+ ./simple_example.py # On the first server\\n+ python -m torch.distributed.launch --nproc_per_node 2 \\\\\\n+ --use_env \\\\\\n+ --node_rank 1 \\\\\\n+ --master_addr master_node_ip_address \\\\\\n+ ./simple_example.py # On the second server\\n+ ```\\n+- (multi) TPUs\\n+ * With Accelerate config and launcher\\n+ ```bash\\n+ accelerate config # This will create a config file on your TPU server\\n+ accelerate launch ./simple_example.py # This will run the script on each server\\n+ ```\\n+ * In PyTorch:\\n+ Add an `xmp.spawn` line in your script as you usually do.\\ndiff --git a/examples/simple_example.py b/examples/simple_example.py\\nindex dbbfd22f8..88c81e3a0 100644\\n--- a/examples/simple_example.py\\n+++ b/examples/simple_example.py\\n@@ -11,11 +11,28 @@\\n )\\n \\n \\n+########################################################################\\n+# This is a fully working simple example to use Accelerate\\n+#\\n+# This example train a Bert base model on GLUE MRPC\\n+# in any of the following settings (with the same script):\\n+# - single CPU or single GPU\\n+# - multi GPUS (using PyTorch distributed mode)\\n+# - (multi) TPUs\\n+# - fp16 (mixed-precision) or fp32 (normal precision)\\n+#\\n+# To run it in each of these various modes, follow the instructions\\n+# in the readme for examples:\\n+# https://github.com/huggingface/accelerate/examples\\n+#\\n+########################################################################\\n+\\n+\\n MAX_GPU_BATCH_SIZE = 16\\n EVAL_BATCH_SIZE = 32\\n \\n \\n-def training_function(config):\\n+def training_function(config, args):\\n # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs\\n lr = config[\\\"lr\\\"]\\n num_epochs = int(config[\\\"num_epochs\\\"])\\n@@ -62,7 +79,7 @@ def collate_fn(examples):\\n \\n set_seed(seed)\\n # Initialize accelerator\\n- accelerator = Accelerator(device_placement=False)\\n+ accelerator = Accelerator(device_placement=False, fp16=args.fp16, cpu=args.cpu)\\n \\n # Instantiate the model (we build the model here so that the seed also control new weights initialization)\\n model = AutoModelForSequenceClassification.from_pretrained(\\\"bert-base-cased\\\", return_dict=True)\\n@@ -117,8 +134,20 @@ def collate_fn(examples):\\n \\n \\n def main():\\n+ parser = argparse.ArgumentParser(description=\\\"Simple example of training script.\\\")\\n+ parser.add_argument(\\n+ \\\"--fp16\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"If passed, will use FP16 training.\\\",\\n+ )\\n+ parser.add_argument(\\n+ \\\"--cpu\\\",\\n+ action=\\\"store_true\\\",\\n+ help=\\\"If passed, will train on the CPU.\\\",\\n+ )\\n+ args = parser.parse_args()\\n config = {\\\"lr\\\": 2e-5, \\\"num_epochs\\\": 3, \\\"correct_bias\\\": True, \\\"seed\\\": 42, \\\"batch_size\\\": 16}\\n- training_function(config)\\n+ training_function(config, args)\\n \\n \\n if __name__ == \\\"__main__\\\":\\ndiff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py\\nindex 96e3b2c86..a18f31372 100644\\n--- a/src/accelerate/accelerator.py\\n+++ b/src/accelerate/accelerator.py\\n@@ -14,7 +14,7 @@ class Accelerator:\\n \\n Args:\\n device_placement (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n- Whether or not the accelerator should put objects on device (tensors yielded by the datalaoder, model,\\n+ Whether or not the accelerator should put objects on device (tensors yielded by the dataloader, model,\\n etc...).\\n split_batches (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n Whether or not the accelerator should split the batches yielded by the dataloaders across the devices. If\\n@@ -38,6 +38,7 @@ def __init__(\\n self, device_placement: bool = True, split_batches: bool = False, fp16: bool = None, cpu: bool = False\\n ):\\n self.state = AcceleratorState(fp16=fp16, cpu=cpu, _from_accelerator=True)\\n+\\n self.device_placement = device_placement\\n self.split_batches = split_batches\\n \\n@@ -99,6 +100,13 @@ def prepare(self, *args):\\n \\\"\\\"\\\"\\n Prepare all objects passed in :obj:`args` for distributed training and mixed precision, then return them in the\\n same order.\\n+\\n+ Accepts the following type of objects:\\n+\\n+ - :obj:`torch.utils.data.DataLoader`: PyTorch Dataloader\\n+ - :obj:`torch.nn.Module`: PyTorch Module\\n+ - :obj:`torch.optim.Optimizer`: PyTorch Optimizer\\n+\\n \\\"\\\"\\\"\\n # On TPUs, putting the model on the XLA device will create new parameters, so the corresponding optimizer will\\n # have parameters disconnected from the model (so no training :-( ).\\ndiff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py\\nindex d559d0b0b..601cba147 100644\\n--- a/src/accelerate/commands/launch.py\\n+++ b/src/accelerate/commands/launch.py\\n@@ -32,6 +32,9 @@ def launch_command_parser(subparsers=None):\\n parser.add_argument(\\n \\\"--fp16\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not to use mixed precision training.\\\"\\n )\\n+ parser.add_argument(\\n+ \\\"--cpu\\\", default=False, action=\\\"store_true\\\", help=\\\"Whether or not to force the training on the CPU.\\\"\\n+ )\\n parser.add_argument(\\n \\\"--num_processes\\\", type=int, default=None, help=\\\"The total number of processes to be launched in parallel.\\\"\\n )\\n@@ -77,6 +80,7 @@ def simple_launcher(args):\\n cmd.extend(args.training_script_args)\\n \\n current_env = os.environ.copy()\\n+ current_env[\\\"USE_CPU\\\"] = str(args.cpu)\\n current_env[\\\"USE_FP16\\\"] = str(args.fp16)\\n \\n process = subprocess.Popen(cmd, env=current_env)\\n@@ -143,7 +147,7 @@ def launch_command(args):\\n raise ValueError(\\\"You can only pick one between `--multi_gpu` and `--tpu`.\\\")\\n \\n # Get the default from the config file.\\n- if args.config_file is not None or os.path.isfile(default_config_file):\\n+ if args.config_file is not None or os.path.isfile(default_config_file) and not args.cpu:\\n defaults = LaunchConfig.from_json_file(json_file=args.config_file)\\n if not args.multi_gpu and not args.tpu:\\n args.multi_gpu = defaults.distributed_type == DistributedType.MULTI_GPU\\n@@ -157,9 +161,9 @@ def launch_command(args):\\n args.num_processes = 1\\n \\n # Use the proper launcher\\n- if args.multi_gpu:\\n+ if args.multi_gpu and not args.cpu:\\n multi_gpu_launcher(args)\\n- elif args.tpu:\\n+ elif args.tpu and not args.cpu:\\n tpu_launcher(args)\\n else:\\n simple_launcher(args)\\n\",\n \"code_comments\": [\n {\n \"body\": \"```suggestion\\r\\n+ accelerator = Accelerator(device_placement=False)\\r\\n```\\r\\nThe default is still `True` as it's safer for the user (and it still takes one line of code to have the default to `False`). If the table has space enough, I'd add the same example with the device placement handled by `accelerate` (like the current example below).\",\n \"diff_hunk\": \"@@ -34,7 +34,98 @@\\n <p>Run your *raw* PyTorch training script on any kind of device\\n </h3>\\n \\n-π€ Accelerate provides an easy API to make your scripts run with mixed precision and on any kind of distributed setting (multi-GPUs, TPUs etc.) while still letting you write your own training loop. The same code can then run on your local machine for debugging or your training environment.\\n+π€ Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boiler code needed to use multi-GPUs/TPU/fp16.\\n+\\n+π€ Accelerate abstracts exactly and only the boiler code related to multi-GPUs/TPU/fp16 and let the rest of your code unchanged.\\n+\\n+Here is an example:\\n+\\n+<table>\\n+<tr>\\n+<th> Original training code (CPU or mono-GPU only)</th>\\n+<th> With Accelerate for CPU/GPU/multi-GPUs/TPUs/fp16 </th>\\n+</tr>\\n+<tr>\\n+<td>\\n+\\n+```python\\n+import torch\\n+import torch.nn.functional as F\\n+from datasets import load_dataset\\n+\\n+\\n+\\n+device = 'cpu'\\n+\\n+model = torch.nn.Transformer().to(device)\\n+optim = torch.optim.Adam(model.parameters())\\n+\\n+dataset = load_dataset('my_dataset')\\n+data = torch.utils.data.Dataloader(dataset)\\n+\\n+\\n+\\n+\\n+model.train()\\n+for epoch in range(10):\\n+ for source, targets in data:\\n+ source = source.to(device)\\n+ targets = targets.to(device)\\n+\\n+ optimizer.zero_grad()\\n+\\n+ output = model(source, targets)\\n+ loss = F.cross_entropy(output, targets)\\n+\\n+ loss.backward()\\n+\\n+ optimizer.step()\\n+```\\n+\\n+</td>\\n+<td>\\n+\\n+```python\\n+ import torch\\n+ import torch.nn.functional as F\\n+ from datasets import load_dataset\\n+\\n++ from accelerate import Accelerator\\n++ accelerator = Accelerator()\",\n \"from_author\": false\n }\n ],\n \"context\": [],\n \"url\": \"https://api.github.com/repos/huggingface/accelerate/pulls/1\",\n \"pr_id\": 577481934\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":1,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Mjc1MTEwMiwic3ViIjoiL2RhdGFzZXRzL211ZWxsZXJ6ci9naXRodWItcHItaGlzdG9yeSIsImV4cCI6MTc3Mjc1NDcwMiwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.iII2neZWaYco1GVJEV0SHwxTpUGskvqPrSdAtD_G9hnk3W-iB6RF8GpXoQdhDxUWYwPVvtO8Wq_lnvc2_Z6zCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":1,"numBytesParquet":1637411}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
train list |
|---|
[
{
"diff": "diff --git a/src/accelerate/utils/modeling.py b/src/accelerate/utils/modeling.py\nindex c58cfeb50..679e57ff2 100644\n--- a/src/accelerate/utils/modeling.py\n+++ b/src/accelerate/utils/modeling.py\n@@ -666,7 +666,7 @@ def load_checkpoint_in_model(\n elif len(potential_index) == 1:\n ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.