diff --git a/src/accelerate/accelerator.py b/src/accelerate/accelerator.py
index 63ea4a71b..ad22c8ee4 100644
--- a/src/accelerate/accelerator.py
+++ b/src/accelerate/accelerator.py
@@ -36,6 +36,7 @@
     DeepSpeedPlugin,
     DistributedDataParallelKwargs,
     DistributedType,
+    DynamoBackend,
     FullyShardedDataParallelPlugin,
     GradScalerKwargs,
     InitProcessGroupKwargs,
@@ -163,6 +164,8 @@ class Accelerator:
         kwargs_handlers (`List[KwargHandler]`, *optional*)
             A list of `KwargHandler` to customize how the objects related to distributed training or mixed precision
             are created. See [kwargs](kwargs) for more information.
+        dynamo_backend (`str` or `DynamoBackend`, *optional*, defaults to `"no"`):
+            Set to one of the possible dynamo backends to optimize your training with torch dynamo.
 
     **Available attributes:**
 
@@ -198,6 +201,7 @@ def __init__(
         even_batches: bool = True,
         step_scheduler_with_optimizer: bool = True,
         kwargs_handlers: Optional[List[KwargsHandler]] = None,
+        dynamo_backend: Union[DynamoBackend, str] = None,
     ):
         self.logging_dir = logging_dir
         trackers = filter_trackers(log_with, self.logging_dir)
@@ -219,6 +223,9 @@ def __init__(
             )
             mixed_precision = "fp16"
 
+        if dynamo_backend is not None:
+            dynamo_backend = DynamoBackend(dynamo_backend.upper())
+
         if deepspeed_plugin is None:  # init from env variables
             deepspeed_plugin = DeepSpeedPlugin() if os.environ.get("USE_DEEPSPEED", "false") == "true" else None
         else:
@@ -285,6 +292,7 @@ def __init__(
         self.state = AcceleratorState(
             mixed_precision=mixed_precision,
             cpu=cpu,
+            dynamo_backend=dynamo_backend,
             deepspeed_plugin=deepspeed_plugin,
             fsdp_plugin=fsdp_plugin,
             megatron_lm_plugin=megatron_lm_plugin,
@@ -793,6 +801,10 @@ def prepare_model(self, model: torch.nn.Module, device_placement=None):
         self._models.append(model)
         if device_placement:
             model = model.to(self.device)
+        if self.state.dynamo_backend != DynamoBackend.NO:
+            import torch._dynamo as dynamo
+
+            model = dynamo.optimize(self.state.dynamo_backend.value.lower())(model)
         if self.distributed_type == DistributedType.MULTI_GPU:
             if any(p.requires_grad for p in model.parameters()):
                 kwargs = self.ddp_handler.to_kwargs() if self.ddp_handler is not None else {}
diff --git a/src/accelerate/commands/config/cluster.py b/src/accelerate/commands/config/cluster.py
index aa61a6857..5f032debc 100644
--- a/src/accelerate/commands/config/cluster.py
+++ b/src/accelerate/commands/config/cluster.py
@@ -16,7 +16,13 @@
 
 import os
 
-from ...utils import ComputeEnvironment, DistributedType, is_deepspeed_available, is_transformers_available
+from ...utils import (
+    ComputeEnvironment,
+    DistributedType,
+    DynamoBackend,
+    is_deepspeed_available,
+    is_transformers_available,
+)
 from ...utils.constants import (
     DEEPSPEED_MULTINODE_LAUNCHERS,
     FSDP_AUTO_WRAP_POLICY,
@@ -25,7 +31,7 @@
     FSDP_STATE_DICT_TYPE,
 )
 from .config_args import ClusterConfig
-from .config_utils import _ask_field, _convert_distributed_mode, _convert_yes_no_to_bool
+from .config_utils import _ask_field, _convert_distributed_mode, _convert_dynamo_backend, _convert_yes_no_to_bool
 
 
 def get_cluster_input():
@@ -89,6 +95,22 @@ def get_cluster_input():
     else:
         use_cpu = False
 
+    use_dynamo = _ask_field(
+        "Do you wish to optimize your script with torch dynamo?[yes/NO]:",
+        _convert_yes_no_to_bool,
+        default=False,
+        error_message="Please enter yes or no.",
+    )
+    if use_dynamo:
+        dynamo_backend = _ask_field(
+            "Which dynamo backend would you like to use? ([0] eager, [1] aot_eager, [2] inductor, [3] nvfuser, [5] aot_nvfuser, [6] aot_cudagraphs, [7] ofi, [8] onnxrt, [9] ipex) [2]: ",
+            _convert_dynamo_backend,
+            default=DynamoBackend.INDUCTOR,
+            error_message="Please enter 0, 1, 2, 3, 4, 5, 6, 7, 8 or 9.",
+        )
+    else:
+        dynamo_backend = DynamoBackend.NO
+
     deepspeed_config = {}
     if distributed_type in [DistributedType.MULTI_GPU, DistributedType.NO]:
         use_deepspeed = _ask_field(
@@ -446,6 +468,11 @@ def get_cluster_input():
     else:
         mixed_precision = "no"
 
+    if use_dynamo and mixed_precision == "no" and not use_cpu:
+        print(
+            "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."
+        )
+
     downcast_bf16 = "no"
     if distributed_type == DistributedType.TPU and mixed_precision == "bf16":
         downcast_bf16 = _ask_field(
@@ -474,4 +501,5 @@ def get_cluster_input():
         tpu_zone=tpu_zone,
         commands=commands,
         command_file=command_file,
+        dynamo_backend=dynamo_backend,
     )
diff --git a/src/accelerate/commands/config/config_args.py b/src/accelerate/commands/config/config_args.py
index a5a841900..ba492802e 100644
--- a/src/accelerate/commands/config/config_args.py
+++ b/src/accelerate/commands/config/config_args.py
@@ -22,7 +22,7 @@
 
 import yaml
 
-from ...utils import ComputeEnvironment, DistributedType, SageMakerDistributedType
+from ...utils import ComputeEnvironment, DistributedType, DynamoBackend, SageMakerDistributedType
 from ...utils.constants import SAGEMAKER_PYTHON_VERSION, SAGEMAKER_PYTORCH_VERSION, SAGEMAKER_TRANSFORMERS_VERSION
 
 
@@ -70,6 +70,7 @@ class BaseConfig:
     distributed_type: Union[DistributedType, SageMakerDistributedType]
     mixed_precision: str
     use_cpu: bool
+    dynamo_backend: DynamoBackend
 
     def to_dict(self):
         result = self.__dict__
@@ -92,6 +93,8 @@ def from_json_file(cls, json_file=None):
             del config_dict["fp16"]
         if "use_cpu" not in config_dict:
             config_dict["use_cpu"] = False
+        if "dynamo_backend" not in config_dict:
+            config_dict["dynamo_backend"] = DynamoBackend.NO
         return cls(**config_dict)
 
     def to_json_file(self, json_file):
@@ -113,6 +116,8 @@ def from_yaml_file(cls, yaml_file=None):
             del config_dict["fp16"]
         if "use_cpu" not in config_dict:
             config_dict["use_cpu"] = False
+        if "dynamo_backend" not in config_dict:
+            config_dict["dynamo_backend"] = DynamoBackend.NO
 
         return cls(**config_dict)
 
@@ -128,6 +133,8 @@ def __post_init__(self):
                 self.distributed_type = SageMakerDistributedType(self.distributed_type)
             else:
                 self.distributed_type = DistributedType(self.distributed_type)
+        if isinstance(self.dynamo_backend, str):
+            self.dynamo_backend = DynamoBackend(self.dynamo_backend.upper())
 
 
 @dataclass
diff --git a/src/accelerate/commands/config/config_utils.py b/src/accelerate/commands/config/config_utils.py
index 9dd1f4c99..8974cddc9 100644
--- a/src/accelerate/commands/config/config_utils.py
+++ b/src/accelerate/commands/config/config_utils.py
@@ -14,7 +14,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...utils.dataclasses import ComputeEnvironment, DistributedType, SageMakerDistributedType
+from ...utils.dataclasses import ComputeEnvironment, DistributedType, DynamoBackend, SageMakerDistributedType
+
+
+DYNAMO_BACKENDS = [
+    "EAGER",
+    "AOT_EAGER",
+    "INDUCTOR",
+    "NVFUSER",
+    "AOT_NVFUSER",
+    "AOT_CUDAGRAPHS",
+    "OFI",
+    "FX2TRT",
+    "ONNXRT",
+    "IPEX",
+]
 
 
 def _ask_field(input_text, convert_value=None, default=None, error_message=None):
@@ -40,6 +54,11 @@ def _convert_distributed_mode(value):
     return DistributedType(["NO", "MULTI_CPU", "MULTI_GPU", "TPU", "MPS"][value])
 
 
+def _convert_dynamo_backend(value):
+    value = int(value)
+    return DynamoBackend(DYNAMO_BACKENDS[value + 1])
+
+
 def _convert_sagemaker_distributed_mode(value):
     value = int(value)
     return SageMakerDistributedType(["NO", "DATA_PARALLEL", "MODEL_PARALLEL"][value])
diff --git a/src/accelerate/commands/config/sagemaker.py b/src/accelerate/commands/config/sagemaker.py
index b3a45c9e4..71de4fea9 100644
--- a/src/accelerate/commands/config/sagemaker.py
+++ b/src/accelerate/commands/config/sagemaker.py
@@ -17,10 +17,15 @@
 import os
 
 from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES
-from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
+from ...utils.dataclasses import ComputeEnvironment, DynamoBackend, SageMakerDistributedType
 from ...utils.imports import is_boto3_available
 from .config_args import SageMakerConfig
-from .config_utils import _ask_field, _convert_sagemaker_distributed_mode, _convert_yes_no_to_bool
+from .config_utils import (
+    _ask_field,
+    _convert_dynamo_backend,
+    _convert_sagemaker_distributed_mode,
+    _convert_yes_no_to_bool,
+)
 
 
 if is_boto3_available():
@@ -162,6 +167,22 @@ def get_sagemaker_input():
         error_message="Please enter 0 or 1",
     )
 
+    use_dynamo = _ask_field(
+        "Do you wish to optimize your script with torch dynamo?[yes/NO]:",
+        _convert_yes_no_to_bool,
+        default=False,
+        error_message="Please enter yes or no.",
+    )
+    if use_dynamo:
+        dynamo_backend = _ask_field(
+            "Which dynamo backend would you like to use? ([0] eager, [1] aot_eager, [2] inductor, [3] nvfuser, [5] aot_nvfuser, [6] aot_cudagraphs, [7] ofi, [8] onnxrt, [9] ipex) [2]: ",
+            _convert_dynamo_backend,
+            default=DynamoBackend.INDUCTOR,
+            error_message="Please enter 0, 1, 2, 3, 4, 5, 6, 7, 8 or 9.",
+        )
+    else:
+        dynamo_backend = DynamoBackend.NO
+
     ec2_instance_query = "Which EC2 instance type you want to use for your training "
     if distributed_type != SageMakerDistributedType.NO:
         ec2_instance_query += "("
@@ -186,15 +207,21 @@ def get_sagemaker_input():
 
     mixed_precision = _ask_field(
         "Do you wish to use FP16 or BF16 (mixed precision)? [No/FP16/BF16]: ",
-        lambda x: str(x),
-        default="No",
+        lambda x: str(x).lower(),
+        default="no",
     )
 
+    if use_dynamo and mixed_precision == "no":
+        print(
+            "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."
+        )
+
     return SageMakerConfig(
         image_uri=docker_image,
         compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER,
         distributed_type=distributed_type,
         use_cpu=False,
+        dynamo_backend=dynamo_backend,
         ec2_instance_type=ec2_instance_type,
         profile=aws_profile,
         region=aws_region,
diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py
index 46d95c713..d96ab2f45 100644
--- a/src/accelerate/commands/launch.py
+++ b/src/accelerate/commands/launch.py
@@ -30,10 +30,12 @@
 import psutil
 from accelerate.commands.config import default_config_file, load_config_from_file
 from accelerate.commands.config.config_args import SageMakerConfig
+from accelerate.commands.config.config_utils import DYNAMO_BACKENDS
 from accelerate.state import get_int_from_env
 from accelerate.utils import (
     ComputeEnvironment,
     DistributedType,
+    DynamoBackend,
     PrecisionType,
     PrepareForLaunch,
     _filter_args,
@@ -171,6 +173,13 @@ def launch_command_parser(subparsers=None):
     resource_args = parser.add_argument_group(
         "Resource Selection Arguments", "Arguments for fine-tuning how available hardware should be used."
     )
+    resource_args.add_argument(
+        "--dynamo_backend",
+        type=str,
+        choices=["no"] + [b.lower() for b in DYNAMO_BACKENDS],
+        help="Choose a backend to optimize your training with dynamo, see more at "
+        "https://github.com/pytorch/torchdynamo.",
+    )
     resource_args.add_argument(
         "--mixed_precision",
         type=str,
@@ -546,6 +555,13 @@ def simple_launcher(args):
         mixed_precision = "fp16"
 
     current_env["MIXED_PRECISION"] = str(mixed_precision)
+
+    try:
+        dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
+    except ValueError:
+        raise ValueError(f"Unknown dynamo backend: {args.dynamo_backend.upper()}. Choose between {DYNAMO_BACKENDS}.")
+    current_env["DYNAMO_BACKEND"] = dynamo_backend.value
+
     current_env["OMP_NUM_THREADS"] = str(args.num_cpu_threads_per_process)
 
     process = subprocess.Popen(cmd, env=current_env)
@@ -598,6 +614,13 @@ def multi_gpu_launcher(args):
         mixed_precision = "fp16"
 
     current_env["MIXED_PRECISION"] = str(mixed_precision)
+
+    try:
+        dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
+    except ValueError:
+        raise ValueError(f"Unknown dynamo backend: {args.dynamo_backend.upper()}. Choose between {DYNAMO_BACKENDS}.")
+    current_env["DYNAMO_BACKEND"] = dynamo_backend.value
+
     if args.use_fsdp:
         current_env["USE_FSDP"] = "true"
         current_env["FSDP_SHARDING_STRATEGY"] = str(args.fsdp_sharding_strategy)
@@ -893,10 +916,16 @@ def sagemaker_launcher(sagemaker_config: SageMakerConfig, args):
         warnings.warn('--fp16 flag is deprecated. Use "--mixed_precision fp16" instead.', FutureWarning)
         mixed_precision = "fp16"
 
+    try:
+        dynamo_backend = DynamoBackend(args.dynamo_backend.upper())
+    except ValueError:
+        raise ValueError(f"Unknown dynamo backend: {args.dynamo_backend.upper()}. Choose between {DYNAMO_BACKENDS}.")
+
     # Environment variables to be set for use during training job
     environment = {
         "USE_SAGEMAKER": "true",
         "MIXED_PRECISION": str(mixed_precision),
+        "DYNAMO_BACKEND": dynamo_backend.value,
         "SAGEMAKER_DISTRIBUTED_TYPE": sagemaker_config.distributed_type.value,
     }
     # configure distribution set up
@@ -1017,6 +1046,9 @@ def launch_command(args):
                 args.mixed_precision = "fp16"
             else:
                 args.mixed_precision = defaults.mixed_precision
+        if args.dynamo_backend is None:
+            warned.append("\t`--dynamo_backend` was set to a value of `'no'`")
+            args.dynamo_backend = "no"
     else:
         if args.num_processes is None:
             args.num_processes = torch.cuda.device_count() if args.multi_gpu else 1
@@ -1029,6 +1061,9 @@ def launch_command(args):
             args.mixed_precision = "no"
         if not hasattr(args, "use_cpu"):
             args.use_cpu = args.cpu
+        if args.dynamo_backend is None:
+            warned.append("\t`--dynamo_backend` was set to a value of `'no'`")
+            args.dynamo_backend = "no"
 
     if args.num_cpu_threads_per_process is None:
         args.num_cpu_threads_per_process = 1
diff --git a/src/accelerate/state.py b/src/accelerate/state.py
index 00ba3ab67..18df61bbc 100644
--- a/src/accelerate/state.py
+++ b/src/accelerate/state.py
@@ -19,6 +19,7 @@
 
 from .utils import (
     DistributedType,
+    DynamoBackend,
     get_ccl_version,
     get_int_from_env,
     is_ccl_available,
@@ -57,6 +58,7 @@ def __init__(
         self,
         mixed_precision: str = None,
         cpu: bool = False,
+        dynamo_backend=None,
         deepspeed_plugin=None,
         fsdp_plugin=None,
         megatron_lm_plugin=None,
@@ -74,6 +76,10 @@ def __init__(
             mixed_precision = (
                 parse_choice_from_env("MIXED_PRECISION", "no") if mixed_precision is None else mixed_precision.lower()
             )
+            dynamo_backend = (
+                parse_choice_from_env("DYNAMO_BACKEND", "no") if dynamo_backend is None else dynamo_backend
+            )
+            self.dynamo_backend = DynamoBackend(dynamo_backend.upper())
             if not _from_accelerator:
                 raise ValueError(
                     "Please make sure to properly initialize your accelerator via `accelerator = Accelerator()` "
@@ -230,6 +236,9 @@ def __init__(
                 else:
                     self.device = torch.device("cuda")
                 self.mixed_precision = mixed_precision
+
+            if self.dynamo_backend != DynamoBackend.NO and self.mixed_precision == "no" and self.device.type == "cuda":
+                torch.backends.cuda.matmul.allow_tf32 = True
             self.initialized = True
 
     def __repr__(self):
diff --git a/src/accelerate/utils/__init__.py b/src/accelerate/utils/__init__.py
index a017a2ad5..3ad09ecab 100644
--- a/src/accelerate/utils/__init__.py
+++ b/src/accelerate/utils/__init__.py
@@ -8,6 +8,7 @@
     DeepSpeedPlugin,
     DistributedDataParallelKwargs,
     DistributedType,
+    DynamoBackend,
     FullyShardedDataParallelPlugin,
     GradScalerKwargs,
     InitProcessGroupKwargs,
diff --git a/src/accelerate/utils/dataclasses.py b/src/accelerate/utils/dataclasses.py
index 7dd8798e9..e51576865 100644
--- a/src/accelerate/utils/dataclasses.py
+++ b/src/accelerate/utils/dataclasses.py
@@ -164,6 +164,50 @@ class ComputeEnvironment(str, enum.Enum):
     AMAZON_SAGEMAKER = "AMAZON_SAGEMAKER"
 
 
+class DynamoBackend(str, enum.Enum):
+    """
+    Represents a dynamo backend (see https://github.com/pytorch/torchdynamo).
+
+    Values:
+
+        - **NO** -- Do not use torch dynamo.
+        - **EAGER** -- Uses PyTorch to run the extracted GraphModule. This is quite useful in debugging TorchDynamo
+          issues.
+        - **AOT_EAGER** -- Uses AotAutograd with no compiler, i.e, just using PyTorch eager for the AotAutograd's
+          extracted forward and backward graphs. This is useful for debugging, and unlikely to give speedups.
+        - **INDUCTOR** -- Uses TorchInductor backend with AotAutograd and cudagraphs by leveraging codegened Triton
+          kernels. [Read
+          more](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
+        - **NVFUSER** -- nvFuser with TorchScript. [Read
+          more](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
+        - **AOT_NVFUSER** -- nvFuser with AotAutograd. [Read
+          more](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
+        - **AOT_CUDAGRAPHS** -- cudagraphs with AotAutograd. [Read
+          more](https://github.com/pytorch/torchdynamo/pull/757)
+        - **OFI** -- Uses Torchscript optimize_for_inference. Inference only. [Read
+          more](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
+        - **FX2TRT** -- Uses Nvidia TensorRT for inference optimizations. Inference only. [Read
+          more](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
+        - **ONNXRT** -- Uses ONNXRT for inference on CPU/GPU. Inference only. [Read more](https://onnxruntime.ai/)
+        - **IPEX** -- Uses IPEX for inference on CPU. Inference only. [Read
+          more](https://github.com/intel/intel-extension-for-pytorch).
+
+    """
+
+    # Subclassing str as well as Enum allows the `SageMakerDistributedType` to be JSON-serializable out of the box.
+    NO = "NO"
+    EAGER = "EAGER"
+    AOT_EAGER = "AOT_EAGER"
+    INDUCTOR = "INDUCTOR"
+    NVFUSER = "NVFUSER"
+    AOT_NVFUSER = "AOT_NVFUSER"
+    AOT_CUDAGRAPHS = "AOT_CUDAGRAPHS"
+    OFI = "OFI"
+    FX2TRT = "FX2TRT"
+    ONNXRT = "ONNXRT"
+    IPEX = "IPEX"
+
+
 class EnumWithContains(enum.EnumMeta):
     "A metaclass that adds the ability to check if `self` contains an item with the `in` operator"
 
diff --git a/src/accelerate/utils/other.py b/src/accelerate/utils/other.py
index ff360038d..f1af373b6 100644
--- a/src/accelerate/utils/other.py
+++ b/src/accelerate/utils/other.py
@@ -115,7 +115,7 @@ def get_pretty_name(obj):
     return str(obj)
 
 
-def write_basic_config(mixed_precision="no", save_location: str = default_json_config_file):
+def write_basic_config(mixed_precision="no", save_location: str = default_json_config_file, dynamo_backend="no"):
     """
     Creates and saves a basic cluster config to be used on a local machine with potentially multiple GPUs. Will also
     set CPU if it is a CPU-only machine.
@@ -138,7 +138,11 @@ def write_basic_config(mixed_precision="no", save_location: str = default_json_c
     mixed_precision = mixed_precision.lower()
     if mixed_precision not in ["no", "fp16", "bf16"]:
         raise ValueError(f"`mixed_precision` should be one of 'no', 'fp16', or 'bf16'. Received {mixed_precision}")
-    config = {"compute_environment": "LOCAL_MACHINE", "mixed_precision": mixed_precision}
+    config = {
+        "compute_environment": "LOCAL_MACHINE",
+        "mixed_precision": mixed_precision,
+        "dynamo_backend": dynamo_backend,
+    }
     if torch.cuda.is_available():
         num_gpus = torch.cuda.device_count()
         config["num_processes"] = num_gpus


Review comments: body: ```suggestion
            Set to one of the possible dynamo backends to optimize your training with torch dynamo.
```

diff_hunk: @@ -163,6 +164,8 @@ class Accelerator:
         kwargs_handlers (`List[KwargHandler]`, *optional*)
             A list of `KwargHandler` to customize how the objects related to distributed training or mixed precision
             are created. See [kwargs](kwargs) for more information.
+        dynamo_backend (`str` or `DynamoBackend`, *optional*, defaults to `"no"`):
+            Set to one of the possible dynamo backends to optimizer your training with torch dynamo.
body: ```suggestion
            if self.dynamo_backend != DynamoBackend.NO and self.mixed_precision == "no" and self.device.type == "cuda":
```

diff_hunk: @@ -230,6 +236,9 @@ def __init__(
                 else:
                     self.device = torch.device("cuda")
                 self.mixed_precision = mixed_precision
+
+            if self.dynamo_backend != DynamoBackend.NO and self.mixed_precision != "no" and self.device.type == "cuda":

Discussion: body: The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_829). All of your documentation changes will be reflected on that endpoint.
body: The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_829). All of your documentation changes will be reflected on that endpoint.
body: The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_829). All of your documentation changes will be reflected on that endpoint.
body: The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/accelerate/pr_829). All of your documentation changes will be reflected on that endpoint.