+
+
+
+
+
+
+A community member has taken the idea and expanded it further, allowing you to filter models directly and see if you can run a particular LLM given GPU constraints and LoRA configurations. To play with it, see [here](https://huggingface.co/spaces/Vokturz/can-it-run-llm) for more details.
+
+## The Command
+
+When using `accelerate estimate-memory`, you need to pass in the name of the model you want to use, potentially the framework
+that model utilizing (if it can't be found automatically), and the data types you want the model to be loaded in with.
+
+For example, here is how we can calculate the memory footprint for `bert-base-cased`:
+
+```bash
+accelerate estimate-memory bert-base-cased
+```
+
+This will download the `config.json` for `bert-based-cased`, load the model on the `meta` device, and report back how much space
+it will use:
+
+Memory Usage for loading `bert-base-cased`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 84.95 MB | 418.18 MB | 1.61 GB |
+| float16 | 42.47 MB | 206.59 MB | 826.36 MB |
+| int8 | 21.24 MB | 103.29 MB | 413.18 MB |
+| int4 | 10.62 MB | 51.65 MB | 206.59 MB |
+
+By default it will return all the supported dtypes (`int4` through `float32`), but if you are interested in specific ones these can be filtered.
+
+### Specific libraries
+
+If the source library cannot be determined automatically (like it could in the case of `bert-base-cased`), a library name can
+be passed in.
+
+```bash
+accelerate estimate-memory HuggingFaceM4/idefics-80b-instruct --library_name transformers
+```
+
+Memory Usage for loading `HuggingFaceM4/idefics-80b-instruct`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 3.02 GB | 297.12 GB | 1.16 TB |
+| float16 | 1.51 GB | 148.56 GB | 594.24 GB |
+| int8 | 772.52 MB | 74.28 GB | 297.12 GB |
+| int4 | 386.26 MB | 37.14 GB | 148.56 GB |
+
+
+```bash
+accelerate estimate-memory timm/resnet50.a1_in1k --library_name timm
+```
+
+Memory Usage for loading `timm/resnet50.a1_in1k`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 9.0 MB | 97.7 MB | 390.78 MB |
+| float16 | 4.5 MB | 48.85 MB | 195.39 MB |
+| int8 | 2.25 MB | 24.42 MB | 97.7 MB |
+| int4 | 1.12 MB | 12.21 MB | 48.85 MB |
+
+### Specific dtypes
+
+As mentioned earlier, while we return `int4` through `float32` by default, any dtype can be used from `float32`, `float16`, `int8`, and `int4`.
+
+To do so, pass them in after specifying `--dtypes`:
+
+```bash
+accelerate estimate-memory bert-base-cased --dtypes float32 float16
+```
+
+Memory Usage for loading `bert-base-cased`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 84.95 MB | 413.18 MB | 1.61 GB |
+| float16 | 42.47 MB | 206.59 MB | 826.36 MB |
+
+## Caveats with this calculator
+
+This calculator will tell you how much memory is needed to purely load the model in, *not* to perform inference.
+
+This calculation is accurate within a few % of the actual value, so it is a very good view of just how much memory it will take. For instance loading `bert-base-cased` actually takes `413.68 MB` when loaded on CUDA in full precision, and the calculator estimates `413.18 MB`.
+
+When performing inference you can expect to add up to an additional 20% as found by [EleutherAI](https://blog.eleuther.ai/transformer-math/). We'll be conducting research into finding a more accurate estimate to these values, and will update
+this calculator once done.
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/mps.md b/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/mps.md
new file mode 100644
index 0000000000000000000000000000000000000000..8bd2912d79cc6138ea605b5699f134318144151b
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/mps.md
@@ -0,0 +1,54 @@
+
+
+# Accelerated PyTorch Training on Mac
+
+With PyTorch v1.12 release, developers and researchers can take advantage of Apple silicon GPUs for significantly faster model training.
+This unlocks the ability to perform machine learning workflows like prototyping and fine-tuning locally, right on Mac.
+Apple's Metal Performance Shaders (MPS) as a backend for PyTorch enables this and can be used via the new `"mps"` device.
+This will map computational graphs and primitives on the MPS Graph framework and tuned kernels provided by MPS.
+For more information please refer official documents [Introducing Accelerated PyTorch Training on Mac](https://pytorch.org/blog/introducing-accelerated-pytorch-training-on-mac/)
+and [MPS BACKEND](https://pytorch.org/docs/stable/notes/mps.html).
+
+### Benefits of Training and Inference using Apple Silicon Chips
+
+1. Enables users to train larger networks or batch sizes locally
+2. Reduces data retrieval latency and provides the GPU with direct access to the full memory store due to unified memory architecture.
+Therefore, improving end-to-end performance.
+3. Reduces costs associated with cloud-based development or the need for additional local GPUs.
+
+**Pre-requisites**: To install torch with mps support,
+please follow this nice medium article [GPU-Acceleration Comes to PyTorch on M1 Macs](https://medium.com/towards-data-science/gpu-acceleration-comes-to-pytorch-on-m1-macs-195c399efcc1).
+
+
+## How it works out of the box
+It is enabled by default on MacOs machines with MPS enabled Apple Silicon GPUs.
+To disable it, pass `--cpu` flag to `accelerate launch` command or answer the corresponding question when answering the `accelerate config` questionnaire.
+
+You can directly run the following script to test it out on MPS enabled Apple Silicon machines:
+```bash
+accelerate launch /examples/cv_example.py --data_dir images
+```
+
+## A few caveats to be aware of
+
+1. We strongly recommend to install PyTorch >= 1.13 (nightly version at the time of writing) on your MacOS machine.
+It has major fixes related to model correctness and performance improvements for transformer based models.
+Please refer to https://github.com/pytorch/pytorch/issues/82707 for more details.
+2. Distributed setups `gloo` and `nccl` are not working with `mps` device.
+This means that currently only single GPU of `mps` device type can be used.
+
+Finally, please, remember that, 🤗 `Accelerate` only integrates MPS backend, therefore if you
+have any problems or questions with regards to MPS backend usage, please, file an issue with [PyTorch GitHub](https://github.com/pytorch/pytorch/issues).
\ No newline at end of file
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/profiler.md b/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/profiler.md
new file mode 100644
index 0000000000000000000000000000000000000000..be32193135eae2527f22f682bb926e65d7467846
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/docs/source/usage_guides/profiler.md
@@ -0,0 +1,334 @@
+
+
+# Profiler
+
+Profiler is a tool that allows the collection of performance metrics during training and inference. Profiler’s context manager API can be used to better understand what model operators are the most expensive, examine their input shapes and stack traces, study device kernel activity, and visualize the execution trace. It provides insights into the performance of your model, allowing you to optimize and improve it.
+
+This guide explains how to use PyTorch Profiler to measure the time and memory consumption of the model’s operators and how to integrate this with 🤗 Accelerate. We will cover various use cases and provide examples for each.
+
+## Using profiler to analyze execution time
+
+Profiler allows one to check which operators were called during the execution of a code range wrapped with a profiler context manager.
+
+Let’s see how we can use profiler to analyze the execution time:
+
+
+
+ 
+
+
+ +
+
+ 
+ 
+ 
+ 
+
+
Run your *raw* PyTorch training script on any kind of device + + +
+ 
+
+
+## Easy to integrate
+
+🤗 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.
+
+🤗 Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.
+
+Here is an example:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
++ accelerator = Accelerator()
+- device = 'cpu'
++ device = accelerator.device
+
+ model = torch.nn.Transformer().to(device)
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+ source = source.to(device)
+ targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+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 (fp8, fp16, bf16).
+
+In particular, the same code can then be run without modification on your local machine for debugging or your training environment.
+
+🤗 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:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
+- device = 'cpu'
++ accelerator = Accelerator()
+
+- model = torch.nn.Transformer().to(device)
++ model = torch.nn.Transformer()
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+- source = source.to(device)
+- targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+Want to learn more? Check out the [documentation](https://huggingface.co/docs/accelerate) or have a look at our [examples](https://github.com/huggingface/accelerate/tree/main/examples).
+
+## Launching script
+
+🤗 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.run` or to write a specific launcher for TPU training!
+On your machine(s) just run:
+
+```bash
+accelerate config
+```
+
+and answer the questions asked. This will generate a config file that will be used automatically to properly set the default options when doing
+
+```bash
+accelerate launch my_script.py --args_to_my_script
+```
+
+For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):
+
+```bash
+accelerate launch examples/nlp_example.py
+```
+
+This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torchrun my_script.py` at your convenience.
+
+You can also directly pass in the arguments you would to `torchrun` as arguments to `accelerate launch` if you wish to not run` accelerate config`.
+
+For example, here is how to launch on two GPUs:
+
+```bash
+accelerate launch --multi_gpu --num_processes 2 examples/nlp_example.py
+```
+
+To learn more, check the CLI documentation available [here](https://huggingface.co/docs/accelerate/package_reference/cli).
+
+Or view the configuration zoo [here](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates/)
+
+## Launching multi-CPU run using MPI
+
+🤗 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.
+Once you have MPI setup on your cluster, just run:
+```bash
+accelerate config
+```
+Answer the questions that are asked, selecting to run using multi-CPU, and answer "yes" when asked if you want accelerate to launch mpirun.
+Then, use `accelerate launch` with your script like:
+```bash
+accelerate launch examples/nlp_example.py
+```
+Alternatively, you can use mpirun directly, without using the CLI like:
+```bash
+mpirun -np 2 python examples/nlp_example.py
+```
+
+## Launching training using DeepSpeed
+
+🤗 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`.
+
+```python
+from accelerate import Accelerator, DeepSpeedPlugin
+
+# deepspeed needs to know your gradient accumulation steps beforehand, so don't forget to pass it
+# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed
+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)
+accelerator = Accelerator(mixed_precision='fp16', deepspeed_plugin=deepspeed_plugin)
+
+# How to save your 🤗 Transformer?
+accelerator.wait_for_everyone()
+unwrapped_model = accelerator.unwrap_model(model)
+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
+```
+
+Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.
+
+## Launching your training from a notebook
+
+🤗 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:
+
+```python
+from accelerate import notebook_launcher
+
+notebook_launcher(training_function)
+```
+
+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb). [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb)
+
+## Why should I use 🤗 Accelerate?
+
+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.
+
+## Why shouldn't I use 🤗 Accelerate?
+
+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.
+
+## Frameworks using 🤗 Accelerate
+
+If you like the simplicity of 🤗 Accelerate but would prefer a higher-level abstraction around its capabilities, some frameworks and libraries that are built on top of 🤗 Accelerate are listed below:
+
+* [Amphion](https://github.com/open-mmlab/Amphion) is a toolkit for Audio, Music, and Speech Generation. Its purpose is to support reproducible research and help junior researchers and engineers get started in the field of audio, music, and speech generation research and development.
+* [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).
+* [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 training, and inference logic.
+* [fastai](https://github.com/fastai/fastai#installing) is a PyTorch framework for Deep Learning that simplifies training fast and accurate neural nets using modern best practices. fastai provides a [Learner](https://docs.fast.ai/learner.html#Learner) to handle the training, fine-tuning, and inference of deep learning algorithms.
+* [Finetuner](https://github.com/jina-ai/finetuner) is a service that enables models to create higher-quality embeddings for semantic search, visual similarity search, cross-modal text<->image search, recommendation systems, clustering, duplication detection, anomaly detection, or other uses.
+* [InvokeAI](https://github.com/invoke-ai/InvokeAI) is a creative engine for Stable Diffusion models, offering industry-leading WebUI, terminal usage support, and serves as the foundation for many commercial products.
+* [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.
+* [Open Assistant](https://projects.laion.ai/Open-Assistant/) is a chat-based assistant that understands tasks, can interact with their party systems, and retrieve information dynamically to do so.
+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centered 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!
+* [Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is an open-source browser-based easy-to-use interface based on the Gradio library for Stable Diffusion.
+* [torchkeras](https://github.com/lyhue1991/torchkeras) is a simple tool for training pytorch model just in a keras style, a dynamic and beautiful plot is provided in notebook to monitor your loss or metric.
+* [transformers](https://github.com/huggingface/transformers) as a tool for helping train state-of-the-art machine learning models in PyTorch, Tensorflow, and JAX. (Accelerate is the backend for the PyTorch side).
+
+
+## Installation
+
+This repository is tested on Python 3.8+ and PyTorch 1.10.0+
+
+You should install 🤗 Accelerate in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
+
+First, create a virtual environment with the version of Python you're going to use and activate it.
+
+Then, you will need to install PyTorch: refer to the [official installation page](https://pytorch.org/get-started/locally/#start-locally) regarding the specific install command for your platform. Then 🤗 Accelerate can be installed using pip as follows:
+
+```bash
+pip install accelerate
+```
+
+## Supported integrations
+
+- CPU only
+- multi-CPU on one node (machine)
+- multi-CPU on several nodes (machines)
+- single GPU
+- multi-GPU on one node (machine)
+- multi-GPU on several nodes (machines)
+- TPU
+- FP16/BFloat16 mixed precision
+- FP8 mixed precision with [Transformer Engine](https://github.com/NVIDIA/TransformerEngine) or [MS-AMP](https://github.com/Azure/MS-AMP/)
+- DeepSpeed support (Experimental)
+- PyTorch Fully Sharded Data Parallel (FSDP) support (Experimental)
+- Megatron-LM support (Experimental)
+
+## Citing 🤗 Accelerate
+
+If you use 🤗 Accelerate in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{accelerate,
+ title = {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
+ author = {Sylvain Gugger and Lysandre Debut and Thomas Wolf and Philipp Schmid and Zachary Mueller and Sourab Mangrulkar and Marc Sun and Benjamin Bossan},
+ howpublished = {\url{https://github.com/huggingface/accelerate}},
+ year = {2022}
+}
+```
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/SOURCES.txt b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/SOURCES.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e763988e430bf79992e082d14776262f87f0a832
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/SOURCES.txt
@@ -0,0 +1,113 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/accelerate/__init__.py
+src/accelerate/accelerator.py
+src/accelerate/big_modeling.py
+src/accelerate/checkpointing.py
+src/accelerate/data_loader.py
+src/accelerate/hooks.py
+src/accelerate/inference.py
+src/accelerate/launchers.py
+src/accelerate/local_sgd.py
+src/accelerate/logging.py
+src/accelerate/memory_utils.py
+src/accelerate/optimizer.py
+src/accelerate/scheduler.py
+src/accelerate/state.py
+src/accelerate/tracking.py
+src/accelerate.egg-info/PKG-INFO
+src/accelerate.egg-info/SOURCES.txt
+src/accelerate.egg-info/dependency_links.txt
+src/accelerate.egg-info/entry_points.txt
+src/accelerate.egg-info/requires.txt
+src/accelerate.egg-info/top_level.txt
+src/accelerate/commands/__init__.py
+src/accelerate/commands/accelerate_cli.py
+src/accelerate/commands/env.py
+src/accelerate/commands/estimate.py
+src/accelerate/commands/launch.py
+src/accelerate/commands/merge.py
+src/accelerate/commands/test.py
+src/accelerate/commands/tpu.py
+src/accelerate/commands/utils.py
+src/accelerate/commands/config/__init__.py
+src/accelerate/commands/config/cluster.py
+src/accelerate/commands/config/config.py
+src/accelerate/commands/config/config_args.py
+src/accelerate/commands/config/config_utils.py
+src/accelerate/commands/config/default.py
+src/accelerate/commands/config/sagemaker.py
+src/accelerate/commands/config/update.py
+src/accelerate/commands/menu/__init__.py
+src/accelerate/commands/menu/cursor.py
+src/accelerate/commands/menu/helpers.py
+src/accelerate/commands/menu/input.py
+src/accelerate/commands/menu/keymap.py
+src/accelerate/commands/menu/selection_menu.py
+src/accelerate/test_utils/__init__.py
+src/accelerate/test_utils/examples.py
+src/accelerate/test_utils/testing.py
+src/accelerate/test_utils/training.py
+src/accelerate/test_utils/scripts/__init__.py
+src/accelerate/test_utils/scripts/test_cli.py
+src/accelerate/test_utils/scripts/test_ddp_comm_hook.py
+src/accelerate/test_utils/scripts/test_distributed_data_loop.py
+src/accelerate/test_utils/scripts/test_merge_weights.py
+src/accelerate/test_utils/scripts/test_notebook.py
+src/accelerate/test_utils/scripts/test_ops.py
+src/accelerate/test_utils/scripts/test_script.py
+src/accelerate/test_utils/scripts/test_sync.py
+src/accelerate/test_utils/scripts/external_deps/__init__.py
+src/accelerate/test_utils/scripts/external_deps/test_checkpointing.py
+src/accelerate/test_utils/scripts/external_deps/test_metrics.py
+src/accelerate/test_utils/scripts/external_deps/test_peak_memory_usage.py
+src/accelerate/test_utils/scripts/external_deps/test_performance.py
+src/accelerate/test_utils/scripts/external_deps/test_pippy.py
+src/accelerate/test_utils/scripts/external_deps/test_zero3_integration.py
+src/accelerate/utils/__init__.py
+src/accelerate/utils/bnb.py
+src/accelerate/utils/constants.py
+src/accelerate/utils/dataclasses.py
+src/accelerate/utils/deepspeed.py
+src/accelerate/utils/environment.py
+src/accelerate/utils/fsdp_utils.py
+src/accelerate/utils/imports.py
+src/accelerate/utils/launch.py
+src/accelerate/utils/megatron_lm.py
+src/accelerate/utils/memory.py
+src/accelerate/utils/modeling.py
+src/accelerate/utils/offload.py
+src/accelerate/utils/operations.py
+src/accelerate/utils/other.py
+src/accelerate/utils/random.py
+src/accelerate/utils/rich.py
+src/accelerate/utils/torch_xla.py
+src/accelerate/utils/tqdm.py
+src/accelerate/utils/transformer_engine.py
+src/accelerate/utils/versions.py
+tests/test_accelerator.py
+tests/test_big_modeling.py
+tests/test_cli.py
+tests/test_cpu.py
+tests/test_data_loader.py
+tests/test_examples.py
+tests/test_grad_sync.py
+tests/test_hooks.py
+tests/test_imports.py
+tests/test_kwargs_handlers.py
+tests/test_logging.py
+tests/test_memory_utils.py
+tests/test_metrics.py
+tests/test_modeling_utils.py
+tests/test_multigpu.py
+tests/test_offload.py
+tests/test_optimizer.py
+tests/test_quantization.py
+tests/test_sagemaker.py
+tests/test_scheduler.py
+tests/test_state_checkpointing.py
+tests/test_tpu.py
+tests/test_tracking.py
+tests/test_utils.py
\ No newline at end of file
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/dependency_links.txt b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/dependency_links.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/entry_points.txt b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b9bf6b798b250a47a3febdf0e32c88507fbf86d
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/entry_points.txt
@@ -0,0 +1,6 @@
+[console_scripts]
+accelerate = accelerate.commands.accelerate_cli:main
+accelerate-config = accelerate.commands.config:main
+accelerate-estimate-memory = accelerate.commands.estimate:main
+accelerate-launch = accelerate.commands.launch:main
+accelerate-merge-weights = accelerate.commands.merge:main
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/requires.txt b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/requires.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b46dedf51817512f3916b4bc6cac265e0e8e2ac1
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/requires.txt
@@ -0,0 +1,86 @@
+numpy<3.0.0,>=1.17
+packaging>=20.0
+psutil
+pyyaml
+torch>=1.10.0
+huggingface_hub>=0.21.0
+safetensors>=0.4.3
+
+[deepspeed]
+deepspeed
+
+[dev]
+black~=23.1
+hf-doc-builder>=0.3.0
+ruff~=0.2.1
+pytest<=8.0.0,>=7.2.0
+pytest-xdist
+pytest-subtests
+parameterized
+datasets
+diffusers
+evaluate
+torchdata>=0.8.0
+torchpippy>=0.2.0
+transformers
+scipy
+scikit-learn
+tqdm
+bitsandbytes
+timm
+rich
+
+[docs]
+
+[quality]
+black~=23.1
+hf-doc-builder>=0.3.0
+ruff~=0.2.1
+
+[rich]
+rich
+
+[sagemaker]
+sagemaker
+
+[test_dev]
+datasets
+diffusers
+evaluate
+torchdata>=0.8.0
+torchpippy>=0.2.0
+transformers
+scipy
+scikit-learn
+tqdm
+bitsandbytes
+timm
+
+[test_prod]
+pytest<=8.0.0,>=7.2.0
+pytest-xdist
+pytest-subtests
+parameterized
+
+[test_trackers]
+wandb
+comet-ml
+tensorboard
+dvclive
+
+[testing]
+pytest<=8.0.0,>=7.2.0
+pytest-xdist
+pytest-subtests
+parameterized
+datasets
+diffusers
+evaluate
+torchdata>=0.8.0
+torchpippy>=0.2.0
+transformers
+scipy
+scikit-learn
+tqdm
+bitsandbytes
+timm
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/top_level.txt b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a9368375be0e0e13fdad0eea4b92541bd9e1f594
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate.egg-info/top_level.txt
@@ -0,0 +1 @@
+accelerate
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/__init__.py b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc36acf7fec37d74e62e37fd0edda2d01b300488
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/__init__.py
@@ -0,0 +1,50 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+__version__ = "0.35.0.dev0"
+
+from .accelerator import Accelerator
+from .big_modeling import (
+ cpu_offload,
+ cpu_offload_with_hook,
+ disk_offload,
+ dispatch_model,
+ init_empty_weights,
+ init_on_device,
+ load_checkpoint_and_dispatch,
+)
+from .data_loader import skip_first_batches
+from .inference import prepare_pippy
+from .launchers import debug_launcher, notebook_launcher
+from .state import PartialState
+from .utils import (
+ AutocastKwargs,
+ DataLoaderConfiguration,
+ DDPCommunicationHookType,
+ DeepSpeedPlugin,
+ DistributedDataParallelKwargs,
+ DistributedType,
+ FullyShardedDataParallelPlugin,
+ GradScalerKwargs,
+ InitProcessGroupKwargs,
+ ProfileKwargs,
+ find_executable_batch_size,
+ infer_auto_device_map,
+ is_rich_available,
+ load_checkpoint_in_model,
+ synchronize_rng_states,
+)
+
+
+if is_rich_available():
+ from .utils import rich
diff --git a/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/accelerator.py b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/accelerator.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea17a060046872b2e959628350d8d391e5037009
--- /dev/null
+++ b/tasks/tasksmith-5d12db5414d2/tests/source/src/accelerate/accelerator.py
@@ -0,0 +1,3562 @@
+# Copyright 2021 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import contextlib
+import functools
+import json
+import math
+import os
+import re
+import shutil
+import sys
+import warnings
+from collections import OrderedDict
+from contextlib import contextmanager
+from functools import partial
+from types import MethodType
+from typing import Any, Callable, Union
+
+import torch
+import torch.utils.hooks as hooks
+from huggingface_hub import split_torch_state_dict_into_shards
+
+from .checkpointing import load_accelerator_state, load_custom_state, save_accelerator_state, save_custom_state
+from .data_loader import DataLoaderDispatcher, prepare_data_loader, skip_first_batches
+from .hooks import AlignDevicesHook
+from .logging import get_logger
+from .optimizer import AcceleratedOptimizer
+from .scheduler import AcceleratedScheduler
+from .state import AcceleratorState, GradientState, PartialState
+from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers
+from .utils import (
+ MODEL_NAME,
+ SAFE_WEIGHTS_INDEX_NAME,
+ SAFE_WEIGHTS_NAME,
+ SAFE_WEIGHTS_PATTERN_NAME,
+ WEIGHTS_INDEX_NAME,
+ WEIGHTS_NAME,
+ WEIGHTS_PATTERN_NAME,
+ AutocastKwargs,
+ DataLoaderConfiguration,
+ DeepSpeedPlugin,
+ DistributedDataParallelKwargs,
+ DistributedType,
+ DynamoBackend,
+ FP8RecipeKwargs,
+ FullyShardedDataParallelPlugin,
+ GradientAccumulationPlugin,
+ GradScalerKwargs,
+ InitProcessGroupKwargs,
+ KwargsHandler,
+ LoggerType,
+ MegatronLMPlugin,
+ PrecisionType,
+ ProfileKwargs,
+ ProjectConfiguration,
+ RNGType,
+ TorchDynamoPlugin,
+ apply_fp8_autowrap,
+ check_os_kernel,
+ clean_state_dict_for_safetensors,
+ compare_versions,
+ convert_model,
+ convert_outputs_to_fp32,
+ extract_model_from_parallel,
+ gather,
+ gather_object,
+ get_mixed_precision_context_manager,
+ get_pretty_name,
+ is_bf16_available,
+ is_deepspeed_available,
+ is_ipex_available,
+ is_lomo_available,
+ is_megatron_lm_available,
+ is_mlu_available,
+ is_msamp_available,
+ is_musa_available,
+ is_npu_available,
+ is_torch_version,
+ is_torch_xla_available,
+ is_transformer_engine_available,
+ is_xpu_available,
+ load_fsdp_model,
+ load_fsdp_optimizer,
+ pad_across_processes,
+ parse_choice_from_env,
+ recursively_apply,
+ reduce,
+ release_memory,
+ save,
+ save_fsdp_model,
+ save_fsdp_optimizer,
+ wait_for_everyone,
+)
+from .utils.constants import FSDP_PYTORCH_VERSION, PROFILE_PATTERN_NAME
+from .utils.modeling import get_state_dict_offloaded_model
+from .utils.other import is_compiled_module
+
+
+if is_deepspeed_available():
+ from .utils import (
+ DeepSpeedEngineWrapper,
+ DeepSpeedOptimizerWrapper,
+ DeepSpeedSchedulerWrapper,
+ DummyOptim,
+ DummyScheduler,
+ )
+
+if is_megatron_lm_available():
+ from .utils import (
+ MegatronEngine,
+ MegatronLMDummyDataLoader,
+ MegatronLMDummyScheduler,
+ MegatronLMOptimizerWrapper,
+ MegatronLMSchedulerWrapper,
+ megatron_lm_initialize,
+ megatron_lm_prepare_data_loader,
+ megatron_lm_prepare_model_optimizer_scheduler,
+ )
+
+from torch.distributed.algorithms.join import Join
+
+
+if is_torch_xla_available():
+ import torch_xla.amp as xamp
+ import torch_xla.core.xla_model as xm
+ import torch_xla.distributed.xla_multiprocessing as xmp
+
+
+if is_npu_available(check_device=False):
+ import torch_npu # noqa: F401
+
+
+try:
+ from torch.optim.lr_scheduler import LRScheduler
+except ImportError:
+ from torch.optim.lr_scheduler import _LRScheduler as LRScheduler
+
+logger = get_logger(__name__)
+
+# Sentinel values for defaults
+_split_batches = object()
+_dispatch_batches = object()
+_even_batches = object()
+_use_seedable_sampler = object()
+
+
+class Accelerator:
+ """
+ Creates an instance of an accelerator for distributed training (on multi-GPU, TPU) or mixed precision training.
+
+ Args:
+ device_placement (`bool`, *optional*, defaults to `True`):
+ Whether or not the accelerator should put objects on device (tensors yielded by the dataloader, model,
+ etc...).
+ mixed_precision (`str`, *optional*):
+ Whether or not to use mixed precision training. Choose from 'no','fp16','bf16' or 'fp8'. Will default to
+ the value in the environment variable `ACCELERATE_MIXED_PRECISION`, which will use the default value in the
+ accelerate config of the current system or the flag passed with the `accelerate.launch` command. 'fp8'
+ requires the installation of transformers-engine.
+ gradient_accumulation_steps (`int`, *optional*, default to 1):
+ The number of steps that should pass before gradients are accumulated. A number > 1 should be combined with
+ `Accelerator.accumulate`. If not passed, will default to the value in the environment variable
+ `ACCELERATE_GRADIENT_ACCUMULATION_STEPS`. Can also be configured through a `GradientAccumulationPlugin`.
+ cpu (`bool`, *optional*):
+ Whether or not to force the script to execute on CPU. Will ignore GPU available if set to `True` and force
+ the execution on one process only.
+ dataloader_config (`DataLoaderConfiguration`, *optional*):
+ A configuration for how the dataloaders should be handled in distributed scenarios.
+ deepspeed_plugin ([`~utils.DeepSpeedPlugin`], *optional*):
+ Tweak your DeepSpeed related args using this argument. This argument is optional and can be configured
+ directly using *accelerate config*
+ fsdp_plugin ([`~utils.FullyShardedDataParallelPlugin`], *optional*):
+ Tweak your FSDP related args using this argument. This argument is optional and can be configured directly
+ using *accelerate config*
+ megatron_lm_plugin ([`~utils.MegatronLMPlugin`], *optional*):
+ Tweak your MegatronLM related args using this argument. This argument is optional and can be configured
+ directly using *accelerate config*
+ rng_types (list of `str` or [`~utils.RNGType`]):
+ The list of random number generators to synchronize at the beginning of each iteration in your prepared
+ dataloaders. Should be one or several of:
+
+ - `"torch"`: the base torch random number generator
+ - `"cuda"`: the CUDA random number generator (GPU only)
+ - `"xla"`: the XLA random number generator (TPU only)
+ - `"generator"`: the `torch.Generator` of the sampler (or batch sampler if there is no sampler in your
+ dataloader) or of the iterable dataset (if it exists) if the underlying dataset is of that type.
+
+ Will default to `["torch"]` for PyTorch versions <=1.5.1 and `["generator"]` for PyTorch versions >= 1.6.
+ log_with (list of `str`, [`~utils.LoggerType`] or [`~tracking.GeneralTracker`], *optional*):
+ A list of loggers to be setup for experiment tracking. Should be one or several of:
+
+ - `"all"`
+ - `"tensorboard"`
+ - `"wandb"`
+ - `"comet_ml"`
+ If `"all"` is selected, will pick up all available trackers in the environment and initialize them. Can
+ also accept implementations of `GeneralTracker` for custom trackers, and can be combined with `"all"`.
+ project_config ([`~utils.ProjectConfiguration`], *optional*):
+ A configuration for how saving the state can be handled.
+ project_dir (`str`, `os.PathLike`, *optional*):
+ A path to a directory for storing data such as logs of locally-compatible loggers and potentially saved
+ checkpoints.
+ step_scheduler_with_optimizer (`bool`, *optional*, defaults to `True`):
+ Set `True` if the learning rate scheduler is stepped at the same time as the optimizer, `False` if only
+ done under certain circumstances (at the end of each epoch, for instance).
+ kwargs_handlers (list of [`~utils.KwargsHandler`], *optional*)
+ A list of [`~utils.KwargsHandler`] to customize how the objects related to distributed training, profiling
+ or mixed precision are created. See [kwargs](kwargs) for more information.
+ dynamo_backend (`str` or [`~utils.DynamoBackend`], *optional*, defaults to `"no"`):
+ Set to one of the possible dynamo backends to optimize your training with torch dynamo.
+ gradient_accumulation_plugin ([`~utils.GradientAccumulationPlugin`], *optional*):
+ A configuration for how gradient accumulation should be handled, if more tweaking than just the
+ `gradient_accumulation_steps` is needed.
+
+ **Available attributes:**
+
+ - **device** (`torch.device`) -- The device to use.
+ - **distributed_type** ([`~utils.DistributedType`]) -- The distributed training configuration.
+ - **local_process_index** (`int`) -- The process index on the current machine.
+ - **mixed_precision** (`str`) -- The configured mixed precision mode.
+ - **num_processes** (`int`) -- The total number of processes used for training.
+ - **optimizer_step_was_skipped** (`bool`) -- Whether or not the optimizer update was skipped (because of
+ gradient overflow in mixed precision), in which
+ case the learning rate should not be changed.
+ - **process_index** (`int`) -- The overall index of the current process among all processes.
+ - **state** ([`~state.AcceleratorState`]) -- The distributed setup state.
+ - **sync_gradients** (`bool`) -- Whether the gradients are currently being synced across all processes.
+ - **use_distributed** (`bool`) -- Whether the current configuration is for distributed training.
+ """
+
+ def __init__(
+ self,
+ device_placement: bool = True,
+ split_batches: bool = _split_batches,
+ mixed_precision: PrecisionType | str | None = None,
+ gradient_accumulation_steps: int = 1,
+ cpu: bool = False,
+ dataloader_config: DataLoaderConfiguration | None = None,
+ deepspeed_plugin: DeepSpeedPlugin | None = None,
+ fsdp_plugin: FullyShardedDataParallelPlugin | None = None,
+ megatron_lm_plugin: MegatronLMPlugin | None = None,
+ rng_types: list[str | RNGType] | None = None,
+ log_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None = None,
+ project_dir: str | os.PathLike | None = None,
+ project_config: ProjectConfiguration | None = None,
+ gradient_accumulation_plugin: GradientAccumulationPlugin | None = None,
+ dispatch_batches: bool | None = _dispatch_batches,
+ even_batches: bool = _even_batches,
+ use_seedable_sampler: bool = _use_seedable_sampler,
+ step_scheduler_with_optimizer: bool = True,
+ kwargs_handlers: list[KwargsHandler] | None = None,
+ dynamo_backend: DynamoBackend | str | None = None,
+ ):
+ self.trackers = []
+ if project_config is not None:
+ self.project_configuration = project_config
+ else:
+ self.project_configuration = ProjectConfiguration(project_dir=project_dir)
+ if project_dir is not None and self.project_dir is None:
+ self.project_configuration.set_directories(project_dir)
+ if mixed_precision is not None:
+ mixed_precision = str(mixed_precision)
+ if mixed_precision not in PrecisionType:
+ raise ValueError(
+ f"Unknown mixed_precision mode: {mixed_precision}. Choose between {PrecisionType.list()}"
+ )
+
+ dynamo_plugin = TorchDynamoPlugin() if dynamo_backend is None else TorchDynamoPlugin(backend=dynamo_backend)
+
+ if deepspeed_plugin is None: # init from env variables
+ deepspeed_plugin = (
+ DeepSpeedPlugin() if os.environ.get("ACCELERATE_USE_DEEPSPEED", "false") == "true" else None
+ )
+ else:
+ assert isinstance(
+ deepspeed_plugin, DeepSpeedPlugin
+ ), "`deepspeed_plugin` must be an `accelerate.utils.DeepSpeedPlugin` object."
+ os.environ["ACCELERATE_USE_DEEPSPEED"] = "true" # use DeepSpeed if plugin is provided
+ if deepspeed_plugin:
+ if not is_deepspeed_available():
+ raise ImportError("DeepSpeed is not installed => run `pip install deepspeed` or build it from source.")
+ if is_mlu_available():
+ if compare_versions("deepspeed-mlu", "<", "0.10.1"):
+ raise ImportError("DeepSpeed MLU version must be >= 0.10.1. Please update DeepSpeed MLU.")
+ elif is_musa_available():
+ if compare_versions("deepspeed", ">", "0.14.3"):
+ raise ImportError("DeepSpeed MUSA version must be <= 0.14.3. Please downgrade DeepSpeed.")
+ elif compare_versions("deepspeed", "<", "0.9.3"):
+ raise ImportError("DeepSpeed version must be >= 0.9.3. Please update DeepSpeed.")
+
+ mixed_precision = (
+ os.environ.get("ACCELERATE_MIXED_PRECISION", "no") if mixed_precision is None else mixed_precision
+ )
+ deepspeed_plugin.set_mixed_precision(mixed_precision)
+ deepspeed_plugin.set_deepspeed_weakref()
+
+ if os.environ.get("ACCELERATE_USE_FSDP", "false") == "true" or isinstance(
+ fsdp_plugin, FullyShardedDataParallelPlugin
+ ):
+ if not is_torch_version(">=", FSDP_PYTORCH_VERSION):
+ raise ValueError(f"FSDP requires PyTorch >= {FSDP_PYTORCH_VERSION}")
+
+ if fsdp_plugin is None: # init from env variables
+ fsdp_plugin = (
+ FullyShardedDataParallelPlugin() if os.environ.get("ACCELERATE_USE_FSDP", "false") == "true" else None
+ )
+ else:
+ if not isinstance(fsdp_plugin, FullyShardedDataParallelPlugin):
+ raise TypeError("`fsdp_plugin` must be a FullyShardedDataParallelPlugin object.")
+ os.environ["ACCELERATE_USE_FSDP"] = "true" # use FSDP if plugin is provided
+
+ if megatron_lm_plugin is None: # init from env variables
+ megatron_lm_plugin = (
+ MegatronLMPlugin() if os.environ.get("ACCELERATE_USE_MEGATRON_LM", "false") == "true" else None
+ )
+ else:
+ if not isinstance(megatron_lm_plugin, MegatronLMPlugin):
+ raise TypeError("`megatron_lm_plugin` must be a MegatronLMPlugin object.")
+ os.environ["ACCELERATE_USE_MEGATRON_LM"] = "true" # use MegatronLM if plugin is provided
+
+ if megatron_lm_plugin:
+ if not is_megatron_lm_available():
+ raise ImportError("Megatron is not installed. please build it from source.")
+
+ # Kwargs handlers
+ self.ddp_handler = None
+ self.scaler_handler = None
+ self.init_handler = None
+ self.fp8_recipe_handler = None
+ self.autocast_handler = None
+ self.profile_handler = None
+ self.has_lomo_optimizer = False
+
+ if kwargs_handlers is not None:
+ for handler in kwargs_handlers:
+ assert isinstance(
+ handler, KwargsHandler
+ ), f"Unsupported kwargs handler passed: {handler}, must be one that inherits `accelerate.utils.KwargsHandler`."
+ if isinstance(handler, DistributedDataParallelKwargs):
+ if self.ddp_handler is not None:
+ raise ValueError("You can only pass one `DistributedDataParallelKwargs` in `kwargs_handler`.")
+ else:
+ self.ddp_handler = handler
+ elif isinstance(handler, GradScalerKwargs):
+ if self.scaler_handler is not None:
+ raise ValueError("You can only pass one `GradScalerKwargs` in `kwargs_handler`.")
+ else:
+ self.scaler_handler = handler
+ elif isinstance(handler, InitProcessGroupKwargs):
+ if self.init_handler is not None:
+ raise ValueError("You can only pass one `InitProcessGroupKwargs` in `kwargs_handler`.")
+ else:
+ self.init_handler = handler
+ elif isinstance(handler, FP8RecipeKwargs):
+ if self.fp8_recipe_handler is not None:
+ raise ValueError("You can only pass one `FP8RecipeKwargs` in `kwargs_handler`.")
+ else:
+ self.fp8_recipe_handler = handler
+ elif isinstance(handler, AutocastKwargs):
+ if self.autocast_handler is not None:
+ raise ValueError("You can only pass one `AutocastKwargs` in `kwargs_handler`.")
+ else:
+ self.autocast_handler = handler
+ elif isinstance(handler, ProfileKwargs):
+ if self.profile_handler is not None:
+ raise ValueError("You can only pass one `ProfileKwargs` in `kwargs_handler`.")
+ else:
+ self.profile_handler = handler
+
+ kwargs = self.init_handler.to_kwargs() if self.init_handler is not None else {}
+ self.state = AcceleratorState(
+ mixed_precision=mixed_precision,
+ cpu=cpu,
+ dynamo_plugin=dynamo_plugin,
+ deepspeed_plugin=deepspeed_plugin,
+ fsdp_plugin=fsdp_plugin,
+ megatron_lm_plugin=megatron_lm_plugin,
+ _from_accelerator=True,
+ **kwargs,
+ )
+
+ if self.state.mixed_precision == "fp8" and self.fp8_recipe_handler is None:
+ self.fp8_recipe_handler = FP8RecipeKwargs()
+
+ self.delayed_fp8_autocast = False
+ if self.fp8_recipe_handler is not None:
+ # We already check if FP8 is available during `self.state`
+ if self.state.mixed_precision != "fp8" and (
+ self.distributed_type not in (DistributedType.FSDP, DistributedType.DEEPSPEED)
+ ):
+ raise ValueError("Passing in a `FP8RecipeKwargs` object requires setting `mixed_precision='fp8'`.")
+ self.delayed_fp8_autocast = self.fp8_recipe_handler.backend == "TE" and self.distributed_type in (
+ DistributedType.MULTI_GPU,
+ DistributedType.FSDP,
+ )
+
+ trackers = filter_trackers(log_with, self.logging_dir)
+ if len(trackers) < 1 and log_with is not None:
+ warnings.warn(f"`log_with={log_with}` was passed but no supported trackers are currently installed.")
+ self.log_with = trackers
+
+ if (
+ (mixed_precision != "bf16")
+ and getattr(self.state, "downcast_bfloat", False)
+ and (self.state.distributedType != DistributedType.XLA)
+ ):
+ raise ValueError("Can only use `downcast_bf16` when using `mixed_precision='bf16'` and on a TPU")
+
+ if gradient_accumulation_plugin is not None:
+ if gradient_accumulation_steps != 1:
+ raise ValueError(
+ "You can only pass one of `gradient_accumulation_steps` and `gradient_accumulation_plugin`. Please only pass in the created `GradientAccumulationPlugin` object."
+ )
+ else:
+ gradient_accumulation_steps = int(
+ parse_choice_from_env("ACCELERATE_GRADIENT_ACCUMULATION_STEPS", gradient_accumulation_steps)
+ )
+ gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=gradient_accumulation_steps)
+ self.gradient_state = GradientState(
+ gradient_accumulation_plugin=gradient_accumulation_plugin,
+ )
+
+ self.device_placement = device_placement
+ if dataloader_config is None:
+ dataloader_config = DataLoaderConfiguration()
+ self.dataloader_config = dataloader_config
+ # Deal with deprecated args
+ # TODO: Remove in v1.0.0
+ deprecated_dl_args = {}
+ if dispatch_batches is not _dispatch_batches:
+ deprecated_dl_args["dispatch_batches"] = dispatch_batches
+ self.dataloader_config.dispatch_batches = dispatch_batches
+ if split_batches is not _split_batches:
+ deprecated_dl_args["split_batches"] = split_batches
+ self.dataloader_config.split_batches = split_batches
+ if even_batches is not _even_batches:
+ deprecated_dl_args["even_batches"] = even_batches
+ self.dataloader_config.even_batches = even_batches
+ if use_seedable_sampler is not _use_seedable_sampler:
+ deprecated_dl_args["use_seedable_sampler"] = use_seedable_sampler
+ self.dataloader_config.use_seedable_sampler = use_seedable_sampler
+ if len(deprecated_dl_args) > 0:
+ values = ", ".join([f"{k}={v}" for k, v in deprecated_dl_args.items()])
+ warnings.warn(
+ f"Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: {deprecated_dl_args.keys()}. "
+ "Please pass an `accelerate.DataLoaderConfiguration` instead: \n"
+ f"dataloader_config = DataLoaderConfiguration({values})",
+ FutureWarning,
+ )
+ self.step_scheduler_with_optimizer = step_scheduler_with_optimizer
+
+ # Mixed precision attributes
+ self.scaler = None
+ self.native_amp = False
+ if (
+ self.state.mixed_precision == "fp16"
+ and self.device.type != "cpu"
+ and self.distributed_type not in (DistributedType.DEEPSPEED, DistributedType.MEGATRON_LM)
+ ):
+ self.native_amp = True
+ if self.device.type not in ("xpu", "cuda", "npu", "xla", "mlu", "musa") or is_torch_xla_available(
+ check_is_tpu=True
+ ):
+ raise ValueError(f"fp16 mixed precision requires a GPU (not {self.device.type!r}).")
+ kwargs = self.scaler_handler.to_kwargs() if self.scaler_handler is not None else {}
+ if self.distributed_type == DistributedType.FSDP:
+ from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler
+
+ self.scaler = ShardedGradScaler(**kwargs)
+ elif is_torch_xla_available(check_is_gpu=True):
+ self.scaler = xamp.GradScaler(**kwargs)
+ elif is_mlu_available():
+ self.scaler = torch.mlu.amp.GradScaler(**kwargs)
+ elif is_musa_available():
+ self.scalar = torch.musa.amp.GradScaler(**kwargs)
+ elif is_npu_available():
+ self.scaler = torch.npu.amp.GradScaler(**kwargs)
+ elif is_xpu_available():
+ self.scaler = torch.amp.GradScaler("xpu", **kwargs)
+ else:
+ self.scaler = torch.cuda.amp.GradScaler(**kwargs)
+
+ elif self.state.mixed_precision == "bf16" and self.distributed_type not in (
+ DistributedType.DEEPSPEED,
+ DistributedType.MEGATRON_LM,
+ ):
+ if self.device.type in ["cpu", "xpu"]:
+ self.native_amp = True
+ else:
+ self.native_amp = is_bf16_available(True)
+ if mixed_precision == "bf16" and not self.native_amp and not is_torch_xla_available():
+ raise ValueError("bf16 mixed precision requires PyTorch >= 1.10 and a supported device.")
+
+ elif self.state.mixed_precision == "fp8":
+ # We always enable `native_amp` for FP8
+ self.native_amp = True
+
+ # Start of internal step tracking
+ self.step = 0
+
+ # Internal references to the training objects
+ self._optimizers = []
+ self._models = []
+ self._schedulers = []
+ self._dataloaders = []
+ self._custom_objects = []
+
+ # Hooks
+ self._load_model_state_pre_hook = OrderedDict()
+ self._save_model_state_pre_hook = OrderedDict()
+
+ # RNG Types
+ self.rng_types = rng_types
+ if self.rng_types is None:
+ self.rng_types = ["generator"]
+
+ # Set a flag tensor for early stopping and other breakpoints
+ self.flag_tensor = None
+
+ check_os_kernel()
+
+ @property
+ def use_distributed(self):
+ """
+ Whether the Accelerator is configured for distributed training
+ """
+ return self.state.use_distributed
+
+ @property
+ def distributed_type(self):
+ return self.state.distributed_type
+
+ @property
+ def num_processes(self):
+ return self.state.num_processes
+
+ @property
+ def process_index(self):
+ return self.state.process_index
+
+ @property
+ def local_process_index(self):
+ return self.state.local_process_index
+
+ @property
+ def device(self):
+ return self.state.device
+
+ @property
+ def split_batches(self):
+ return self.dataloader_config.split_batches
+
+ @property
+ def dispatch_batches(self):
+ return self.dataloader_config.dispatch_batches
+
+ @property
+ def even_batches(self):
+ return self.dataloader_config.even_batches
+
+ @even_batches.setter
+ def even_batches(self, value: bool):
+ self.dataloader_config.even_batches = value
+
+ @property
+ def use_seedable_sampler(self):
+ return self.dataloader_config.use_seedable_sampler
+
+ @property
+ def non_blocking(self):
+ return self.dataloader_config.non_blocking
+
+ @property
+ def use_stateful_dataloader(self):
+ if hasattr(self.dataloader_config, "use_stateful_dataloader"):
+ return self.dataloader_config.use_stateful_dataloader
+ return False
+
+ @property
+ def project_dir(self):
+ return self.project_configuration.project_dir
+
+ @property
+ def logging_dir(self):
+ return self.project_configuration.logging_dir
+
+ @property
+ def save_iteration(self):
+ return self.project_configuration.iteration
+
+ @property
+ def is_main_process(self):
+ """True for one process only."""
+ return self.state.is_main_process
+
+ @property
+ def is_local_main_process(self):
+ """True for one process per server."""
+ return self.state.is_local_main_process
+
+ @property
+ def use_fp16(self):
+ warnings.warn(
+ "The `use_fp16` property is deprecated and will be removed in version 1.0 of Accelerate use "
+ "`Accelerator.mixed_precision == 'fp16'` instead.",
+ FutureWarning,
+ )
+ return self.mixed_precision != "no"
+
+ @property
+ def is_last_process(self):
+ return self.process_index == self.num_processes - 1
+
+ @property
+ def mixed_precision(self):
+ return self.state.mixed_precision
+
+ @contextmanager
+ def split_between_processes(self, inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False):
+ """
+ Splits `input` between `self.num_processes` quickly and can be then used on that process. Useful when doing
+ distributed inference, such as with different prompts.
+
+ Note that when using a `dict`, all keys need to have the same number of elements.
+
+ Args:
+ inputs (`list`, `tuple`, `torch.Tensor`, or `dict` of `list`/`tuple`/`torch.Tensor`):
+ The input to split between processes.
+ apply_padding (`bool`, `optional`, defaults to `False`):
+ Whether to apply padding by repeating the last element of the input so that all processes have the same
+ number of elements. Useful when trying to perform actions such as `Accelerator.gather()` on the outputs
+ or passing in less inputs than there are processes. If so, just remember to drop the padded elements
+ afterwards.
+
+ Example:
+
+ ```python
+ # Assume there are two processes
+ from accelerate import Accelerator
+
+ accelerator = Accelerator()
+ with accelerator.split_between_processes(["A", "B", "C"]) as inputs:
+ print(inputs)
+ # Process 0
+ ["A", "B"]
+ # Process 1
+ ["C"]
+
+ with accelerator.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
+ print(inputs)
+ # Process 0
+ ["A", "B"]
+ # Process 1
+ ["C", "C"]
+ ```
+ """
+ with PartialState().split_between_processes(inputs, apply_padding=apply_padding) as inputs:
+ yield inputs
+
+ def on_main_process(self, function: Callable[..., Any] = None):
+ """
+ A decorator that will run the decorated function on the main process only. Can also be called using the
+ `PartialState` class.
+
+ Args:
+ function (`Callable`): The function to decorate.
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator()
+
+
+ >>> @accelerator.on_main_process
+ ... def print_something():
+ ... print("This will be printed by process 0 only.")
+
+
+ >>> print_something()
+ "This will be printed by process 0 only"
+ ```
+ """
+ # For times when the `Accelerator` object itself utilizes this decorator.
+ if function is None:
+ if "Accelerator." in self.__qualname__:
+ function = self
+ else:
+ raise ValueError(
+ "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
+ )
+
+ def _inner(*args, **kwargs):
+ return PartialState().on_main_process(function)(*args, **kwargs)
+
+ return _inner
+
+ def on_local_main_process(self, function: Callable[..., Any] = None):
+ """
+ A decorator that will run the decorated function on the local main process only. Can also be called using the
+ `PartialState` class.
+
+ Args:
+ function (`Callable`): The function to decorate.
+
+ Example:
+ ```python
+ # Assume we have 2 servers with 4 processes each.
+ from accelerate import Accelerator
+
+ accelerator = Accelerator()
+
+
+ @accelerator.on_local_main_process
+ def print_something():
+ print("This will be printed by process 0 only on each server.")
+
+
+ print_something()
+ # On server 1:
+ "This will be printed by process 0 only"
+ # On server 2:
+ "This will be printed by process 0 only"
+ ```
+ """
+ # For times when the `Accelerator` object itself utilizes this decorator.
+ if function is None:
+ if "Accelerator." in self.__qualname__:
+ function = self
+ else:
+ raise ValueError(
+ "The `on_local_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
+ )
+
+ def _inner(*args, **kwargs):
+ return PartialState().on_local_main_process(function)(*args, **kwargs)
+
+ return _inner
+
+ def on_last_process(self, function: Callable[..., Any]):
+ """
+ A decorator that will run the decorated function on the last process only. Can also be called using the
+ `PartialState` class.
+
+ Args:
+ function (`Callable`): The function to decorate.
+
+ Example:
+ ```python
+ # Assume we have 4 processes.
+ from accelerate import Accelerator
+
+ accelerator = Accelerator()
+
+
+ @accelerator.on_last_process
+ def print_something():
+ print(f"Printed on process {accelerator.process_index}")
+
+
+ print_something()
+ "Printed on process 3"
+ ```
+ """
+ # For times when the `Accelerator` object itself utilizes this decorator.
+ if function is None:
+ if "Accelerator." in self.__qualname__:
+ function = self
+ else:
+ raise ValueError(
+ "The `on_last_process` decorator must be called with a function on an instantiated `Accelerator` object."
+ )
+
+ def _inner(*args, **kwargs):
+ return PartialState().on_last_process(function)(*args, **kwargs)
+
+ return _inner
+
+ def on_process(self, function: Callable[..., Any] = None, process_index: int = None):
+ """
+ A decorator that will run the decorated function on a given process index only. Can also be called using the
+ `PartialState` class.
+
+ Args:
+ function (`Callable`, `optional`):
+ The function to decorate.
+ process_index (`int`, `optional`):
+ The index of the process on which to run the function.
+
+ Example:
+ ```python
+ # Assume we have 4 processes.
+ from accelerate import Accelerator
+
+ accelerator = Accelerator()
+
+
+ @accelerator.on_process(process_index=2)
+ def print_something():
+ print(f"Printed on process {accelerator.process_index}")
+
+
+ print_something()
+ "Printed on process 2"
+ ```
+ """
+ # Initial construction of the decorator.
+ if (self is not None) and (process_index is not None) and (function is None):
+ return partial(self.on_process, process_index=process_index)
+ # For times when the `Accelerator` object itself utilizes this decorator.
+ if function is None:
+ if "Accelerator." in self.__qualname__:
+ function = self
+ else:
+ raise ValueError(
+ "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
+ )
+
+ def _inner(*args, **kwargs):
+ return PartialState().on_process(function, process_index)(*args, **kwargs)
+
+ return _inner
+
+ def on_local_process(self, function: Callable[..., Any] = None, local_process_index: int = None):
+ """
+ A decorator that will run the decorated function on a given local process index only. Can also be called using
+ the `PartialState` class.
+
+ Args:
+ function (`Callable`, *optional*):
+ The function to decorate.
+ local_process_index (`int`, *optional*):
+ The index of the local process on which to run the function.
+
+ Example:
+ ```python
+ # Assume we have 2 servers with 4 processes each.
+ from accelerate import Accelerator
+
+ accelerator = Accelerator()
+
+
+ @accelerator.on_local_process(local_process_index=2)
+ def print_something():
+ print(f"Printed on process {accelerator.local_process_index}")
+
+
+ print_something()
+ # On server 1:
+ "Printed on process 2"
+ # On server 2:
+ "Printed on process 2"
+ ```
+ """
+ # Initial construction of the decorator.
+ if (self is not None) and (local_process_index is not None) and (function is None):
+ return partial(self.on_local_process, local_process_index=local_process_index)
+ # For times when the `Accelerator` object itself utilizes this decorator.
+ if function is None:
+ if "Accelerator." in self.__qualname__:
+ function = self
+ else:
+ raise ValueError(
+ "The `on_main_process` decorator must be called with a function on an instantiated `Accelerator` object."
+ )
+
+ def _inner(*args, **kwargs):
+ return PartialState().on_local_process(function, local_process_index)(*args, **kwargs)
+
+ return _inner
+
+ @contextmanager
+ def main_process_first(self):
+ """
+ Lets the main process go first inside a with block.
+
+ The other processes will enter the with block after the main process exits.
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator()
+ >>> with accelerator.main_process_first():
+ ... # This will be printed first by process 0 then in a seemingly
+ ... # random order by the other processes.
+ ... print(f"This will be printed by process {accelerator.process_index}")
+ ```
+ """
+ with self.state.main_process_first():
+ yield
+
+ @contextmanager
+ def local_main_process_first(self):
+ """
+ Lets the local main process go inside a with block.
+
+ The other processes will enter the with block after the main process exits.
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator()
+ >>> with accelerator.local_main_process_first():
+ ... # This will be printed first by local process 0 then in a seemingly
+ ... # random order by the other processes.
+ ... print(f"This will be printed by process {accelerator.local_process_index}")
+ ```
+ """
+ with self.state.local_main_process_first():
+ yield
+
+ @contextmanager
+ def no_sync(self, model):
+ """
+ A context manager to disable gradient synchronizations across DDP processes by calling
+ `torch.nn.parallel.DistributedDataParallel.no_sync`.
+
+ If `model` is not in DDP, this context manager does nothing
+
+ Args:
+ model (`torch.nn.Module`):
+ PyTorch Module that was prepared with `Accelerator.prepare`
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator()
+ >>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
+ >>> input_a = next(iter(dataloader))
+ >>> input_b = next(iter(dataloader))
+
+ >>> with accelerator.no_sync():
+ ... outputs = model(input_a)
+ ... loss = loss_func(outputs)
+ ... accelerator.backward(loss)
+ ... # No synchronization across processes, only accumulate gradients
+ >>> outputs = model(input_b)
+ >>> accelerator.backward(loss)
+ >>> # Synchronization across all processes
+ >>> optimizer.step()
+ >>> optimizer.zero_grad()
+ ```
+ """
+ context = contextlib.nullcontext
+ if self.use_distributed:
+ context = getattr(model, "no_sync", context)
+
+ with context():
+ yield
+
+ @staticmethod
+ @contextmanager
+ def trigger_sync_in_backward(model):
+ """Trigger the sync of the gradients in the next backward pass of the model after multiple forward passes under
+ `Accelerator.no_sync` (only applicable in multi-GPU scenarios).
+
+ If the script is not launched in distributed mode, this context manager does nothing.
+
+ Args:
+ model (`torch.nn.Module`):
+ The model for which to trigger the gradient synchronization.
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator()
+ >>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
+
+ >>> with accelerator.no_sync():
+ ... loss_a = loss_func(model(input_a)) # first forward pass
+ ... loss_b = loss_func(model(input_b)) # second forward pass
+ >>> accelerator.backward(loss_a) # No synchronization across processes, only accumulate gradients
+ >>> with accelerator.trigger_sync_in_backward(model):
+ ... accelerator.backward(loss_b) # Synchronization across all processes
+ >>> optimizer.step()
+ >>> optimizer.zero_grad()
+ ```
+ """
+ if not isinstance(model, torch.nn.parallel.DistributedDataParallel):
+ yield
+ return
+
+ old_require_backward_grad_sync = model.require_backward_grad_sync
+ old_require_forward_param_sync = model.require_forward_param_sync
+
+ # EXPERIMENTAL: This will force grad sync during `backward()`, but it is unknown if it breaks other DDP features.
+ # https://github.com/pytorch/pytorch/blob/e1502c0cdbfd17548c612f25d5a65b1e4b86224d/torch/nn/parallel/distributed.py#L1453-L1466
+ model.require_backward_grad_sync = True
+ model.require_forward_param_sync = True
+ # https://github.com/pytorch/pytorch/blob/e1502c0cdbfd17548c612f25d5a65b1e4b86224d/torch/csrc/distributed/c10d/reducer.cpp#L1371-L1402
+ model.reducer.prepare_for_backward([])
+ try:
+ yield
+ finally:
+ model.require_backward_grad_sync = old_require_backward_grad_sync
+ model.require_forward_param_sync = old_require_forward_param_sync
+
+ def _do_sync(self):
+ "Sets the right `sync_gradients` context and either resets or increases `self.step`"
+ if self.gradient_state.sync_with_dataloader and self.gradient_state.end_of_dataloader:
+ self.step = 0
+ self.gradient_state._set_sync_gradients(True)
+ else:
+ self.step += 1
+ self.gradient_state._set_sync_gradients((self.step % self.gradient_state.num_steps) == 0)
+
+ @property
+ def sync_gradients(self):
+ return self.gradient_state.sync_gradients
+
+ @sync_gradients.setter
+ def sync_gradients(self, sync_gradients):
+ self.gradient_state.sync_gradients = sync_gradients
+
+ @property
+ def gradient_accumulation_steps(self):
+ return self.gradient_state.num_steps
+
+ @gradient_accumulation_steps.setter
+ def gradient_accumulation_steps(self, gradient_accumulation_steps):
+ self.gradient_state.plugin_kwargs.update({"num_steps": gradient_accumulation_steps})
+
+ @contextmanager
+ def accumulate(self, *models):
+ """
+ A context manager that will lightly wrap around and perform gradient accumulation automatically
+
+ Args:
+ *models (list of `torch.nn.Module`):
+ PyTorch Modules that were prepared with `Accelerator.prepare`. Models passed to `accumulate()` will
+ skip gradient syncing during backward pass in distributed training
+
+ Example:
+
+ ```python
+ >>> from accelerate import Accelerator
+
+ >>> accelerator = Accelerator(gradient_accumulation_steps=1)
+ >>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
+
+ >>> for input, output in dataloader:
+ ... with accelerator.accumulate(model):
+ ... outputs = model(input)
+ ... loss = loss_func(outputs)
+ ... loss.backward()
+ ... optimizer.step()
+ ... scheduler.step()
+ ... optimizer.zero_grad()
+ ```
+ """
+ self._do_sync()
+
+ allow_gradient_sync = (
+ self.sync_gradients # must sync if sync gradients need to complete an optimizer step
+ or (
+ # the no_sync context stops the gradients from reducing during distributed training
+ # bringing speedup (potentially at some costs). Here, no_sync can be prevented
+ # by setting sync_each_batch = True.
+ self.use_distributed # only relevant in distributed settings
+ and self.gradient_state.plugin_kwargs.get("sync_each_batch", False)
+ )
+ )
+ with contextlib.ExitStack() as cm_stack:
+ for m in models:
+ cm_stack.enter_context(contextlib.nullcontext() if allow_gradient_sync else self.no_sync(m))
+ yield
+
+ @contextmanager
+ def join_uneven_inputs(self, joinables, even_batches=None):
+ """
+ A context manager that facilitates distributed training or evaluation on uneven inputs, which acts as a wrapper
+ around `torch.distributed.algorithms.join`. This is useful when the total batch size does not evenly divide the
+ length of the dataset.
+
+ Args:
+ joinables (`list[torch.distributed.algorithms.Joinable]`):
+ A list of models or optimizers that subclass `torch.distributed.algorithms.Joinable`. Most commonly, a
+ PyTorch Module that was prepared with `Accelerator.prepare` for DistributedDataParallel training.
+ even_batches (`bool`, *optional*)
+ If set, this will override the value of `even_batches` set in the `Accelerator`. If it is not provided,
+ the default `Accelerator` value wil be used.
+
+
+
+
+
+
+ +
+
+
+
+
+
+
+
Run your *raw* PyTorch training script on any kind of device + + +
+
+
+
+## Easy to integrate
+
+🤗 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.
+
+🤗 Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.
+
+Here is an example:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
++ accelerator = Accelerator()
+- device = 'cpu'
++ device = accelerator.device
+
+ model = torch.nn.Transformer().to(device)
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+ source = source.to(device)
+ targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+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 (fp8, fp16, bf16).
+
+In particular, the same code can then be run without modification on your local machine for debugging or your training environment.
+
+🤗 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:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
+- device = 'cpu'
++ accelerator = Accelerator()
+
+- model = torch.nn.Transformer().to(device)
++ model = torch.nn.Transformer()
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+- source = source.to(device)
+- targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+Want to learn more? Check out the [documentation](https://huggingface.co/docs/accelerate) or have a look at our [examples](https://github.com/huggingface/accelerate/tree/main/examples).
+
+## Launching script
+
+🤗 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.run` or to write a specific launcher for TPU training!
+On your machine(s) just run:
+
+```bash
+accelerate config
+```
+
+and answer the questions asked. This will generate a config file that will be used automatically to properly set the default options when doing
+
+```bash
+accelerate launch my_script.py --args_to_my_script
+```
+
+For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):
+
+```bash
+accelerate launch examples/nlp_example.py
+```
+
+This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torchrun my_script.py` at your convenience.
+
+You can also directly pass in the arguments you would to `torchrun` as arguments to `accelerate launch` if you wish to not run` accelerate config`.
+
+For example, here is how to launch on two GPUs:
+
+```bash
+accelerate launch --multi_gpu --num_processes 2 examples/nlp_example.py
+```
+
+To learn more, check the CLI documentation available [here](https://huggingface.co/docs/accelerate/package_reference/cli).
+
+Or view the configuration zoo [here](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates/)
+
+## Launching multi-CPU run using MPI
+
+🤗 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.
+Once you have MPI setup on your cluster, just run:
+```bash
+accelerate config
+```
+Answer the questions that are asked, selecting to run using multi-CPU, and answer "yes" when asked if you want accelerate to launch mpirun.
+Then, use `accelerate launch` with your script like:
+```bash
+accelerate launch examples/nlp_example.py
+```
+Alternatively, you can use mpirun directly, without using the CLI like:
+```bash
+mpirun -np 2 python examples/nlp_example.py
+```
+
+## Launching training using DeepSpeed
+
+🤗 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`.
+
+```python
+from accelerate import Accelerator, DeepSpeedPlugin
+
+# deepspeed needs to know your gradient accumulation steps beforehand, so don't forget to pass it
+# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed
+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)
+accelerator = Accelerator(mixed_precision='fp16', deepspeed_plugin=deepspeed_plugin)
+
+# How to save your 🤗 Transformer?
+accelerator.wait_for_everyone()
+unwrapped_model = accelerator.unwrap_model(model)
+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
+```
+
+Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.
+
+## Launching your training from a notebook
+
+🤗 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:
+
+```python
+from accelerate import notebook_launcher
+
+notebook_launcher(training_function)
+```
+
+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb). [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb)
+
+## Why should I use 🤗 Accelerate?
+
+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.
+
+## Why shouldn't I use 🤗 Accelerate?
+
+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.
+
+## Frameworks using 🤗 Accelerate
+
+If you like the simplicity of 🤗 Accelerate but would prefer a higher-level abstraction around its capabilities, some frameworks and libraries that are built on top of 🤗 Accelerate are listed below:
+
+* [Amphion](https://github.com/open-mmlab/Amphion) is a toolkit for Audio, Music, and Speech Generation. Its purpose is to support reproducible research and help junior researchers and engineers get started in the field of audio, music, and speech generation research and development.
+* [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).
+* [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 training, and inference logic.
+* [fastai](https://github.com/fastai/fastai#installing) is a PyTorch framework for Deep Learning that simplifies training fast and accurate neural nets using modern best practices. fastai provides a [Learner](https://docs.fast.ai/learner.html#Learner) to handle the training, fine-tuning, and inference of deep learning algorithms.
+* [Finetuner](https://github.com/jina-ai/finetuner) is a service that enables models to create higher-quality embeddings for semantic search, visual similarity search, cross-modal text<->image search, recommendation systems, clustering, duplication detection, anomaly detection, or other uses.
+* [InvokeAI](https://github.com/invoke-ai/InvokeAI) is a creative engine for Stable Diffusion models, offering industry-leading WebUI, terminal usage support, and serves as the foundation for many commercial products.
+* [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.
+* [Open Assistant](https://projects.laion.ai/Open-Assistant/) is a chat-based assistant that understands tasks, can interact with their party systems, and retrieve information dynamically to do so.
+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centered 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!
+* [Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is an open-source browser-based easy-to-use interface based on the Gradio library for Stable Diffusion.
+* [torchkeras](https://github.com/lyhue1991/torchkeras) is a simple tool for training pytorch model just in a keras style, a dynamic and beautiful plot is provided in notebook to monitor your loss or metric.
+* [transformers](https://github.com/huggingface/transformers) as a tool for helping train state-of-the-art machine learning models in PyTorch, Tensorflow, and JAX. (Accelerate is the backend for the PyTorch side).
+
+
+## Installation
+
+This repository is tested on Python 3.8+ and PyTorch 1.10.0+
+
+You should install 🤗 Accelerate in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
+
+First, create a virtual environment with the version of Python you're going to use and activate it.
+
+Then, you will need to install PyTorch: refer to the [official installation page](https://pytorch.org/get-started/locally/#start-locally) regarding the specific install command for your platform. Then 🤗 Accelerate can be installed using pip as follows:
+
+```bash
+pip install accelerate
+```
+
+## Supported integrations
+
+- CPU only
+- multi-CPU on one node (machine)
+- multi-CPU on several nodes (machines)
+- single GPU
+- multi-GPU on one node (machine)
+- multi-GPU on several nodes (machines)
+- TPU
+- FP16/BFloat16 mixed precision
+- FP8 mixed precision with [Transformer Engine](https://github.com/NVIDIA/TransformerEngine) or [MS-AMP](https://github.com/Azure/MS-AMP/)
+- DeepSpeed support (Experimental)
+- PyTorch Fully Sharded Data Parallel (FSDP) support (Experimental)
+- Megatron-LM support (Experimental)
+
+## Citing 🤗 Accelerate
+
+If you use 🤗 Accelerate in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{accelerate,
+ title = {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
+ author = {Sylvain Gugger and Lysandre Debut and Thomas Wolf and Philipp Schmid and Zachary Mueller and Sourab Mangrulkar and Marc Sun and Benjamin Bossan},
+ howpublished = {\url{https://github.com/huggingface/accelerate}},
+ year = {2022}
+}
+```
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/README.md b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a2381ac4182437151c1840847970bb6ade6bcbe
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/README.md
@@ -0,0 +1,5 @@
+# Benchmarks
+
+The folders below contain suites to test various functionalities in Accelerate.
+
+See their relevant README.md's for more information.
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/README.md b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..243e9df58ea92bc4148101a5fcf399978cbf07f3
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/README.md
@@ -0,0 +1,46 @@
+# Big model inference benchmarks
+
+Running inference with Accelerate on big models.
+
+## Setup
+
+These benchmarks use the `transformers` library:
+
+```bash
+pip install transformers
+```
+
+To reproduce or test a new setup, run
+
+```py
+python inference_acc.py model_name
+```
+
+This script supports `gpt-j-6b`, `gpt-neox`, `opt` (30B version) and `T0pp` out of the box, but you can specify any valid checkpoint for `model_name`.
+
+To force a different `torch_dtype` than the one in the config: `--torch_dtype xxx`.
+
+If you get an error linked to disk offload, you need to add the option `--disk-offload`
+
+## Results
+
+On a setup with two Titan RTXs (24GB of RAM) and 32GB of RAM, we get the following benchmarks (T0pp does not run in float16, which is why it's not included).
+
+| Model | Model load time | Generation time | dtype | GPU 0 use | GPU 1 use | CPU use | Disk offload |
+|:-----:|:---------------:|:---------------:|:-----:|:---------:|:---------:|:-------:|:------------:|
+| GPT-J-6B | 8.7s | 0.05s per token | float16 | 11.7GB | 0GB | 0GB | no |
+| GPT-J-6B | 12.4s | 0.06s per token | float32 | 21.9GB | 1.5GB | 0GB | no |
+| GPT-Neo-X-20B | 30.9s | 0.08s per token | float16 | 21.5GB | 18GB | 0GB | no |
+| GPT-Neo-X-20B | 78.2s | 10.72s per token | float32 | 20.3GB | 22.7 GB | 24.4GB | yes |
+| T0pp (11B) | 29.4s | 0.05s per token | float32 | 21.1GB | 21.3GB | 0GB | no |
+| OPT-30B | 34.5s | 2.37s per token | float16 | 20.7GB | 22.3GB | 14.1GB | no |
+| OPT-30B | 112.3s | 33.9s per token | float32 | 20.2GB | 21.2GB | 23.5GB | yes |
+
+Note on the results:
+- using two GPUs instead of one does not slow down generation
+- using CPU offload slows down a bit (see OPT-30b)
+- using disk offload slows down a lot (need to implement prefetching)
+
+You will also note that Accelerate does not use anymore GPU and CPU RAM than necessary:
+- peak GPU memory is exactly the size of the model put on a given GPU
+- peak CPU memory is either the size of the biggest checkpoint shard or the part of the model offloaded on CPU, whichever is bigger.
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/big_model_inference.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/big_model_inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7874e625805c5f9581508dbe69f4456adfdae4a
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/big_model_inference.py
@@ -0,0 +1,143 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import time
+
+import torch
+import transformers
+from measures_util import end_measure, log_measures, start_measure
+from transformers import AutoConfig, AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer
+
+from accelerate.utils import compute_module_sizes
+
+
+DEFAULT_MODELS = {
+ "gpt-j-6b": {"is_causal": True, "model": "sgugger/sharded-gpt-j-6B", "tokenizer": "EleutherAI/gpt-j-6B"},
+ "gpt-neox": {"is_causal": True, "model": "EleutherAI/gpt-neox-20b"},
+ "opt": {"is_causal": True, "model": "facebook/opt-30b"},
+ "T0pp": {"is_causal": False, "model": "bigscience/T0pp", "model_revision": "sharded"},
+}
+
+PROMPTS = [
+ "Hello, my name is",
+ "Are unicorns real? Unicorns are",
+ "For the first time in several years,",
+ "My name is Julien and I am",
+ "The goal of life is",
+ "Whenever I'm sad, I like to",
+]
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run and time generations on a big model using Accelerate.")
+ parser.add_argument("model_name", type=str, default=None, help="The name of the model to try.")
+ parser.add_argument(
+ "--tokenizer_name", type=str, default=None, help="The name of the tokenizer (if different from the model."
+ )
+ parser.add_argument("--is_causal", type=bool, default=None, help="Whether or not the model is causal.")
+ parser.add_argument(
+ "--model_revision", type=str, default=None, help="The revision to use for the model checkpoint."
+ )
+ parser.add_argument("--torch_dtype", type=str, default=None, help="The dtype for the model.")
+ parser.add_argument("--disk_offload", action="store_true")
+
+ args = parser.parse_args()
+
+ # Sanitize args
+ if args.model_name in DEFAULT_MODELS:
+ defaults = DEFAULT_MODELS[args.model_name]
+ args.model_name = defaults["model"]
+ if args.tokenizer_name is None:
+ args.tokenizer_name = defaults.get("tokenizer", args.model_name)
+ if args.is_causal is None:
+ args.is_causal = defaults["is_causal"]
+ if args.model_revision is None:
+ args.model_revision = defaults.get("model_revision", "main")
+
+ if args.is_causal is None:
+ raise ValueError("Could not infer the default for `--is_causal`, pass either True or False for it.")
+ if args.tokenizer_name is None:
+ args.tokenizer_name = args.model_name
+ if args.model_revision is None:
+ args.model_revision = "main"
+
+ return args
+
+
+def main():
+ transformers.utils.logging.set_verbosity_error()
+ args = parse_args()
+
+ if args.torch_dtype is None:
+ config = AutoConfig.from_pretrained(args.model_name)
+ torch_dtype = getattr(config, "torch_dtype", torch.float32)
+ else:
+ torch_dtype = getattr(torch, args.torch_dtype)
+ model_cls = AutoModelForCausalLM if args.is_causal else AutoModelForSeq2SeqLM
+ kwargs = {
+ "torch_dtype": torch_dtype,
+ "revision": args.model_revision,
+ }
+ if args.disk_offload:
+ kwargs["offload_folder"] = "tmp_offload"
+ kwargs["offload_state_dict"] = True
+
+ start_measures = start_measure()
+ model = model_cls.from_pretrained(args.model_name, device_map="auto", **kwargs)
+ end_measures = end_measure(start_measures)
+ log_measures(end_measures, "Model loading")
+
+ module_sizes = compute_module_sizes(model)
+ device_size = {v: 0 for v in model.hf_device_map.values()}
+ for module, device in model.hf_device_map.items():
+ device_size[device] += module_sizes[module]
+ message = "\n".join([f"- {device}: {size // 2**20}MiB" for device, size in device_size.items()])
+ print(f"\nTheoretical use:\n{message}")
+
+ tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name)
+
+ start_measures = start_measure()
+ generation_times = []
+ gen_tokens = []
+ texts_outs = []
+ for prompt in PROMPTS:
+ inputs = tokenizer(prompt, return_tensors="pt").to(0)
+ tokens = inputs["input_ids"][0].tolist()
+ before_generate = time.time()
+ outputs = model.generate(inputs["input_ids"])
+ after_generate = time.time()
+ outputs = outputs[0].tolist()
+ num_gen_tokens = len(outputs) if outputs[: len(tokens)] != tokens else len(outputs) - len(tokens)
+ generation_time = after_generate - before_generate
+
+ text_out = tokenizer.decode(outputs, skip_special_tokens=True)
+ texts_outs.append(text_out)
+ generation_times.append(generation_time)
+ gen_tokens.append(num_gen_tokens)
+ print(f"Prompt: {prompt}\nGeneration {text_out}\nIn {generation_time:.2f}s for {num_gen_tokens} tokens\n")
+
+ end_measures = end_measure(start_measures)
+ log_measures(end_measures, "Model generation")
+
+ generation_times_per_token = [gen / tok for gen, tok in zip(generation_times, gen_tokens)]
+ avg_gen = sum(generation_times_per_token) / len(generation_times)
+ print(f"Average time of generation per token: {avg_gen:.2f}s")
+ print(f"First generation (avg time per token): {generation_times_per_token[0]:.2f}s")
+ avg_gen = sum(generation_times_per_token[1:]) / (len(generation_times_per_token) - 1)
+ print(f"Average time of generation per token (excluding the first): {avg_gen:.2f}s")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/measures_util.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/measures_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..f22c0792f45f98c7719eb5a3314865020515658e
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/big_model_inference/measures_util.py
@@ -0,0 +1,98 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import gc
+import threading
+import time
+
+import psutil
+import torch
+
+
+class PeakCPUMemory:
+ def __init__(self):
+ self.process = psutil.Process()
+ self.peak_monitoring = False
+
+ def peak_monitor(self):
+ self.cpu_memory_peak = -1
+
+ while True:
+ self.cpu_memory_peak = max(self.process.memory_info().rss, self.cpu_memory_peak)
+
+ # can't sleep or will not catch the peak right (this comment is here on purpose)
+ if not self.peak_monitoring:
+ break
+
+ def start(self):
+ self.peak_monitoring = True
+ self.thread = threading.Thread(target=self.peak_monitor)
+ self.thread.daemon = True
+ self.thread.start()
+
+ def stop(self):
+ self.peak_monitoring = False
+ self.thread.join()
+ return self.cpu_memory_peak
+
+
+cpu_peak_tracker = PeakCPUMemory()
+
+
+def start_measure():
+ # Time
+ measures = {"time": time.time()}
+
+ gc.collect()
+ torch.cuda.empty_cache()
+
+ # CPU mem
+ measures["cpu"] = psutil.Process().memory_info().rss
+ cpu_peak_tracker.start()
+
+ # GPU mem
+ for i in range(torch.cuda.device_count()):
+ measures[str(i)] = torch.cuda.memory_allocated(i)
+ torch.cuda.reset_peak_memory_stats()
+
+ return measures
+
+
+def end_measure(start_measures):
+ # Time
+ measures = {"time": time.time() - start_measures["time"]}
+
+ gc.collect()
+ torch.cuda.empty_cache()
+
+ # CPU mem
+ measures["cpu"] = (psutil.Process().memory_info().rss - start_measures["cpu"]) / 2**20
+ measures["cpu-peak"] = (cpu_peak_tracker.stop() - start_measures["cpu"]) / 2**20
+
+ # GPU mem
+ for i in range(torch.cuda.device_count()):
+ measures[str(i)] = (torch.cuda.memory_allocated(i) - start_measures[str(i)]) / 2**20
+ measures[f"{i}-peak"] = (torch.cuda.max_memory_allocated(i) - start_measures[str(i)]) / 2**20
+
+ return measures
+
+
+def log_measures(measures, description):
+ print(f"{description}:")
+ print(f"- Time: {measures['time']:.2f}s")
+ for i in range(torch.cuda.device_count()):
+ print(f"- GPU {i} allocated: {measures[str(i)]:.2f}MiB")
+ peak = measures[f"{i}-peak"]
+ print(f"- GPU {i} peak: {peak:.2f}MiB")
+ print(f"- CPU RAM allocated: {measures['cpu']:.2f}MiB")
+ print(f"- CPU RAM peak: {measures['cpu-peak']:.2f}MiB")
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/Dockerfile b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..4d7778200a52b9a5bbf33979bbb3cd34090854dd
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/Dockerfile
@@ -0,0 +1,12 @@
+FROM ghcr.io/azure/msamp
+
+RUN pip install transformers evaluate datasets
+RUN git clone https://github.com/huggingface/accelerate
+
+RUN cd accelerate && \
+ pip install -e . && \
+ cd benchmarks/fp8
+
+CMD ["bash"]
+
+
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/ddp.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/ddp.py
new file mode 100644
index 0000000000000000000000000000000000000000..25d9fc0a7bf63533ae9b34cc8f397bf22cb45987
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/ddp.py
@@ -0,0 +1,127 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for DDP training.
+"""
+
+import evaluate
+import msamp
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from packaging import version
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(opt_level="O2"):
+ set_seed(42)
+ if version.parse(torch.__version__) > version.parse("2.3"):
+ scaler = torch.amp.GradScaler("cuda")
+ else:
+ scaler = torch.cuda.amp.GradScaler()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+
+ model, optimizer = msamp.initialize(model, optimizer, opt_level=opt_level)
+
+ model.to(device)
+
+ # Convert the model to DDP
+ device_ids, output_device = [accelerator.local_process_index], accelerator.local_process_index
+ model = DDP(model, device_ids=device_ids, output_device=output_device)
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for i, batch in enumerate(train_dataloader):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ scaler.scale(loss).backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(opt_level="O2"):
+ kwargs_handlers = [FP8RecipeKwargs(backend="msamp", opt_level=opt_level)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ for i, batch in enumerate(train_dataloader):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for opt_level in ["O1", "O2"]:
+ baseline_not_trained, baseline_trained = train_baseline(opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(opt_level)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy not the same for untrained baseline and accelerator using opt_level={opt_level}: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 not the same for untrained baseline and accelerator using opt_level={opt_level}: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy not the same for trained baseline and accelerator using opt_level={opt_level}: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 not the same for trained baseline and accelerator using opt_level={opt_level}: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py
new file mode 100644
index 0000000000000000000000000000000000000000..57a2569729f055122d4d0ed6fe4a6f07f88c3fb3
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py
@@ -0,0 +1,161 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for DeepSpeed training.
+
+NOTE: MS-AMP does *not* support ZeRO-3.
+"""
+
+# import msamp.deepspeed as msamp_deepspeed
+import evaluate
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from msamp import deepspeed as msamp_deepspeed
+
+from accelerate import Accelerator, DeepSpeedPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(zero_stage: int = 1, opt_level: str = "O1"):
+ set_seed(42)
+ accelerator = Accelerator()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ import numpy as np
+
+ config = {
+ "train_batch_size": 32,
+ "train_micro_batch_size_per_gpu": 16,
+ "gradient_accumulation_steps": 1,
+ "zero_optimization": {
+ "stage": zero_stage,
+ "offload_optimizer": {"device": "none", "nvme_path": None},
+ "offload_param": {"device": "none", "nvme_path": None},
+ },
+ "gradient_clipping": 1.0,
+ "steps_per_print": np.inf,
+ "bf16": {"enabled": True},
+ "fp16": {"enabled": False},
+ "zero_allow_untested_optimizer": True,
+ "msamp": {
+ "enabled": True,
+ "opt_level": opt_level,
+ },
+ }
+ (
+ model,
+ optimizer,
+ _,
+ _,
+ ) = msamp_deepspeed.initialize(
+ model=model,
+ optimizer=optimizer,
+ config_params=config,
+ )
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ model.backward(loss)
+ model.step()
+ for _ in range(accelerator.num_processes):
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ torch.cuda.empty_cache()
+ AcceleratorState()._reset_state(True)
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(zero_stage: int = 1, opt_level: str = "O1"):
+ set_seed(42)
+ deepspeed_plugin = DeepSpeedPlugin(
+ zero_stage=zero_stage,
+ enable_msamp=True,
+ msamp_opt_level=opt_level,
+ )
+ accelerator = Accelerator(mixed_precision="fp8", deepspeed_plugin=deepspeed_plugin)
+ accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = 16
+
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ torch.cuda.empty_cache()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ AcceleratorState()._reset_state(True)
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for zero_stage in [1, 2]:
+ for opt_level in ["O1", "O2", "O3"]:
+ baseline_not_trained, baseline_trained = train_baseline(zero_stage, opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(zero_stage, opt_level)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nAccuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nF1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nAccuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nF1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/fp8_utils.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/fp8_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..602ce07fdc62b39c60b2dd62cf8a0fe2e085a308
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/fp8_utils.py
@@ -0,0 +1,118 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+
+
+def get_dataloaders(model_name: str, batch_size: int = 16):
+ from datasets import load_dataset
+ from torch.utils.data import DataLoader
+ from transformers import AutoTokenizer
+
+ tokenizer = AutoTokenizer.from_pretrained(model_name)
+ datasets = load_dataset("glue", "mrpc")
+
+ def tokenize_function(examples):
+ # max_length=None => use the model max length (it's actually the default)
+ outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+ return outputs
+
+ # Apply the method we just defined to all the examples in all the splits of the dataset
+ # starting with the main process first:
+ tokenized_datasets = datasets.map(
+ tokenize_function,
+ batched=True,
+ remove_columns=["idx", "sentence1", "sentence2"],
+ )
+
+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+ # transformers library
+ tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+ def collate_fn(examples):
+ return tokenizer.pad(
+ examples,
+ padding="longest",
+ pad_to_multiple_of=16, # Specific for FP8
+ return_tensors="pt",
+ )
+
+ # Instantiate dataloaders.
+ train_dataloader = DataLoader(
+ tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size, drop_last=True
+ )
+ eval_dataloader = DataLoader(
+ tokenized_datasets["validation"],
+ shuffle=False,
+ collate_fn=collate_fn,
+ batch_size=16,
+ drop_last=True,
+ )
+
+ return train_dataloader, eval_dataloader
+
+
+def get_training_utilities(model_name: str, batch_size: int = 16, accelerator=None):
+ """
+ Returns a tuple of:
+ - Model
+ - Optimizer
+ - Train dataloader (prepared)
+ - Eval dataloader (prepared)
+ - LR Scheduler
+ Suitable for training on the MRPC dataset
+ """
+ from torch.optim import AdamW
+ from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup
+
+ from accelerate import Accelerator
+
+ if accelerator is None:
+ accelerator = Accelerator()
+ model = AutoModelForSequenceClassification.from_pretrained(model_name)
+ train_dataloader, eval_dataloader = get_dataloaders(model_name, batch_size)
+ optimizer = AdamW(model.parameters(), lr=0.0001)
+ lr_scheduler = get_linear_schedule_with_warmup(
+ optimizer=optimizer,
+ num_warmup_steps=100,
+ num_training_steps=len(train_dataloader) * 2,
+ )
+ train_dataloader, eval_dataloader = accelerator.prepare(train_dataloader, eval_dataloader)
+ return model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+
+
+def get_named_parameters(model):
+ """
+ Same thing as `Accelerator.get_named_parameters` Returns a list of the named parameters of the model (extracted
+ from parallel)
+ """
+ from accelerate.utils import extract_model_from_parallel
+
+ model = extract_model_from_parallel(model)
+ return {n: p for n, p in model.named_parameters()}
+
+
+def evaluate_model(model, dataloader, metric, accelerator=None):
+ "Turns model to .eval(), runs dataloader, calculates metric, then turns eval back on"
+ model.eval()
+ for step, batch in enumerate(dataloader):
+ with torch.no_grad():
+ # W/ MS-AMP, we need to cast while evaluating
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ predictions = outputs.logits.argmax(dim=-1)
+ references = batch["labels"]
+ if accelerator is not None and accelerator.num_processes > 1:
+ predictions, references = accelerator.gather_for_metrics((predictions, references))
+ metric.add_batch(predictions=predictions, references=references)
+ return metric.compute()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/non_distributed.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/non_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fc659117cad26992c5353e140800637db67ee91
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/ms_amp/non_distributed.py
@@ -0,0 +1,122 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for single GPU training.
+"""
+
+import evaluate
+import msamp
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from packaging import version
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(opt_level="O2"):
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+
+ model, optimizer = msamp.initialize(model, optimizer, opt_level=opt_level)
+ model.to("cuda")
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+ if version.parse(torch.__version__) > version.parse("2.3"):
+ scaler = torch.amp.GradScaler("cuda")
+ else:
+ scaler = torch.cuda.amp.GradScaler()
+
+ for batch in train_dataloader:
+ batch = batch.to("cuda")
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss = scaler.scale(loss)
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(opt_level="O2"):
+ kwargs_handlers = [FP8RecipeKwargs(backend="msamp", opt_level=opt_level)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for opt_level in ["O1", "O2"]:
+ baseline_not_trained, baseline_trained = train_baseline(opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(opt_level)
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/Dockerfile b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..88c21934d4eb435565916376997fe16811057fb6
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/Dockerfile
@@ -0,0 +1,12 @@
+FROM nvcr.io/nvidia/pytorch:24.07-py3
+
+RUN pip install transformers evaluate datasets
+RUN git clone https://github.com/huggingface/accelerate.git
+
+RUN cd accelerate && \
+ pip install -e . && \
+ cd benchmarks/fp8
+
+RUN /bin/bash
+
+
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/README.md b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..71fb42dbdc192d4493d92c265fdaa62ec4eb5b34
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/README.md
@@ -0,0 +1,32 @@
+# FP8 Benchmarks
+
+Comparing and running [TransformerEngine](https://github.com/NVIDIA/TransformerEngine) FP8 with accelerate
+
+## Overview
+
+This repo provides scripts which compare native TransformerEngine model training against `accelerate`'s own integration. Each modeling type is segmented out via a script, supporting the following:
+
+* Single GPU training (`non_distributed.py`)
+* Multi-GPU training via DistributedDataParallelism (`ddp.py`)
+* Fully Sharded Data Parallelism (`fsdp.py`)
+* DeepSpeed ZeRO 1-3 (`deepspeed.py`)
+
+To run them, it's recommended to use a docker image (see the attached `Dockerfile`) and not install `TransformerEngine` manually.
+
+## Running:
+
+There are official Docker images located at `huggingface/accelerate:gpu-fp8-transformerengine-nightly` which can be used.
+
+You can run all scripts using the core `accelerate launch` command without any `accelerate config` being needed.
+
+For single GPU, run it via `python`:
+
+```bash
+python non_distributed.py
+```
+
+For the rest, run it via `accelerate launch`:
+
+```bash
+accelerate launch ddp.py # or distrib_deepspeed.py, ddp.py
+```
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/ddp.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/ddp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba708a27be4af1971e12490170ef1c7c6c7dad3e
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/ddp.py
@@ -0,0 +1,144 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for DDP training.
+"""
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from torch.nn.parallel import DistributedDataParallel as DDP
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+ model.to(device)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ new_named_params = get_named_parameters(model)
+
+ # Convert the model to DDP
+ device_ids, output_device = [accelerator.local_process_index], accelerator.local_process_index
+ model = DDP(model, device_ids=device_ids, output_device=output_device)
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to(device)
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py
new file mode 100644
index 0000000000000000000000000000000000000000..e678deb36597b9442062ce6d678959be871f414b
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py
@@ -0,0 +1,190 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for DDP training.
+"""
+
+from unittest.mock import patch
+
+import deepspeed
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator, DeepSpeedPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(zero_stage: int = 1):
+ # This forces transformers to think Zero-3 Init should be used
+ with patch("transformers.integrations.deepspeed.is_deepspeed_zero3_enabled") as mock:
+ mock.return_value = zero_stage == 3
+ set_seed(42)
+
+ accelerator = Accelerator()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+ new_named_params = get_named_parameters(model)
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ import numpy as np
+
+ config = {
+ "train_batch_size": 32,
+ "train_micro_batch_size_per_gpu": 16,
+ "gradient_accumulation_steps": 1,
+ "zero_optimization": {
+ "stage": zero_stage,
+ "offload_optimizer": {"device": "none", "nvme_path": None},
+ "offload_param": {"device": "none", "nvme_path": None},
+ "stage3_gather_16bit_weights_on_model_save": False,
+ },
+ "gradient_clipping": 1.0,
+ "steps_per_print": np.inf,
+ "bf16": {"enabled": True},
+ "fp16": {"enabled": False},
+ "zero_allow_untested_optimizer": True,
+ }
+
+ (
+ model,
+ optimizer,
+ _,
+ _,
+ ) = deepspeed.initialize(
+ model=model,
+ optimizer=optimizer,
+ config_params=config,
+ )
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ model_outputs = []
+ data = []
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ outputs = model(**batch)
+ data.append(batch.to("cpu"))
+ model_outputs.append(outputs.logits.to("cpu"))
+ loss = outputs.loss
+ model.backward(loss)
+ model.step()
+ for _ in range(accelerator.num_processes):
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results, model_outputs, data
+
+
+def train_integration(zero_stage: int = 1):
+ set_seed(42)
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ deepspeed_plugin = DeepSpeedPlugin(
+ zero_stage=zero_stage,
+ zero3_init_flag=zero_stage == 3,
+ )
+ accelerator = Accelerator(
+ mixed_precision="fp8", kwargs_handlers=kwargs_handlers, deepspeed_plugin=deepspeed_plugin
+ )
+ accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = 16
+
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ model_outputs = []
+ data = []
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ data.append(batch.to("cpu"))
+ model_outputs.append(outputs.logits.to("cpu"))
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results, model_outputs, data
+
+
+if __name__ == "__main__":
+ # for zero_stage in [1, 2, 3]:
+ zero_stage = 1
+ baseline_not_trained, baseline_trained, baseline_outputs, baseline_data = train_baseline(zero_stage)
+ accelerator_not_trained, accelerator_trained, accelerator_outputs, accelerator_data = train_integration(zero_stage)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}: Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'ZERO stage {zero_stage}: F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}: Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'ZERO stage {zero_stage}: F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fp8_utils.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fp8_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..d28702e05ff0bbd77d0a51428082336fb5314181
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fp8_utils.py
@@ -0,0 +1,116 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+
+
+def get_dataloaders(model_name: str, batch_size: int = 16):
+ from datasets import load_dataset
+ from torch.utils.data import DataLoader
+ from transformers import AutoTokenizer
+
+ tokenizer = AutoTokenizer.from_pretrained(model_name)
+ datasets = load_dataset("glue", "mrpc")
+
+ def tokenize_function(examples):
+ # max_length=None => use the model max length (it's actually the default)
+ outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+ return outputs
+
+ # Apply the method we just defined to all the examples in all the splits of the dataset
+ # starting with the main process first:
+ tokenized_datasets = datasets.map(
+ tokenize_function,
+ batched=True,
+ remove_columns=["idx", "sentence1", "sentence2"],
+ )
+
+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+ # transformers library
+ tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+ def collate_fn(examples):
+ return tokenizer.pad(
+ examples,
+ padding="longest",
+ pad_to_multiple_of=16, # Specific for FP8
+ return_tensors="pt",
+ )
+
+ # Instantiate dataloaders.
+ train_dataloader = DataLoader(
+ tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size, drop_last=True
+ )
+ eval_dataloader = DataLoader(
+ tokenized_datasets["validation"],
+ shuffle=False,
+ collate_fn=collate_fn,
+ batch_size=16,
+ drop_last=True,
+ )
+
+ return train_dataloader, eval_dataloader
+
+
+def get_training_utilities(model_name: str, batch_size: int = 16, accelerator=None):
+ """
+ Returns a tuple of:
+ - Model
+ - Optimizer
+ - Train dataloader (prepared)
+ - Eval dataloader (prepared)
+ - LR Scheduler
+ Suitable for training on the MRPC dataset
+ """
+ from torch.optim import AdamW
+ from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup
+
+ from accelerate import Accelerator
+
+ if accelerator is None:
+ accelerator = Accelerator()
+ model = AutoModelForSequenceClassification.from_pretrained(model_name)
+ train_dataloader, eval_dataloader = get_dataloaders(model_name, batch_size)
+ optimizer = AdamW(model.parameters(), lr=0.0001)
+ lr_scheduler = get_linear_schedule_with_warmup(
+ optimizer=optimizer,
+ num_warmup_steps=100,
+ num_training_steps=len(train_dataloader) * 2,
+ )
+ train_dataloader, eval_dataloader = accelerator.prepare(train_dataloader, eval_dataloader)
+ return model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+
+
+def get_named_parameters(model):
+ """
+ Same thing as `Accelerator.get_named_parameters` Returns a list of the named parameters of the model (extracted
+ from parallel)
+ """
+ from accelerate.utils import extract_model_from_parallel
+
+ model = extract_model_from_parallel(model)
+ return {n: p for n, p in model.named_parameters()}
+
+
+def evaluate_model(model, dataloader, metric, accelerator=None):
+ "Turns model to .eval(), runs dataloader, calculates metric, then turns eval back on"
+ model.eval()
+ for step, batch in enumerate(dataloader):
+ with torch.no_grad():
+ outputs = model(**batch)
+ predictions = outputs.logits.argmax(dim=-1)
+ references = batch["labels"]
+ if accelerator is not None and accelerator.num_processes > 1:
+ predictions, references = accelerator.gather_for_metrics((predictions, references))
+ metric.add_batch(predictions=predictions, references=references)
+ return metric.compute()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fsdp.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fsdp.py
new file mode 100644
index 0000000000000000000000000000000000000000..418122185e1f9bd4a8f0f783aaa199b0991d714d
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/fsdp.py
@@ -0,0 +1,161 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for FSDP training.
+"""
+
+from functools import partial
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.distributed.fsdp import MixedPrecision
+from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+from transformer_engine.common.recipe import DelayedScaling
+from transformers.models.bert import BertLayer
+
+from accelerate import Accelerator
+from accelerate import FullyShardedDataParallelPlugin as FSDPPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+FSDP_WRAP_POLICY = partial(transformer_auto_wrap_policy, transformer_layer_cls={BertLayer})
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+ model.to(device)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ new_named_params = get_named_parameters(model)
+
+ # Convert the model to FSDP
+ model = FSDP(
+ model,
+ use_orig_params=True,
+ mixed_precision=MixedPrecision(param_dtype=torch.bfloat16, reduce_dtype=torch.float32),
+ auto_wrap_policy=FSDP_WRAP_POLICY,
+ )
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to(device)
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ fsdp_plugin = FSDPPlugin(
+ auto_wrap_policy=FSDP_WRAP_POLICY,
+ use_orig_params=True,
+ mixed_precision_policy=MixedPrecision(param_dtype=torch.bfloat16, reduce_dtype=torch.float32),
+ )
+ accelerator = Accelerator(mixed_precision="fp8", fsdp_plugin=fsdp_plugin, kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/non_distributed.py b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/non_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..71d577c48d6715c09ef5ea2aff25bda5472634a1
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/benchmarks/fp8/transformer_engine/non_distributed.py
@@ -0,0 +1,132 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for single GPU training.
+"""
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ new_named_params = get_named_parameters(model)
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ model.to("cuda")
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to("cuda")
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/docker/README.md b/tasks/tasksmith-5db757e91a6e/environment/source/docker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e19e6caa4ae26b61dec7602f02199d3a4daf036
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/docker/README.md
@@ -0,0 +1,74 @@
+
+
+# Official Hugging Face Accelerate Docker Images
+
+Accelerate publishes a variety of docker versions as part of our CI that users can also use. These are stable images that Accelerate can run off of which comes with a variety of different setup configurations, all of which are officially hosted on [Docker Hub](https://hub.docker.com/r/huggingface/accelerate).
+
+A breakdown of each are given below
+
+## Naming Conventions
+
+Accelerate docker images follow a tagging convention of:
+
+```bash
+huggingface/accelerate:{accelerator}-{nightly,release}
+```
+
+`accelerator` in this instance is one of many applical pre-configured backend supports:
+* `gpu`: Comes compiled off of the `nvidia/cuda` image and includes core parts like `bitsandbytes`. Runs off python 3.9.
+* `cpu`: Comes compiled off of `python:3.9-slim` and is designed for non-CUDA based workloads.
+* More to come soon
+* `gpu-deepspeed`: Comes compiled off of the `nvidia/cuda` image and includes core parts like `bitsandbytes` as well as the latest `deepspeed` version. Runs off python 3.10.
+* `gpu-fp8-transformerengine`: Comes compiled off of `nvcr.io/nvidia/pytorch` and is specifically for running the `benchmarks/fp8` scripts on devices which support FP8 operations using the `TransformerEngine` library (RTX 4090, H100, etc)
+
+## Nightlies vs Releases
+
+Each release a new build is pushed with a version number included in the name. For a GPU-supported image of version 0.28.0 for instance, it would look like the following:
+
+```bash
+huggingface/accelerate:gpu-release-0.28.0
+```
+
+Nightlies contain two different image tags. There is a general `nightly` tag which is built each night, and a `nightly-YYYY-MM-DD` which corresponds to a build from a particular date.
+
+For instance, here is an example nightly CPU image from 3/14/2024
+
+```bash
+huggingface/accelerate:cpu-nightly-2024-03-14
+```
+
+## Running the images
+
+Each image comes compiled with `conda` and an `accelerate` environment contains all of the installed dependencies.
+
+To pull down the latest nightly run:
+
+```bash
+docker pull huggingface/accelerate:gpu-nightly
+```
+
+To then run it in interactive mode with GPU-memory available, run:
+
+```bash
+docker container run --gpus all -it huggingface/accelerate:gpu-nightly
+```
+
+## DEPRECATED IMAGES
+
+CPU and GPU docker images were hosted at `huggingface/accelerate-gpu` and `huggingface/accelerate-cpu`. These builds are now outdated and will not receive updates.
+
+The builds at the corresponding `huggingface/accelerate:{gpu,cpu}` contain the same `Dockerfile`, so it's as simple as changing the docker image to the desired ones from above. We will not be deleting these images for posterity, but they will not be receiving updates going forward.
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-cpu/Dockerfile b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-cpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..ac4176342151a2800971dec660a1465137d72769
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-cpu/Dockerfile
@@ -0,0 +1,35 @@
+# Builds CPU-only Docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+FROM python:3.8-slim as compile-image
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt update
+RUN apt-get install -y --no-install-recommends \
+ build-essential \
+ git \
+ gcc
+
+# Setup virtual environment for Docker
+ENV VIRTUAL_ENV=/opt/venv
+RUN python3 -m venv ${VIRTUAL_ENV}
+# Make sure we use the virtualenv
+ENV PATH="${VIRTUAL_ENV}/bin:$PATH"
+WORKDIR /workspace
+# Install specific CPU torch wheel to save on space
+RUN python3 -m pip install --upgrade --no-cache-dir pip
+RUN python3 -m pip install --no-cache-dir \
+ jupyter \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers] \
+ --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Stage 2
+FROM python:3.8-slim AS build-image
+COPY --from=compile-image /opt/venv /opt/venv
+RUN useradd -ms /bin/bash user
+USER user
+
+# Make sure we use the virtualenv
+ENV PATH="/opt/venv/bin:$PATH"
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu-deepspeed/Dockerfile b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu-deepspeed/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..d35fc1b5c5beedabc7b205f00655554bc366292d
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu-deepspeed/Dockerfile
@@ -0,0 +1,46 @@
+# Builds GPU docker image of PyTorch specifically
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+# Note: DeepSpeed beyond v0.12.6 requires py 3.10
+ENV PYTHON_VERSION=3.10
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+# Create our conda env
+RUN conda create --name accelerate python=${PYTHON_VERSION} ipython jupyter pip
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH /opt/conda/envs/accelerate/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env, install mpy4pi, and install torch + accelerate
+RUN source activate accelerate && conda install -c conda-forge mpi4py
+RUN source activate accelerate && \
+ python3 -m pip install --no-cache-dir \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers,deepspeed] \
+ --extra-index-url https://download.pytorch.org/whl/cu117
+
+RUN python3 -m pip install --no-cache-dir bitsandbytes
+
+# Stage 2
+FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu20.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH /opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate accelerate" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu/Dockerfile b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..e5aae6b528b5419f101e3d1bfa75ea58dbe1bca8
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/docker/accelerate-gpu/Dockerfile
@@ -0,0 +1,45 @@
+# Builds GPU docker image of PyTorch specifically
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.9
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+# Create our conda env
+RUN conda create --name accelerate python=${PYTHON_VERSION} ipython jupyter pip
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH /opt/conda/envs/accelerate/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env, install mpy4pi, and install torch + accelerate
+RUN source activate accelerate && conda install -c conda-forge mpi4py
+RUN source activate accelerate && \
+ python3 -m pip install --no-cache-dir \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers] \
+ --extra-index-url https://download.pytorch.org/whl/cu117
+
+RUN python3 -m pip install --no-cache-dir bitsandbytes
+
+# Stage 2
+FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu20.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH /opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate accelerate" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/pyproject.toml b/tasks/tasksmith-5db757e91a6e/environment/source/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..96d5ffb5ef7dda491bb7bcfad5264de07cfa7681
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/pyproject.toml
@@ -0,0 +1,43 @@
+[tool.ruff]
+line-length = 119
+target-version = "py38"
+
+[tool.ruff.lint]
+preview = true
+extend-select = [
+ "B009", # static getattr
+ "B010", # static setattr
+ "CPY", # Copyright
+ "E", # PEP8 errors
+ "F", # PEP8 formatting
+ "I", # Import sorting
+ "TID251", # Banned API
+ "UP", # Pyupgrade
+ "W", # PEP8 warnings
+]
+ignore = [
+ "E501", # Line length (handled by ruff-format)
+ "E741", # Ambiguous variable name
+ "W605", # Invalid escape sequence
+ "UP007", # X | Y type annotations
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = [
+ "F401", # Ignore seemingly unused imports (they're meant for re-export)
+]
+"manim_animations/*" = ["ALL"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["accelerate"]
+
+[tool.ruff.format]
+exclude = [
+ "manim_animations/*"
+]
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"os.getenv".msg = "Use os.environ instead"
+"os.putenv".msg = "Use os.environ instead"
+"os.unsetenv".msg = "Use os.environ instead"
diff --git a/tasks/tasksmith-5db757e91a6e/environment/source/setup.py b/tasks/tasksmith-5db757e91a6e/environment/source/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8c666e9367a33b670a22f04acd6eb1f247b0a0f
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/environment/source/setup.py
@@ -0,0 +1,122 @@
+# Copyright 2021 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from setuptools import find_packages, setup
+
+
+extras = {}
+extras["quality"] = [
+ "black ~= 23.1", # hf-doc-builder has a hidden dependency on `black`
+ "hf-doc-builder >= 0.3.0",
+ "ruff ~= 0.6.4",
+]
+extras["docs"] = []
+extras["test_prod"] = ["pytest>=7.2.0,<=8.0.0", "pytest-xdist", "pytest-subtests", "parameterized"]
+extras["test_dev"] = [
+ "datasets",
+ "diffusers",
+ "evaluate",
+ "torchdata>=0.8.0",
+ "torchpippy>=0.2.0",
+ "transformers",
+ "scipy",
+ "scikit-learn",
+ "tqdm",
+ "bitsandbytes",
+ "timm",
+]
+extras["testing"] = extras["test_prod"] + extras["test_dev"]
+extras["deepspeed"] = ["deepspeed"]
+extras["rich"] = ["rich"]
+
+extras["test_trackers"] = ["wandb", "comet-ml", "tensorboard", "dvclive"]
+extras["dev"] = extras["quality"] + extras["testing"] + extras["rich"]
+
+extras["sagemaker"] = [
+ "sagemaker", # boto3 is a required package in sagemaker
+]
+
+setup(
+ name="accelerate",
+ version="0.35.0.dev0",
+ description="Accelerate",
+ long_description=open("README.md", encoding="utf-8").read(),
+ long_description_content_type="text/markdown",
+ keywords="deep learning",
+ license="Apache",
+ author="The HuggingFace team",
+ author_email="zach.mueller@huggingface.co",
+ url="https://github.com/huggingface/accelerate",
+ package_dir={"": "src"},
+ packages=find_packages("src"),
+ entry_points={
+ "console_scripts": [
+ "accelerate=accelerate.commands.accelerate_cli:main",
+ "accelerate-config=accelerate.commands.config:main",
+ "accelerate-estimate-memory=accelerate.commands.estimate:main",
+ "accelerate-launch=accelerate.commands.launch:main",
+ "accelerate-merge-weights=accelerate.commands.merge:main",
+ ]
+ },
+ python_requires=">=3.8.0",
+ install_requires=[
+ "numpy>=1.17,<3.0.0",
+ "packaging>=20.0",
+ "psutil",
+ "pyyaml",
+ "torch>=1.10.0",
+ "huggingface_hub>=0.21.0",
+ "safetensors>=0.4.3",
+ ],
+ extras_require=extras,
+ classifiers=[
+ "Development Status :: 5 - Production/Stable",
+ "Intended Audience :: Developers",
+ "Intended Audience :: Education",
+ "Intended Audience :: Science/Research",
+ "License :: OSI Approved :: Apache Software License",
+ "Operating System :: OS Independent",
+ "Programming Language :: Python :: 3",
+ "Programming Language :: Python :: 3.8",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+ ],
+)
+
+# Release checklist
+# 1. Checkout the release branch (for a patch the current release branch, for a new minor version, create one):
+# git checkout -b vXX.xx-release
+# The -b is only necessary for creation (so remove it when doing a patch)
+# 2. Change the version in __init__.py and setup.py to the proper value.
+# 3. Commit these changes with the message: "Release: v
+
+
+
+
+ +
+
+
+
+
+
+
+
Run your *raw* PyTorch training script on any kind of device + + +
+
+
+
+## Easy to integrate
+
+🤗 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.
+
+🤗 Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.
+
+Here is an example:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
++ accelerator = Accelerator()
+- device = 'cpu'
++ device = accelerator.device
+
+ model = torch.nn.Transformer().to(device)
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+ source = source.to(device)
+ targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+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 (fp8, fp16, bf16).
+
+In particular, the same code can then be run without modification on your local machine for debugging or your training environment.
+
+🤗 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:
+
+```diff
+ import torch
+ import torch.nn.functional as F
+ from datasets import load_dataset
++ from accelerate import Accelerator
+
+- device = 'cpu'
++ accelerator = Accelerator()
+
+- model = torch.nn.Transformer().to(device)
++ model = torch.nn.Transformer()
+ optimizer = torch.optim.Adam(model.parameters())
+
+ dataset = load_dataset('my_dataset')
+ data = torch.utils.data.DataLoader(dataset, shuffle=True)
+
++ model, optimizer, data = accelerator.prepare(model, optimizer, data)
+
+ model.train()
+ for epoch in range(10):
+ for source, targets in data:
+- source = source.to(device)
+- targets = targets.to(device)
+
+ optimizer.zero_grad()
+
+ output = model(source)
+ loss = F.cross_entropy(output, targets)
+
+- loss.backward()
++ accelerator.backward(loss)
+
+ optimizer.step()
+```
+
+Want to learn more? Check out the [documentation](https://huggingface.co/docs/accelerate) or have a look at our [examples](https://github.com/huggingface/accelerate/tree/main/examples).
+
+## Launching script
+
+🤗 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.run` or to write a specific launcher for TPU training!
+On your machine(s) just run:
+
+```bash
+accelerate config
+```
+
+and answer the questions asked. This will generate a config file that will be used automatically to properly set the default options when doing
+
+```bash
+accelerate launch my_script.py --args_to_my_script
+```
+
+For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):
+
+```bash
+accelerate launch examples/nlp_example.py
+```
+
+This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torchrun my_script.py` at your convenience.
+
+You can also directly pass in the arguments you would to `torchrun` as arguments to `accelerate launch` if you wish to not run` accelerate config`.
+
+For example, here is how to launch on two GPUs:
+
+```bash
+accelerate launch --multi_gpu --num_processes 2 examples/nlp_example.py
+```
+
+To learn more, check the CLI documentation available [here](https://huggingface.co/docs/accelerate/package_reference/cli).
+
+Or view the configuration zoo [here](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates/)
+
+## Launching multi-CPU run using MPI
+
+🤗 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.
+Once you have MPI setup on your cluster, just run:
+```bash
+accelerate config
+```
+Answer the questions that are asked, selecting to run using multi-CPU, and answer "yes" when asked if you want accelerate to launch mpirun.
+Then, use `accelerate launch` with your script like:
+```bash
+accelerate launch examples/nlp_example.py
+```
+Alternatively, you can use mpirun directly, without using the CLI like:
+```bash
+mpirun -np 2 python examples/nlp_example.py
+```
+
+## Launching training using DeepSpeed
+
+🤗 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`.
+
+```python
+from accelerate import Accelerator, DeepSpeedPlugin
+
+# deepspeed needs to know your gradient accumulation steps beforehand, so don't forget to pass it
+# Remember you still need to do gradient accumulation by yourself, just like you would have done without deepspeed
+deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)
+accelerator = Accelerator(mixed_precision='fp16', deepspeed_plugin=deepspeed_plugin)
+
+# How to save your 🤗 Transformer?
+accelerator.wait_for_everyone()
+unwrapped_model = accelerator.unwrap_model(model)
+unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
+```
+
+Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.
+
+## Launching your training from a notebook
+
+🤗 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:
+
+```python
+from accelerate import notebook_launcher
+
+notebook_launcher(training_function)
+```
+
+An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb). [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb)
+
+## Why should I use 🤗 Accelerate?
+
+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.
+
+## Why shouldn't I use 🤗 Accelerate?
+
+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.
+
+## Frameworks using 🤗 Accelerate
+
+If you like the simplicity of 🤗 Accelerate but would prefer a higher-level abstraction around its capabilities, some frameworks and libraries that are built on top of 🤗 Accelerate are listed below:
+
+* [Amphion](https://github.com/open-mmlab/Amphion) is a toolkit for Audio, Music, and Speech Generation. Its purpose is to support reproducible research and help junior researchers and engineers get started in the field of audio, music, and speech generation research and development.
+* [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).
+* [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 training, and inference logic.
+* [fastai](https://github.com/fastai/fastai#installing) is a PyTorch framework for Deep Learning that simplifies training fast and accurate neural nets using modern best practices. fastai provides a [Learner](https://docs.fast.ai/learner.html#Learner) to handle the training, fine-tuning, and inference of deep learning algorithms.
+* [Finetuner](https://github.com/jina-ai/finetuner) is a service that enables models to create higher-quality embeddings for semantic search, visual similarity search, cross-modal text<->image search, recommendation systems, clustering, duplication detection, anomaly detection, or other uses.
+* [InvokeAI](https://github.com/invoke-ai/InvokeAI) is a creative engine for Stable Diffusion models, offering industry-leading WebUI, terminal usage support, and serves as the foundation for many commercial products.
+* [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.
+* [Open Assistant](https://projects.laion.ai/Open-Assistant/) is a chat-based assistant that understands tasks, can interact with their party systems, and retrieve information dynamically to do so.
+* [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centered 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!
+* [Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is an open-source browser-based easy-to-use interface based on the Gradio library for Stable Diffusion.
+* [torchkeras](https://github.com/lyhue1991/torchkeras) is a simple tool for training pytorch model just in a keras style, a dynamic and beautiful plot is provided in notebook to monitor your loss or metric.
+* [transformers](https://github.com/huggingface/transformers) as a tool for helping train state-of-the-art machine learning models in PyTorch, Tensorflow, and JAX. (Accelerate is the backend for the PyTorch side).
+
+
+## Installation
+
+This repository is tested on Python 3.8+ and PyTorch 1.10.0+
+
+You should install 🤗 Accelerate in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
+
+First, create a virtual environment with the version of Python you're going to use and activate it.
+
+Then, you will need to install PyTorch: refer to the [official installation page](https://pytorch.org/get-started/locally/#start-locally) regarding the specific install command for your platform. Then 🤗 Accelerate can be installed using pip as follows:
+
+```bash
+pip install accelerate
+```
+
+## Supported integrations
+
+- CPU only
+- multi-CPU on one node (machine)
+- multi-CPU on several nodes (machines)
+- single GPU
+- multi-GPU on one node (machine)
+- multi-GPU on several nodes (machines)
+- TPU
+- FP16/BFloat16 mixed precision
+- FP8 mixed precision with [Transformer Engine](https://github.com/NVIDIA/TransformerEngine) or [MS-AMP](https://github.com/Azure/MS-AMP/)
+- DeepSpeed support (Experimental)
+- PyTorch Fully Sharded Data Parallel (FSDP) support (Experimental)
+- Megatron-LM support (Experimental)
+
+## Citing 🤗 Accelerate
+
+If you use 🤗 Accelerate in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{accelerate,
+ title = {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
+ author = {Sylvain Gugger and Lysandre Debut and Thomas Wolf and Philipp Schmid and Zachary Mueller and Sourab Mangrulkar and Marc Sun and Benjamin Bossan},
+ howpublished = {\url{https://github.com/huggingface/accelerate}},
+ year = {2022}
+}
+```
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/README.md b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a2381ac4182437151c1840847970bb6ade6bcbe
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/README.md
@@ -0,0 +1,5 @@
+# Benchmarks
+
+The folders below contain suites to test various functionalities in Accelerate.
+
+See their relevant README.md's for more information.
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/README.md b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..243e9df58ea92bc4148101a5fcf399978cbf07f3
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/README.md
@@ -0,0 +1,46 @@
+# Big model inference benchmarks
+
+Running inference with Accelerate on big models.
+
+## Setup
+
+These benchmarks use the `transformers` library:
+
+```bash
+pip install transformers
+```
+
+To reproduce or test a new setup, run
+
+```py
+python inference_acc.py model_name
+```
+
+This script supports `gpt-j-6b`, `gpt-neox`, `opt` (30B version) and `T0pp` out of the box, but you can specify any valid checkpoint for `model_name`.
+
+To force a different `torch_dtype` than the one in the config: `--torch_dtype xxx`.
+
+If you get an error linked to disk offload, you need to add the option `--disk-offload`
+
+## Results
+
+On a setup with two Titan RTXs (24GB of RAM) and 32GB of RAM, we get the following benchmarks (T0pp does not run in float16, which is why it's not included).
+
+| Model | Model load time | Generation time | dtype | GPU 0 use | GPU 1 use | CPU use | Disk offload |
+|:-----:|:---------------:|:---------------:|:-----:|:---------:|:---------:|:-------:|:------------:|
+| GPT-J-6B | 8.7s | 0.05s per token | float16 | 11.7GB | 0GB | 0GB | no |
+| GPT-J-6B | 12.4s | 0.06s per token | float32 | 21.9GB | 1.5GB | 0GB | no |
+| GPT-Neo-X-20B | 30.9s | 0.08s per token | float16 | 21.5GB | 18GB | 0GB | no |
+| GPT-Neo-X-20B | 78.2s | 10.72s per token | float32 | 20.3GB | 22.7 GB | 24.4GB | yes |
+| T0pp (11B) | 29.4s | 0.05s per token | float32 | 21.1GB | 21.3GB | 0GB | no |
+| OPT-30B | 34.5s | 2.37s per token | float16 | 20.7GB | 22.3GB | 14.1GB | no |
+| OPT-30B | 112.3s | 33.9s per token | float32 | 20.2GB | 21.2GB | 23.5GB | yes |
+
+Note on the results:
+- using two GPUs instead of one does not slow down generation
+- using CPU offload slows down a bit (see OPT-30b)
+- using disk offload slows down a lot (need to implement prefetching)
+
+You will also note that Accelerate does not use anymore GPU and CPU RAM than necessary:
+- peak GPU memory is exactly the size of the model put on a given GPU
+- peak CPU memory is either the size of the biggest checkpoint shard or the part of the model offloaded on CPU, whichever is bigger.
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/big_model_inference.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/big_model_inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7874e625805c5f9581508dbe69f4456adfdae4a
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/big_model_inference.py
@@ -0,0 +1,143 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import time
+
+import torch
+import transformers
+from measures_util import end_measure, log_measures, start_measure
+from transformers import AutoConfig, AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer
+
+from accelerate.utils import compute_module_sizes
+
+
+DEFAULT_MODELS = {
+ "gpt-j-6b": {"is_causal": True, "model": "sgugger/sharded-gpt-j-6B", "tokenizer": "EleutherAI/gpt-j-6B"},
+ "gpt-neox": {"is_causal": True, "model": "EleutherAI/gpt-neox-20b"},
+ "opt": {"is_causal": True, "model": "facebook/opt-30b"},
+ "T0pp": {"is_causal": False, "model": "bigscience/T0pp", "model_revision": "sharded"},
+}
+
+PROMPTS = [
+ "Hello, my name is",
+ "Are unicorns real? Unicorns are",
+ "For the first time in several years,",
+ "My name is Julien and I am",
+ "The goal of life is",
+ "Whenever I'm sad, I like to",
+]
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description="Run and time generations on a big model using Accelerate.")
+ parser.add_argument("model_name", type=str, default=None, help="The name of the model to try.")
+ parser.add_argument(
+ "--tokenizer_name", type=str, default=None, help="The name of the tokenizer (if different from the model."
+ )
+ parser.add_argument("--is_causal", type=bool, default=None, help="Whether or not the model is causal.")
+ parser.add_argument(
+ "--model_revision", type=str, default=None, help="The revision to use for the model checkpoint."
+ )
+ parser.add_argument("--torch_dtype", type=str, default=None, help="The dtype for the model.")
+ parser.add_argument("--disk_offload", action="store_true")
+
+ args = parser.parse_args()
+
+ # Sanitize args
+ if args.model_name in DEFAULT_MODELS:
+ defaults = DEFAULT_MODELS[args.model_name]
+ args.model_name = defaults["model"]
+ if args.tokenizer_name is None:
+ args.tokenizer_name = defaults.get("tokenizer", args.model_name)
+ if args.is_causal is None:
+ args.is_causal = defaults["is_causal"]
+ if args.model_revision is None:
+ args.model_revision = defaults.get("model_revision", "main")
+
+ if args.is_causal is None:
+ raise ValueError("Could not infer the default for `--is_causal`, pass either True or False for it.")
+ if args.tokenizer_name is None:
+ args.tokenizer_name = args.model_name
+ if args.model_revision is None:
+ args.model_revision = "main"
+
+ return args
+
+
+def main():
+ transformers.utils.logging.set_verbosity_error()
+ args = parse_args()
+
+ if args.torch_dtype is None:
+ config = AutoConfig.from_pretrained(args.model_name)
+ torch_dtype = getattr(config, "torch_dtype", torch.float32)
+ else:
+ torch_dtype = getattr(torch, args.torch_dtype)
+ model_cls = AutoModelForCausalLM if args.is_causal else AutoModelForSeq2SeqLM
+ kwargs = {
+ "torch_dtype": torch_dtype,
+ "revision": args.model_revision,
+ }
+ if args.disk_offload:
+ kwargs["offload_folder"] = "tmp_offload"
+ kwargs["offload_state_dict"] = True
+
+ start_measures = start_measure()
+ model = model_cls.from_pretrained(args.model_name, device_map="auto", **kwargs)
+ end_measures = end_measure(start_measures)
+ log_measures(end_measures, "Model loading")
+
+ module_sizes = compute_module_sizes(model)
+ device_size = {v: 0 for v in model.hf_device_map.values()}
+ for module, device in model.hf_device_map.items():
+ device_size[device] += module_sizes[module]
+ message = "\n".join([f"- {device}: {size // 2**20}MiB" for device, size in device_size.items()])
+ print(f"\nTheoretical use:\n{message}")
+
+ tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name)
+
+ start_measures = start_measure()
+ generation_times = []
+ gen_tokens = []
+ texts_outs = []
+ for prompt in PROMPTS:
+ inputs = tokenizer(prompt, return_tensors="pt").to(0)
+ tokens = inputs["input_ids"][0].tolist()
+ before_generate = time.time()
+ outputs = model.generate(inputs["input_ids"])
+ after_generate = time.time()
+ outputs = outputs[0].tolist()
+ num_gen_tokens = len(outputs) if outputs[: len(tokens)] != tokens else len(outputs) - len(tokens)
+ generation_time = after_generate - before_generate
+
+ text_out = tokenizer.decode(outputs, skip_special_tokens=True)
+ texts_outs.append(text_out)
+ generation_times.append(generation_time)
+ gen_tokens.append(num_gen_tokens)
+ print(f"Prompt: {prompt}\nGeneration {text_out}\nIn {generation_time:.2f}s for {num_gen_tokens} tokens\n")
+
+ end_measures = end_measure(start_measures)
+ log_measures(end_measures, "Model generation")
+
+ generation_times_per_token = [gen / tok for gen, tok in zip(generation_times, gen_tokens)]
+ avg_gen = sum(generation_times_per_token) / len(generation_times)
+ print(f"Average time of generation per token: {avg_gen:.2f}s")
+ print(f"First generation (avg time per token): {generation_times_per_token[0]:.2f}s")
+ avg_gen = sum(generation_times_per_token[1:]) / (len(generation_times_per_token) - 1)
+ print(f"Average time of generation per token (excluding the first): {avg_gen:.2f}s")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/measures_util.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/measures_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..f22c0792f45f98c7719eb5a3314865020515658e
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/big_model_inference/measures_util.py
@@ -0,0 +1,98 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import gc
+import threading
+import time
+
+import psutil
+import torch
+
+
+class PeakCPUMemory:
+ def __init__(self):
+ self.process = psutil.Process()
+ self.peak_monitoring = False
+
+ def peak_monitor(self):
+ self.cpu_memory_peak = -1
+
+ while True:
+ self.cpu_memory_peak = max(self.process.memory_info().rss, self.cpu_memory_peak)
+
+ # can't sleep or will not catch the peak right (this comment is here on purpose)
+ if not self.peak_monitoring:
+ break
+
+ def start(self):
+ self.peak_monitoring = True
+ self.thread = threading.Thread(target=self.peak_monitor)
+ self.thread.daemon = True
+ self.thread.start()
+
+ def stop(self):
+ self.peak_monitoring = False
+ self.thread.join()
+ return self.cpu_memory_peak
+
+
+cpu_peak_tracker = PeakCPUMemory()
+
+
+def start_measure():
+ # Time
+ measures = {"time": time.time()}
+
+ gc.collect()
+ torch.cuda.empty_cache()
+
+ # CPU mem
+ measures["cpu"] = psutil.Process().memory_info().rss
+ cpu_peak_tracker.start()
+
+ # GPU mem
+ for i in range(torch.cuda.device_count()):
+ measures[str(i)] = torch.cuda.memory_allocated(i)
+ torch.cuda.reset_peak_memory_stats()
+
+ return measures
+
+
+def end_measure(start_measures):
+ # Time
+ measures = {"time": time.time() - start_measures["time"]}
+
+ gc.collect()
+ torch.cuda.empty_cache()
+
+ # CPU mem
+ measures["cpu"] = (psutil.Process().memory_info().rss - start_measures["cpu"]) / 2**20
+ measures["cpu-peak"] = (cpu_peak_tracker.stop() - start_measures["cpu"]) / 2**20
+
+ # GPU mem
+ for i in range(torch.cuda.device_count()):
+ measures[str(i)] = (torch.cuda.memory_allocated(i) - start_measures[str(i)]) / 2**20
+ measures[f"{i}-peak"] = (torch.cuda.max_memory_allocated(i) - start_measures[str(i)]) / 2**20
+
+ return measures
+
+
+def log_measures(measures, description):
+ print(f"{description}:")
+ print(f"- Time: {measures['time']:.2f}s")
+ for i in range(torch.cuda.device_count()):
+ print(f"- GPU {i} allocated: {measures[str(i)]:.2f}MiB")
+ peak = measures[f"{i}-peak"]
+ print(f"- GPU {i} peak: {peak:.2f}MiB")
+ print(f"- CPU RAM allocated: {measures['cpu']:.2f}MiB")
+ print(f"- CPU RAM peak: {measures['cpu-peak']:.2f}MiB")
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/Dockerfile b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..4d7778200a52b9a5bbf33979bbb3cd34090854dd
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/Dockerfile
@@ -0,0 +1,12 @@
+FROM ghcr.io/azure/msamp
+
+RUN pip install transformers evaluate datasets
+RUN git clone https://github.com/huggingface/accelerate
+
+RUN cd accelerate && \
+ pip install -e . && \
+ cd benchmarks/fp8
+
+CMD ["bash"]
+
+
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/ddp.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/ddp.py
new file mode 100644
index 0000000000000000000000000000000000000000..25d9fc0a7bf63533ae9b34cc8f397bf22cb45987
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/ddp.py
@@ -0,0 +1,127 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for DDP training.
+"""
+
+import evaluate
+import msamp
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from packaging import version
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(opt_level="O2"):
+ set_seed(42)
+ if version.parse(torch.__version__) > version.parse("2.3"):
+ scaler = torch.amp.GradScaler("cuda")
+ else:
+ scaler = torch.cuda.amp.GradScaler()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+
+ model, optimizer = msamp.initialize(model, optimizer, opt_level=opt_level)
+
+ model.to(device)
+
+ # Convert the model to DDP
+ device_ids, output_device = [accelerator.local_process_index], accelerator.local_process_index
+ model = DDP(model, device_ids=device_ids, output_device=output_device)
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for i, batch in enumerate(train_dataloader):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ scaler.scale(loss).backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(opt_level="O2"):
+ kwargs_handlers = [FP8RecipeKwargs(backend="msamp", opt_level=opt_level)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ for i, batch in enumerate(train_dataloader):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for opt_level in ["O1", "O2"]:
+ baseline_not_trained, baseline_trained = train_baseline(opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(opt_level)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy not the same for untrained baseline and accelerator using opt_level={opt_level}: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 not the same for untrained baseline and accelerator using opt_level={opt_level}: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy not the same for trained baseline and accelerator using opt_level={opt_level}: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 not the same for trained baseline and accelerator using opt_level={opt_level}: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py
new file mode 100644
index 0000000000000000000000000000000000000000..57a2569729f055122d4d0ed6fe4a6f07f88c3fb3
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/distrib_deepspeed.py
@@ -0,0 +1,161 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for DeepSpeed training.
+
+NOTE: MS-AMP does *not* support ZeRO-3.
+"""
+
+# import msamp.deepspeed as msamp_deepspeed
+import evaluate
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from msamp import deepspeed as msamp_deepspeed
+
+from accelerate import Accelerator, DeepSpeedPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(zero_stage: int = 1, opt_level: str = "O1"):
+ set_seed(42)
+ accelerator = Accelerator()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ import numpy as np
+
+ config = {
+ "train_batch_size": 32,
+ "train_micro_batch_size_per_gpu": 16,
+ "gradient_accumulation_steps": 1,
+ "zero_optimization": {
+ "stage": zero_stage,
+ "offload_optimizer": {"device": "none", "nvme_path": None},
+ "offload_param": {"device": "none", "nvme_path": None},
+ },
+ "gradient_clipping": 1.0,
+ "steps_per_print": np.inf,
+ "bf16": {"enabled": True},
+ "fp16": {"enabled": False},
+ "zero_allow_untested_optimizer": True,
+ "msamp": {
+ "enabled": True,
+ "opt_level": opt_level,
+ },
+ }
+ (
+ model,
+ optimizer,
+ _,
+ _,
+ ) = msamp_deepspeed.initialize(
+ model=model,
+ optimizer=optimizer,
+ config_params=config,
+ )
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ model.backward(loss)
+ model.step()
+ for _ in range(accelerator.num_processes):
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ torch.cuda.empty_cache()
+ AcceleratorState()._reset_state(True)
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(zero_stage: int = 1, opt_level: str = "O1"):
+ set_seed(42)
+ deepspeed_plugin = DeepSpeedPlugin(
+ zero_stage=zero_stage,
+ enable_msamp=True,
+ msamp_opt_level=opt_level,
+ )
+ accelerator = Accelerator(mixed_precision="fp8", deepspeed_plugin=deepspeed_plugin)
+ accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = 16
+
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ torch.cuda.empty_cache()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ AcceleratorState()._reset_state(True)
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for zero_stage in [1, 2]:
+ for opt_level in ["O1", "O2", "O3"]:
+ baseline_not_trained, baseline_trained = train_baseline(zero_stage, opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(zero_stage, opt_level)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nAccuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nF1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nAccuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'ZERO stage {zero_stage}, opt_level={opt_level}:\nF1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/fp8_utils.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/fp8_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..602ce07fdc62b39c60b2dd62cf8a0fe2e085a308
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/fp8_utils.py
@@ -0,0 +1,118 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+
+
+def get_dataloaders(model_name: str, batch_size: int = 16):
+ from datasets import load_dataset
+ from torch.utils.data import DataLoader
+ from transformers import AutoTokenizer
+
+ tokenizer = AutoTokenizer.from_pretrained(model_name)
+ datasets = load_dataset("glue", "mrpc")
+
+ def tokenize_function(examples):
+ # max_length=None => use the model max length (it's actually the default)
+ outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+ return outputs
+
+ # Apply the method we just defined to all the examples in all the splits of the dataset
+ # starting with the main process first:
+ tokenized_datasets = datasets.map(
+ tokenize_function,
+ batched=True,
+ remove_columns=["idx", "sentence1", "sentence2"],
+ )
+
+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+ # transformers library
+ tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+ def collate_fn(examples):
+ return tokenizer.pad(
+ examples,
+ padding="longest",
+ pad_to_multiple_of=16, # Specific for FP8
+ return_tensors="pt",
+ )
+
+ # Instantiate dataloaders.
+ train_dataloader = DataLoader(
+ tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size, drop_last=True
+ )
+ eval_dataloader = DataLoader(
+ tokenized_datasets["validation"],
+ shuffle=False,
+ collate_fn=collate_fn,
+ batch_size=16,
+ drop_last=True,
+ )
+
+ return train_dataloader, eval_dataloader
+
+
+def get_training_utilities(model_name: str, batch_size: int = 16, accelerator=None):
+ """
+ Returns a tuple of:
+ - Model
+ - Optimizer
+ - Train dataloader (prepared)
+ - Eval dataloader (prepared)
+ - LR Scheduler
+ Suitable for training on the MRPC dataset
+ """
+ from torch.optim import AdamW
+ from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup
+
+ from accelerate import Accelerator
+
+ if accelerator is None:
+ accelerator = Accelerator()
+ model = AutoModelForSequenceClassification.from_pretrained(model_name)
+ train_dataloader, eval_dataloader = get_dataloaders(model_name, batch_size)
+ optimizer = AdamW(model.parameters(), lr=0.0001)
+ lr_scheduler = get_linear_schedule_with_warmup(
+ optimizer=optimizer,
+ num_warmup_steps=100,
+ num_training_steps=len(train_dataloader) * 2,
+ )
+ train_dataloader, eval_dataloader = accelerator.prepare(train_dataloader, eval_dataloader)
+ return model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+
+
+def get_named_parameters(model):
+ """
+ Same thing as `Accelerator.get_named_parameters` Returns a list of the named parameters of the model (extracted
+ from parallel)
+ """
+ from accelerate.utils import extract_model_from_parallel
+
+ model = extract_model_from_parallel(model)
+ return {n: p for n, p in model.named_parameters()}
+
+
+def evaluate_model(model, dataloader, metric, accelerator=None):
+ "Turns model to .eval(), runs dataloader, calculates metric, then turns eval back on"
+ model.eval()
+ for step, batch in enumerate(dataloader):
+ with torch.no_grad():
+ # W/ MS-AMP, we need to cast while evaluating
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ predictions = outputs.logits.argmax(dim=-1)
+ references = batch["labels"]
+ if accelerator is not None and accelerator.num_processes > 1:
+ predictions, references = accelerator.gather_for_metrics((predictions, references))
+ metric.add_batch(predictions=predictions, references=references)
+ return metric.compute()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/non_distributed.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/non_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fc659117cad26992c5353e140800637db67ee91
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/ms_amp/non_distributed.py
@@ -0,0 +1,122 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `MS-AMP`.
+
+This particular script verifies this for single GPU training.
+"""
+
+import evaluate
+import msamp
+import torch
+from fp8_utils import evaluate_model, get_training_utilities
+from packaging import version
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(opt_level="O2"):
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+
+ model, optimizer = msamp.initialize(model, optimizer, opt_level=opt_level)
+ model.to("cuda")
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+ if version.parse(torch.__version__) > version.parse("2.3"):
+ scaler = torch.amp.GradScaler("cuda")
+ else:
+ scaler = torch.cuda.amp.GradScaler()
+
+ for batch in train_dataloader:
+ batch = batch.to("cuda")
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss = scaler.scale(loss)
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration(opt_level="O2"):
+ kwargs_handlers = [FP8RecipeKwargs(backend="msamp", opt_level=opt_level)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ for opt_level in ["O1", "O2"]:
+ baseline_not_trained, baseline_trained = train_baseline(opt_level)
+ accelerator_not_trained, accelerator_trained = train_integration(opt_level)
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/Dockerfile b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..88c21934d4eb435565916376997fe16811057fb6
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/Dockerfile
@@ -0,0 +1,12 @@
+FROM nvcr.io/nvidia/pytorch:24.07-py3
+
+RUN pip install transformers evaluate datasets
+RUN git clone https://github.com/huggingface/accelerate.git
+
+RUN cd accelerate && \
+ pip install -e . && \
+ cd benchmarks/fp8
+
+RUN /bin/bash
+
+
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/README.md b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..71fb42dbdc192d4493d92c265fdaa62ec4eb5b34
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/README.md
@@ -0,0 +1,32 @@
+# FP8 Benchmarks
+
+Comparing and running [TransformerEngine](https://github.com/NVIDIA/TransformerEngine) FP8 with accelerate
+
+## Overview
+
+This repo provides scripts which compare native TransformerEngine model training against `accelerate`'s own integration. Each modeling type is segmented out via a script, supporting the following:
+
+* Single GPU training (`non_distributed.py`)
+* Multi-GPU training via DistributedDataParallelism (`ddp.py`)
+* Fully Sharded Data Parallelism (`fsdp.py`)
+* DeepSpeed ZeRO 1-3 (`deepspeed.py`)
+
+To run them, it's recommended to use a docker image (see the attached `Dockerfile`) and not install `TransformerEngine` manually.
+
+## Running:
+
+There are official Docker images located at `huggingface/accelerate:gpu-fp8-transformerengine-nightly` which can be used.
+
+You can run all scripts using the core `accelerate launch` command without any `accelerate config` being needed.
+
+For single GPU, run it via `python`:
+
+```bash
+python non_distributed.py
+```
+
+For the rest, run it via `accelerate launch`:
+
+```bash
+accelerate launch ddp.py # or distrib_deepspeed.py, ddp.py
+```
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/ddp.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/ddp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba708a27be4af1971e12490170ef1c7c6c7dad3e
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/ddp.py
@@ -0,0 +1,144 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for DDP training.
+"""
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from torch.nn.parallel import DistributedDataParallel as DDP
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+ model.to(device)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ new_named_params = get_named_parameters(model)
+
+ # Convert the model to DDP
+ device_ids, output_device = [accelerator.local_process_index], accelerator.local_process_index
+ model = DDP(model, device_ids=device_ids, output_device=output_device)
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to(device)
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py
new file mode 100644
index 0000000000000000000000000000000000000000..e678deb36597b9442062ce6d678959be871f414b
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/distrib_deepspeed.py
@@ -0,0 +1,190 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for DDP training.
+"""
+
+from unittest.mock import patch
+
+import deepspeed
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator, DeepSpeedPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline(zero_stage: int = 1):
+ # This forces transformers to think Zero-3 Init should be used
+ with patch("transformers.integrations.deepspeed.is_deepspeed_zero3_enabled") as mock:
+ mock.return_value = zero_stage == 3
+ set_seed(42)
+
+ accelerator = Accelerator()
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+ new_named_params = get_named_parameters(model)
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ import numpy as np
+
+ config = {
+ "train_batch_size": 32,
+ "train_micro_batch_size_per_gpu": 16,
+ "gradient_accumulation_steps": 1,
+ "zero_optimization": {
+ "stage": zero_stage,
+ "offload_optimizer": {"device": "none", "nvme_path": None},
+ "offload_param": {"device": "none", "nvme_path": None},
+ "stage3_gather_16bit_weights_on_model_save": False,
+ },
+ "gradient_clipping": 1.0,
+ "steps_per_print": np.inf,
+ "bf16": {"enabled": True},
+ "fp16": {"enabled": False},
+ "zero_allow_untested_optimizer": True,
+ }
+
+ (
+ model,
+ optimizer,
+ _,
+ _,
+ ) = deepspeed.initialize(
+ model=model,
+ optimizer=optimizer,
+ config_params=config,
+ )
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ model_outputs = []
+ data = []
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ outputs = model(**batch)
+ data.append(batch.to("cpu"))
+ model_outputs.append(outputs.logits.to("cpu"))
+ loss = outputs.loss
+ model.backward(loss)
+ model.step()
+ for _ in range(accelerator.num_processes):
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results, model_outputs, data
+
+
+def train_integration(zero_stage: int = 1):
+ set_seed(42)
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ deepspeed_plugin = DeepSpeedPlugin(
+ zero_stage=zero_stage,
+ zero3_init_flag=zero_stage == 3,
+ )
+ accelerator = Accelerator(
+ mixed_precision="fp8", kwargs_handlers=kwargs_handlers, deepspeed_plugin=deepspeed_plugin
+ )
+ accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = 16
+
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+ model_outputs = []
+ data = []
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ data.append(batch.to("cpu"))
+ model_outputs.append(outputs.logits.to("cpu"))
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ lr_scheduler.step()
+ optimizer.zero_grad()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.destroy()
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results, model_outputs, data
+
+
+if __name__ == "__main__":
+ # for zero_stage in [1, 2, 3]:
+ zero_stage = 1
+ baseline_not_trained, baseline_trained, baseline_outputs, baseline_data = train_baseline(zero_stage)
+ accelerator_not_trained, accelerator_trained, accelerator_outputs, accelerator_data = train_integration(zero_stage)
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}: Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'ZERO stage {zero_stage}: F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'ZERO stage {zero_stage}: Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'ZERO stage {zero_stage}: F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fp8_utils.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fp8_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..d28702e05ff0bbd77d0a51428082336fb5314181
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fp8_utils.py
@@ -0,0 +1,116 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+
+
+def get_dataloaders(model_name: str, batch_size: int = 16):
+ from datasets import load_dataset
+ from torch.utils.data import DataLoader
+ from transformers import AutoTokenizer
+
+ tokenizer = AutoTokenizer.from_pretrained(model_name)
+ datasets = load_dataset("glue", "mrpc")
+
+ def tokenize_function(examples):
+ # max_length=None => use the model max length (it's actually the default)
+ outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+ return outputs
+
+ # Apply the method we just defined to all the examples in all the splits of the dataset
+ # starting with the main process first:
+ tokenized_datasets = datasets.map(
+ tokenize_function,
+ batched=True,
+ remove_columns=["idx", "sentence1", "sentence2"],
+ )
+
+ # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+ # transformers library
+ tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+ def collate_fn(examples):
+ return tokenizer.pad(
+ examples,
+ padding="longest",
+ pad_to_multiple_of=16, # Specific for FP8
+ return_tensors="pt",
+ )
+
+ # Instantiate dataloaders.
+ train_dataloader = DataLoader(
+ tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size, drop_last=True
+ )
+ eval_dataloader = DataLoader(
+ tokenized_datasets["validation"],
+ shuffle=False,
+ collate_fn=collate_fn,
+ batch_size=16,
+ drop_last=True,
+ )
+
+ return train_dataloader, eval_dataloader
+
+
+def get_training_utilities(model_name: str, batch_size: int = 16, accelerator=None):
+ """
+ Returns a tuple of:
+ - Model
+ - Optimizer
+ - Train dataloader (prepared)
+ - Eval dataloader (prepared)
+ - LR Scheduler
+ Suitable for training on the MRPC dataset
+ """
+ from torch.optim import AdamW
+ from transformers import AutoModelForSequenceClassification, get_linear_schedule_with_warmup
+
+ from accelerate import Accelerator
+
+ if accelerator is None:
+ accelerator = Accelerator()
+ model = AutoModelForSequenceClassification.from_pretrained(model_name)
+ train_dataloader, eval_dataloader = get_dataloaders(model_name, batch_size)
+ optimizer = AdamW(model.parameters(), lr=0.0001)
+ lr_scheduler = get_linear_schedule_with_warmup(
+ optimizer=optimizer,
+ num_warmup_steps=100,
+ num_training_steps=len(train_dataloader) * 2,
+ )
+ train_dataloader, eval_dataloader = accelerator.prepare(train_dataloader, eval_dataloader)
+ return model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+
+
+def get_named_parameters(model):
+ """
+ Same thing as `Accelerator.get_named_parameters` Returns a list of the named parameters of the model (extracted
+ from parallel)
+ """
+ from accelerate.utils import extract_model_from_parallel
+
+ model = extract_model_from_parallel(model)
+ return {n: p for n, p in model.named_parameters()}
+
+
+def evaluate_model(model, dataloader, metric, accelerator=None):
+ "Turns model to .eval(), runs dataloader, calculates metric, then turns eval back on"
+ model.eval()
+ for step, batch in enumerate(dataloader):
+ with torch.no_grad():
+ outputs = model(**batch)
+ predictions = outputs.logits.argmax(dim=-1)
+ references = batch["labels"]
+ if accelerator is not None and accelerator.num_processes > 1:
+ predictions, references = accelerator.gather_for_metrics((predictions, references))
+ metric.add_batch(predictions=predictions, references=references)
+ return metric.compute()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fsdp.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fsdp.py
new file mode 100644
index 0000000000000000000000000000000000000000..418122185e1f9bd4a8f0f783aaa199b0991d714d
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/fsdp.py
@@ -0,0 +1,161 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for FSDP training.
+"""
+
+from functools import partial
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.distributed.fsdp import MixedPrecision
+from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+from transformer_engine.common.recipe import DelayedScaling
+from transformers.models.bert import BertLayer
+
+from accelerate import Accelerator
+from accelerate import FullyShardedDataParallelPlugin as FSDPPlugin
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+FSDP_WRAP_POLICY = partial(transformer_auto_wrap_policy, transformer_layer_cls={BertLayer})
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+ accelerator = Accelerator()
+ device = accelerator.device
+ model.to(device)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ new_named_params = get_named_parameters(model)
+
+ # Convert the model to FSDP
+ model = FSDP(
+ model,
+ use_orig_params=True,
+ mixed_precision=MixedPrecision(param_dtype=torch.bfloat16, reduce_dtype=torch.float32),
+ auto_wrap_policy=FSDP_WRAP_POLICY,
+ )
+
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to(device)
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ fsdp_plugin = FSDPPlugin(
+ auto_wrap_policy=FSDP_WRAP_POLICY,
+ use_orig_params=True,
+ mixed_precision_policy=MixedPrecision(param_dtype=torch.bfloat16, reduce_dtype=torch.float32),
+ )
+ accelerator = Accelerator(mixed_precision="fp8", fsdp_plugin=fsdp_plugin, kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer = accelerator.prepare(model, optimizer)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+ model.train()
+
+ for _ in range(2):
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC, accelerator=accelerator)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
+
+ torch.distributed.destroy_process_group()
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/non_distributed.py b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/non_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..71d577c48d6715c09ef5ea2aff25bda5472634a1
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/benchmarks/fp8/transformer_engine/non_distributed.py
@@ -0,0 +1,132 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This script tests to ensure that `accelerate` performs at the same level as raw `TransformersEngine`.
+
+This particular script verifies this for single GPU training.
+"""
+
+import evaluate
+import torch
+import transformer_engine.common.recipe as te_recipe
+import transformer_engine.pytorch as te
+from fp8_utils import evaluate_model, get_named_parameters, get_training_utilities
+from transformer_engine.common.recipe import DelayedScaling
+
+from accelerate import Accelerator
+from accelerate.state import AcceleratorState
+from accelerate.utils import FP8RecipeKwargs, set_seed
+from accelerate.utils.transformer_engine import convert_model
+
+
+MODEL_NAME = "bert-base-cased"
+METRIC = evaluate.load("glue", "mrpc")
+
+
+def train_baseline():
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(MODEL_NAME)
+
+ # Convert the model to TE
+ old_named_params = get_named_parameters(model)
+
+ with torch.no_grad():
+ convert_model(model)
+
+ new_named_params = get_named_parameters(model)
+ mapping = {p: new_named_params[n] for n, p in old_named_params.items()}
+ for param_group in optimizer.param_groups:
+ param_group["params"] = [mapping[p] for p in param_group["params"]]
+
+ FP8_RECIPE_KWARGS = {"fp8_format": te_recipe.Format.HYBRID, "amax_history_len": 32, "amax_compute_algo": "max"}
+ fp8_recipe = DelayedScaling(**FP8_RECIPE_KWARGS)
+
+ model.to("cuda")
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
+ with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+ batch = batch.to("cuda")
+ outputs = model(**batch)
+ loss = outputs.loss
+ loss.backward()
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+def train_integration():
+ FP8_RECIPE_KWARGS = {"fp8_format": "HYBRID", "amax_history_len": 32, "amax_compute_algo": "max"}
+ kwargs_handlers = [FP8RecipeKwargs(backend="TE", **FP8_RECIPE_KWARGS)]
+ AcceleratorState()._reset_state(True)
+ accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=kwargs_handlers)
+ set_seed(42)
+ model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = get_training_utilities(
+ MODEL_NAME, accelerator=accelerator
+ )
+
+ model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
+ base_model_results = evaluate_model(model, eval_dataloader, METRIC)
+ model.train()
+
+ for batch in train_dataloader:
+ outputs = model(**batch)
+ loss = outputs.loss
+ accelerator.backward(loss)
+ optimizer.step()
+ optimizer.zero_grad()
+ lr_scheduler.step()
+
+ trained_model_results = evaluate_model(model, eval_dataloader, METRIC)
+
+ assert (
+ trained_model_results["accuracy"] > base_model_results["accuracy"]
+ ), f'Accuracy should be higher for the trained model: {trained_model_results["accuracy"]} > {base_model_results["accuracy"]}'
+ assert (
+ trained_model_results["f1"] > base_model_results["f1"]
+ ), f'F1 score should be higher for the trained model: {trained_model_results["f1"]} > {base_model_results["f1"]}'
+
+ return base_model_results, trained_model_results
+
+
+if __name__ == "__main__":
+ baseline_not_trained, baseline_trained = train_baseline()
+ accelerator_not_trained, accelerator_trained = train_integration()
+
+ assert (
+ baseline_not_trained["accuracy"] == accelerator_not_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_not_trained["accuracy"]} == {accelerator_not_trained["accuracy"]}'
+ assert (
+ baseline_not_trained["f1"] == accelerator_not_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_not_trained["f1"]} == {accelerator_not_trained["f1"]}'
+ assert (
+ baseline_trained["accuracy"] == accelerator_trained["accuracy"]
+ ), f'Accuracy should be the same for the baseline and accelerator: {baseline_trained["accuracy"]} == {accelerator_trained["accuracy"]}'
+ assert (
+ baseline_trained["f1"] == accelerator_trained["f1"]
+ ), f'F1 score should be the same for the baseline and accelerator: {baseline_trained["f1"]} == {accelerator_trained["f1"]}'
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docker/README.md b/tasks/tasksmith-5db757e91a6e/tests/source/docker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e19e6caa4ae26b61dec7602f02199d3a4daf036
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docker/README.md
@@ -0,0 +1,74 @@
+
+
+# Official Hugging Face Accelerate Docker Images
+
+Accelerate publishes a variety of docker versions as part of our CI that users can also use. These are stable images that Accelerate can run off of which comes with a variety of different setup configurations, all of which are officially hosted on [Docker Hub](https://hub.docker.com/r/huggingface/accelerate).
+
+A breakdown of each are given below
+
+## Naming Conventions
+
+Accelerate docker images follow a tagging convention of:
+
+```bash
+huggingface/accelerate:{accelerator}-{nightly,release}
+```
+
+`accelerator` in this instance is one of many applical pre-configured backend supports:
+* `gpu`: Comes compiled off of the `nvidia/cuda` image and includes core parts like `bitsandbytes`. Runs off python 3.9.
+* `cpu`: Comes compiled off of `python:3.9-slim` and is designed for non-CUDA based workloads.
+* More to come soon
+* `gpu-deepspeed`: Comes compiled off of the `nvidia/cuda` image and includes core parts like `bitsandbytes` as well as the latest `deepspeed` version. Runs off python 3.10.
+* `gpu-fp8-transformerengine`: Comes compiled off of `nvcr.io/nvidia/pytorch` and is specifically for running the `benchmarks/fp8` scripts on devices which support FP8 operations using the `TransformerEngine` library (RTX 4090, H100, etc)
+
+## Nightlies vs Releases
+
+Each release a new build is pushed with a version number included in the name. For a GPU-supported image of version 0.28.0 for instance, it would look like the following:
+
+```bash
+huggingface/accelerate:gpu-release-0.28.0
+```
+
+Nightlies contain two different image tags. There is a general `nightly` tag which is built each night, and a `nightly-YYYY-MM-DD` which corresponds to a build from a particular date.
+
+For instance, here is an example nightly CPU image from 3/14/2024
+
+```bash
+huggingface/accelerate:cpu-nightly-2024-03-14
+```
+
+## Running the images
+
+Each image comes compiled with `conda` and an `accelerate` environment contains all of the installed dependencies.
+
+To pull down the latest nightly run:
+
+```bash
+docker pull huggingface/accelerate:gpu-nightly
+```
+
+To then run it in interactive mode with GPU-memory available, run:
+
+```bash
+docker container run --gpus all -it huggingface/accelerate:gpu-nightly
+```
+
+## DEPRECATED IMAGES
+
+CPU and GPU docker images were hosted at `huggingface/accelerate-gpu` and `huggingface/accelerate-cpu`. These builds are now outdated and will not receive updates.
+
+The builds at the corresponding `huggingface/accelerate:{gpu,cpu}` contain the same `Dockerfile`, so it's as simple as changing the docker image to the desired ones from above. We will not be deleting these images for posterity, but they will not be receiving updates going forward.
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-cpu/Dockerfile b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-cpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..ac4176342151a2800971dec660a1465137d72769
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-cpu/Dockerfile
@@ -0,0 +1,35 @@
+# Builds CPU-only Docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+FROM python:3.8-slim as compile-image
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt update
+RUN apt-get install -y --no-install-recommends \
+ build-essential \
+ git \
+ gcc
+
+# Setup virtual environment for Docker
+ENV VIRTUAL_ENV=/opt/venv
+RUN python3 -m venv ${VIRTUAL_ENV}
+# Make sure we use the virtualenv
+ENV PATH="${VIRTUAL_ENV}/bin:$PATH"
+WORKDIR /workspace
+# Install specific CPU torch wheel to save on space
+RUN python3 -m pip install --upgrade --no-cache-dir pip
+RUN python3 -m pip install --no-cache-dir \
+ jupyter \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers] \
+ --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Stage 2
+FROM python:3.8-slim AS build-image
+COPY --from=compile-image /opt/venv /opt/venv
+RUN useradd -ms /bin/bash user
+USER user
+
+# Make sure we use the virtualenv
+ENV PATH="/opt/venv/bin:$PATH"
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu-deepspeed/Dockerfile b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu-deepspeed/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..d35fc1b5c5beedabc7b205f00655554bc366292d
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu-deepspeed/Dockerfile
@@ -0,0 +1,46 @@
+# Builds GPU docker image of PyTorch specifically
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+# Note: DeepSpeed beyond v0.12.6 requires py 3.10
+ENV PYTHON_VERSION=3.10
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+# Create our conda env
+RUN conda create --name accelerate python=${PYTHON_VERSION} ipython jupyter pip
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH /opt/conda/envs/accelerate/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env, install mpy4pi, and install torch + accelerate
+RUN source activate accelerate && conda install -c conda-forge mpi4py
+RUN source activate accelerate && \
+ python3 -m pip install --no-cache-dir \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers,deepspeed] \
+ --extra-index-url https://download.pytorch.org/whl/cu117
+
+RUN python3 -m pip install --no-cache-dir bitsandbytes
+
+# Stage 2
+FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu20.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH /opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate accelerate" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu/Dockerfile b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..e5aae6b528b5419f101e3d1bfa75ea58dbe1bca8
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docker/accelerate-gpu/Dockerfile
@@ -0,0 +1,45 @@
+# Builds GPU docker image of PyTorch specifically
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.9
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+# Create our conda env
+RUN conda create --name accelerate python=${PYTHON_VERSION} ipython jupyter pip
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH /opt/conda/envs/accelerate/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env, install mpy4pi, and install torch + accelerate
+RUN source activate accelerate && conda install -c conda-forge mpi4py
+RUN source activate accelerate && \
+ python3 -m pip install --no-cache-dir \
+ git+https://github.com/huggingface/accelerate#egg=accelerate[testing,test_trackers] \
+ --extra-index-url https://download.pytorch.org/whl/cu117
+
+RUN python3 -m pip install --no-cache-dir bitsandbytes
+
+# Stage 2
+FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu20.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH /opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+ apt-get install -y curl git wget && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate accelerate" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/Makefile b/tasks/tasksmith-5db757e91a6e/tests/source/docs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..8879933e6cda150267451c9e7d07dd22b7b0d3f1
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/Makefile
@@ -0,0 +1,19 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS =
+SPHINXBUILD = sphinx-build
+SOURCEDIR = source
+BUILDDIR = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+ @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+ @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/README.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c089297dfc6f0ae4cf6022d17b4694b81db288a
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/README.md
@@ -0,0 +1,267 @@
+
+
+# Generating the documentation
+
+To generate the documentation, you first have to build it. Several packages are necessary to build the doc,
+you can install them with the following command, at the root of the code repository:
+
+```bash
+pip install -e ".[docs]"
+```
+
+Then you need to install our special tool that builds the documentation:
+
+```bash
+pip install git+https://github.com/huggingface/doc-builder
+```
+
+---
+**NOTE**
+
+You only need to generate the documentation to inspect it locally (if you're planning changes and want to
+check how they look before committing for instance). You don't have to commit the built documentation.
+
+---
+
+## Building the documentation
+
+Once you have setup the `doc-builder` and additional packages, you can generate the documentation by
+typing the following command:
+
+```bash
+doc-builder build accelerate docs/source/ --build_dir ~/tmp/test-build
+```
+
+You can adapt the `--build_dir` to set any temporary folder that you prefer. This command will create it and generate
+the MDX files that will be rendered as the documentation on the main website. You can inspect them in your favorite
+Markdown editor.
+
+## Previewing the documentation
+
+To preview the docs, first install the `watchdog` module with:
+
+```bash
+pip install watchdog
+```
+
+Then run the following command:
+
+```bash
+doc-builder preview {package_name} {path_to_docs}
+```
+
+For example:
+
+```bash
+doc-builder preview accelerate docs/source/
+```
+
+The docs will be viewable at [http://localhost:3000](http://localhost:3000). You can also preview the docs once you have opened a PR. You will see a bot add a comment to a link where the documentation with your changes lives.
+
+---
+**NOTE**
+
+The `preview` command only works with existing doc files. When you add a completely new file, you need to update `_toctree.yml` & restart `preview` command (`ctrl-c` to stop it & call `doc-builder preview ...` again).
+
+---
+
+## Adding a new element to the navigation bar
+
+Accepted files are Markdown (.md).
+
+Create a file with its extension and put it in the source directory. You can then link it to the toc-tree by putting
+the filename without the extension in the [`_toctree.yml`](https://github.com/huggingface/accelerate/blob/main/docs/source/_toctree.yml) file.
+
+## Renaming section headers and moving sections
+
+It helps to keep the old links working when renaming the section header and/or moving sections from one document to another. This is because the old links are likely to be used in Issues, Forums, and Social media and it'd make for a much more superior user experience if users reading those months later could still easily navigate to the originally intended information.
+
+Therefore, we simply keep a little map of moved sections at the end of the document where the original section was. The key is to preserve the original anchor.
+
+So if you renamed a section from: "Section A" to "Section B", then you can add at the end of the file:
+
+```
+Sections that were moved:
+
+[ Section A ]
+```
+and of course, if you moved it to another file, then:
+
+```
+Sections that were moved:
+
+[ Section A ]
+```
+
+Use the relative style to link to the new file so that the versioned docs continue to work.
+
+
+## Writing Documentation - Specification
+
+The `huggingface/accelerate` documentation follows the
+[Google documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html) style for docstrings,
+although we can write them directly in Markdown.
+
+### Adding a new tutorial
+
+Adding a new tutorial or section is done in two steps:
+
+- Add a new file under `./source`. This file can either be ReStructuredText (.rst) or Markdown (.md).
+- Link that file in `./source/_toctree.yml` on the correct toc-tree.
+
+Make sure to put your new file under the proper section. It's unlikely to go in the first section (*Get Started*), so
+depending on the intended targets (beginners, more advanced users, or researchers) it should go in sections two, three, or
+four.
+
+### Writing source documentation
+
+Values that should be put in `code` should either be surrounded by backticks: \`like so\`. Note that argument names
+and objects like True, None, or any strings should usually be put in `code`.
+
+When mentioning a class, function, or method, it is recommended to use our syntax for internal links so that our tool
+adds a link to its documentation with this syntax: \[\`XXXClass\`\] or \[\`function\`\]. This requires the class or
+function to be in the main package.
+
+If you want to create a link to some internal class or function, you need to
+provide its path. For instance: \[\`utils.gather\`\]. This will be converted into a link with
+`utils.gather` in the description. To get rid of the path and only keep the name of the object you are
+linking to in the description, add a ~: \[\`~utils.gather\`\] will generate a link with `gather` in the description.
+
+The same works for methods so you can either use \[\`XXXClass.method\`\] or \[~\`XXXClass.method\`\].
+
+#### Defining arguments in a method
+
+Arguments should be defined with the `Args:` (or `Arguments:` or `Parameters:`) prefix, followed by a line return and
+an indentation. The argument should be followed by its type, with its shape if it is a tensor, a colon, and its
+description:
+
+```
+ Args:
+ n_layers (`int`): The number of layers of the model.
+```
+
+If the description is too long to fit in one line (more than 119 characters in total), another indentation is necessary
+before writing the description after the argument.
+
+Finally, to maintain uniformity if any *one* description is too long to fit on one line, the
+rest of the parameters should follow suit and have an indention before their description.
+
+Here's an example showcasing everything so far:
+
+```
+ Args:
+ gradient_accumulation_steps (`int`, *optional*, default to 1):
+ The number of steps that should pass before gradients are accumulated. A number > 1 should be combined with `Accelerator.accumulate`.
+ cpu (`bool`, *optional*):
+ Whether or not to force the script to execute on CPU. Will ignore GPU available if set to `True` and force the execution on one process only.
+```
+
+For optional arguments or arguments with defaults we follow the following syntax: imagine we have a function with the
+following signature:
+
+```
+def my_function(x: str = None, a: float = 1):
+```
+
+then its documentation should look like this:
+
+```
+ Args:
+ x (`str`, *optional*):
+ This argument controls ... and has a description longer than 119 chars.
+ a (`float`, *optional*, defaults to 1):
+ This argument is used to ... and has a description longer than 119 chars.
+```
+
+Note that we always omit the "defaults to \`None\`" when None is the default for any argument. Also note that even
+if the first line describing your argument type and its default gets long, you can't break it on several lines. You can
+however write as many lines as you want in the indented description (see the example above with `input_ids`).
+
+#### Writing a multi-line code block
+
+Multi-line code blocks can be useful for displaying examples. They are done between two lines of three backticks as usual in Markdown:
+
+
+````
+```python
+# first line of code
+# second line
+# etc
+```
+````
+
+#### Writing a return block
+
+The return block should be introduced with the `Returns:` prefix, followed by a line return and an indentation.
+The first line should be the type of the return, followed by a line return. No need to indent further for the elements
+building the return.
+
+Here's an example of a single value return:
+
+```
+ Returns:
+ `List[int]`: A list of integers in the range [0, 1] --- 1 for a special token, 0 for a sequence token.
+```
+
+Here's an example of a tuple return, comprising several objects:
+
+```
+ Returns:
+ `tuple(torch.FloatTensor)` comprising various elements depending on the configuration ([`BertConfig`]) and inputs:
+ - ** loss** (*optional*, returned when `masked_lm_labels` is provided) `torch.FloatTensor` of shape `(1,)` --
+ Total loss is the sum of the masked language modeling loss and the next sequence prediction (classification) loss.
+ - **prediction_scores** (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`) --
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+```
+
+## Styling the docstring
+
+We have an automatic script running with the `make style` comment that will make sure that:
+- the docstrings fully take advantage of the line width
+- all code examples are formatted using black, like the code of the Transformers library
+
+This script may have some weird failures if you made a syntax mistake or if you uncover a bug. Therefore, it's
+recommended to commit your changes before running `make style`, so you can revert the changes done by that script
+easily.
+
+## Writing documentation examples
+
+The syntax for Example docstrings can look as follows:
+
+```
+ Example:
+
+ ```python
+ >>> import time
+ >>> from accelerate import Accelerator
+ >>> accelerator = Accelerator()
+ >>> if accelerator.is_main_process:
+ ... time.sleep(2)
+ >>> else:
+ ... print("I'm waiting for the main process to finish its sleep...")
+ >>> accelerator.wait_for_everyone()
+ >>> # Should print on every process at the same time
+ >>> print("Everyone is here")
+ ```
+```
+
+The docstring should give a minimal, clear example of how the respective function
+is to be used in inference and also include the expected (ideally sensible)
+output.
+Often, readers will try out the example before even going through the function
+or class definitions. Therefore, it is of utmost importance that the example
+works as expected.
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/_toctree.yml b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/_toctree.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c90c2ed30d1f2ef606af6eaf394b42544a1795cd
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/_toctree.yml
@@ -0,0 +1,125 @@
+- sections:
+ - local: index
+ title: 🤗 Accelerate
+ - local: basic_tutorials/install
+ title: Installation
+ - local: quicktour
+ title: Quicktour
+ title: Getting started
+- sections:
+ - local: basic_tutorials/overview
+ title: Overview
+ - local: basic_tutorials/migration
+ title: Add Accelerate to your code
+ - local: basic_tutorials/execution
+ title: Execution process
+ - local: basic_tutorials/tpu
+ title: TPU training
+ - local: basic_tutorials/launch
+ title: Launching Accelerate scripts
+ - local: basic_tutorials/notebook
+ title: Launching distributed training from Jupyter Notebooks
+ title: Tutorials
+- sections:
+ - isExpanded: true
+ sections:
+ - local: usage_guides/explore
+ title: Start Here!
+ - local: usage_guides/model_size_estimator
+ title: Model memory estimator
+ - local: usage_guides/quantization
+ title: Model quantization
+ - local: usage_guides/tracking
+ title: Experiment trackers
+ - local: usage_guides/profiler
+ title: Profiler
+ - local: usage_guides/checkpoint
+ title: Checkpointing
+ - local: basic_tutorials/troubleshooting
+ title: Troubleshoot
+ - local: usage_guides/training_zoo
+ title: Example Zoo
+ title: Accelerate
+ - isExpanded: true
+ sections:
+ - local: usage_guides/gradient_accumulation
+ title: Gradient accumulation
+ - local: usage_guides/local_sgd
+ title: Local SGD
+ - local: usage_guides/low_precision_training
+ title: Low precision (FP8) training
+ - local: usage_guides/deepspeed
+ title: DeepSpeed
+ - local: usage_guides/deepspeed_multiple_model
+ title: Using multiple models with DeepSpeed
+ - local: usage_guides/ddp_comm_hook
+ title: DDP Communication Hooks
+ - local: usage_guides/fsdp
+ title: Fully Sharded Data Parallel
+ - local: usage_guides/megatron_lm
+ title: Megatron-LM
+ - local: usage_guides/sagemaker
+ title: Amazon SageMaker
+ - local: usage_guides/mps
+ title: Apple M1 GPUs
+ - local: usage_guides/ipex
+ title: IPEX training with CPU
+ title: Training
+ - isExpanded: true
+ sections:
+ - local: usage_guides/big_modeling
+ title: Big Model Inference
+ - local: usage_guides/distributed_inference
+ title: Distributed inference
+ title: Inference
+ title: How to guides
+- sections:
+ - local: concept_guides/internal_mechanism
+ title: Accelerate's internal mechanism
+ - local: concept_guides/big_model_inference
+ title: Loading big models into memory
+ - local: concept_guides/performance
+ title: Comparing performance across distributed setups
+ - local: concept_guides/deferring_execution
+ title: Executing and deferring jobs
+ - local: concept_guides/gradient_synchronization
+ title: Gradient synchronization
+ - local: concept_guides/fsdp_and_deepspeed
+ title: FSDP vs DeepSpeed
+ - local: concept_guides/low_precision_training
+ title: Low precision training methods
+ - local: concept_guides/training_tpu
+ title: Training on TPUs
+ title: Concepts and fundamentals
+- sections:
+ - local: package_reference/accelerator
+ title: Accelerator
+ - local: package_reference/state
+ title: Stateful classes
+ - local: package_reference/cli
+ title: The Command Line
+ - local: package_reference/torch_wrappers
+ title: DataLoaders, Optimizers, Schedulers
+ - local: package_reference/tracking
+ title: Experiment trackers
+ - local: package_reference/launchers
+ title: Launchers
+ - local: package_reference/deepspeed
+ title: DeepSpeed utilities
+ - local: package_reference/logging
+ title: Logging
+ - local: package_reference/big_modeling
+ title: Working with large models
+ - local: package_reference/inference
+ title: Pipeline parallelism
+ - local: package_reference/kwargs
+ title: Kwargs handlers
+ - local: package_reference/fp8
+ title: FP8
+ - local: package_reference/utilities
+ title: Utility functions and classes
+ - local: package_reference/megatron_lm
+ title: Megatron-LM utilities
+ - local: package_reference/fsdp
+ title: Fully Sharded Data Parallel utilities
+ title: "Reference"
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/basic_tutorials/execution.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/basic_tutorials/execution.md
new file mode 100644
index 0000000000000000000000000000000000000000..4874f4439938ef18997f2cfb78f55c83fae70965
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/basic_tutorials/execution.md
@@ -0,0 +1,128 @@
+
+
+# Execution process
+
+When working with distributed training systems, it is important to manage how and when processes are executed across GPUs. Some processes are completed faster than others, and some processes shouldn't begin if others haven't finished yet. Accelerate provides tools for orchestrating when processes are executed to ensure everything remains synchronized across all devices.
+
+This tutorial will teach you how to execute a process on only one machine and how to delay execution until all processes have reached a certain point.
+
+## Execute on one process
+
+Certain code only needs to be run once on a given machine, such as printing a log statement or only displaying one progress bar on the local main process.
+
+DeepSpeed | `--fsdp_sharding_strategy`
`--zero_stage` | `1` (`FULL_SHARD`)
`3` | +offload | FSDP
DeepSpeed | `--fsdp_offload_params`
`--offload_param_device`
`--offload_optimizer_device` | `true`
`cpu`
`cpu` | all or nothing
+model loading | FSDP
DeepSpeed | `--fsdp_cpu_ram_efficient_loading`
`--zero3_init_flag` | `true`
`true` |
only ZeRO 3 +efficient checkpointing | FSDP
DeepSpeed | `--fsdp_state_dict_type`
`--zero3_save_16bit_model` | `SHARDED_STATE_DICT`
`true` |
only ZeRO 3 +weights prefetching | FSDP
DeepSpeed | `--fsdp_forward_prefetch`
`--fsdp_backward_prefetch`
None | `true`
`BACKWARD_PRE` |
+model | FSDP
DeepSpeed | `--fsdp_auto_wrap_policy`
`--fsdp_transformer_layer_cls_to_wrap`
None | `TRANSFORMER_BASED_WRAP`
Usually not needed
Transparent to user. +parameters summoning | FSDP
DeepSpeed | `--fsdp_use_orig_params`
None | `true` | required for `torch.compile`
Transparent to user +parameters syncing | FSDP
DeepSpeed | `--fsdp_sync_module_states`
None | `true` | +training | FSDP
DeepSpeed | None
`--gradient_accumulation_steps`
`--gradient_clipping` |
`auto`
`auto` | Transparent to user + +For detailed descriptions of the above, refer to [`Accelerate` launch documentation](../package_reference/cli#accelerate-launch). + +
DeepSpeed | created in `torch_dtype`.
disregards `torch_dtype`, created in `float32`. +Optimizer initialization | ✅ | FSDP
DeepSpeed | creates parameters in `torch_dtype`
creates parameters in `float32` +Training Step, i.e, forward, backward, reduction | | FSDP
DeepSpeed | follows [`MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision)
follows `deepspeed_config_file` mixed precision settings. +Optimizer (Pre-Step) | ✅ | FSDP
DeepSpeed | upcasting (if any) to `torch_dtype`
upcasted to `float32` +Optimizer (Actual Step) | ✅ | FSDP
DeepSpeed | occurs in `torch_dtype`
occurs in `float32`. + +
+
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/accelerator.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/accelerator.md
new file mode 100644
index 0000000000000000000000000000000000000000..7d915a4ee60e5518f1f652f549476ed286e98e10
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/accelerator.md
@@ -0,0 +1,26 @@
+
+
+# Accelerator
+
+The [`Accelerator`] is the main class for enabling distributed training on any type of training setup. Read the [Add Accelerator to your code](../basic_tutorials/migration) tutorial to learn more about how to add the [`Accelerator`] to your script.
+
+## Accelerator[[api]]
+
+[[autodoc]] Accelerator
+
+## Utilities
+
+[[autodoc]] accelerate.utils.gather_object
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/big_modeling.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/big_modeling.md
new file mode 100644
index 0000000000000000000000000000000000000000..77dab4525ede9b7c7a95908c2ecc3c666c2d7e89
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/big_modeling.md
@@ -0,0 +1,92 @@
+
+
+# Working with large models
+
+## Dispatch and offload
+
+### init_empty_weights
+
+[[autodoc]] big_modeling.init_empty_weights
+
+### cpu_offload
+
+[[autodoc]] big_modeling.cpu_offload
+
+### cpu_offload_with_hook
+
+[[autodoc]] big_modeling.cpu_offload_with_hook
+
+### disk_offload
+
+[[autodoc]] big_modeling.disk_offload
+
+### dispatch_model
+
+[[autodoc]] big_modeling.dispatch_model
+
+### load_checkpoint_and_dispatch
+
+[[autodoc]] big_modeling.load_checkpoint_and_dispatch
+
+### load_checkpoint_in_model
+
+[[autodoc]] big_modeling.load_checkpoint_in_model
+
+### infer_auto_device_map
+
+[[autodoc]] utils.infer_auto_device_map
+
+## Hooks
+
+### ModelHook
+
+[[autodoc]] hooks.ModelHook
+
+### AlignDevicesHook
+
+[[autodoc]] hooks.AlignDevicesHook
+
+### SequentialHook
+
+[[autodoc]] hooks.SequentialHook
+
+## Adding Hooks
+
+### add_hook_to_module
+
+[[autodoc]] hooks.add_hook_to_module
+
+### attach_execution_device_hook
+
+[[autodoc]] hooks.attach_execution_device_hook
+
+### attach_align_device_hook
+
+[[autodoc]] hooks.attach_align_device_hook
+
+### attach_align_device_hook_on_blocks
+
+[[autodoc]] hooks.attach_align_device_hook_on_blocks
+
+## Removing Hooks
+
+### remove_hook_from_module
+
+[[autodoc]] hooks.remove_hook_from_module
+
+### remove_hook_from_submodules
+
+[[autodoc]] hooks.remove_hook_from_submodules
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/cli.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/cli.md
new file mode 100644
index 0000000000000000000000000000000000000000..1f3ec85827b90bff1fe886265727c5d7e85b37ef
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/package_reference/cli.md
@@ -0,0 +1,335 @@
+
+
+# The Command Line
+
+Below is a list of all the available commands 🤗 Accelerate with their parameters
+
+## accelerate config
+
+**Command**:
+
+`accelerate config` or `accelerate-config`
+
+Launches a series of prompts to create and save a `default_config.yml` configuration file for your training system. Should
+always be ran first on your machine.
+
+**Usage**:
+
+```bash
+accelerate config [arguments]
+```
+
+**Optional Arguments**:
+* `--config_file CONFIG_FILE` (`str`) -- The path to use to store the config file. Will default to a file named default_config.yaml in the cache location, which is the content
+ of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory
+ (`~/.cache` or the content of `XDG_CACHE_HOME`) suffixed with `huggingface`.
+* `-h`, `--help` (`bool`) -- Show a help message and exit
+
+## accelerate config default
+
+**Command**:
+
+`accelerate config default` or `accelerate-config default`
+
+Create a default config file for Accelerate with only a few flags set.
+
+**Usage**:
+
+```bash
+accelerate config default [arguments]
+```
+
+**Optional Arguments**:
+* `--config_file CONFIG_FILE` (`str`) -- The path to use to store the config file. Will default to a file named default_config.yaml in the cache location, which is the content
+ of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory
+ (`~/.cache` or the content of `XDG_CACHE_HOME`) suffixed with `huggingface`.
+
+* `-h`, `--help` (`bool`) -- Show a help message and exit
+* `--mixed_precision {no,fp16,bf16}` (`str`) -- Whether or not to use mixed precision training. Choose between FP16 and BF16 (bfloat16) training. BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.
+
+## accelerate config update
+
+**Command**:
+
+`accelerate config update` or `accelerate-config update`
+
+Update an existing config file with the latest defaults while maintaining the old configuration.
+
+**Usage**:
+
+```bash
+accelerate config update [arguments]
+```
+
+**Optional Arguments**:
+* `--config_file CONFIG_FILE` (`str`) -- The path to the config file to update. Will default to a file named default_config.yaml in the cache location, which is the content
+ of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory
+ (`~/.cache` or the content of `XDG_CACHE_HOME`) suffixed with `huggingface`.
+
+* `-h`, `--help` (`bool`) -- Show a help message and exit
+
+
+## accelerate env
+
+**Command**:
+
+`accelerate env` or `accelerate-env` or `python -m accelerate.commands.env`
+
+Lists the contents of the passed 🤗 Accelerate configuration file. Should always be used when opening an issue on the [GitHub repository](https://github.com/huggingface/accelerate).
+
+**Usage**:
+
+```bash
+accelerate env [arguments]
+```
+
+**Optional Arguments**:
+* `--config_file CONFIG_FILE` (`str`) -- The path to use to store the config file. Will default to a file named default_config.yaml in the cache location, which is the content
+ of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have such an environment variable, your cache directory
+ (`~/.cache` or the content of `XDG_CACHE_HOME`) suffixed with `huggingface`.
+* `-h`, `--help` (`bool`) -- Show a help message and exit
+
+## accelerate launch
+
+**Command**:
+
+`accelerate launch` or `accelerate-launch` or `python -m accelerate.commands.launch`
+
+Launches a specified script on a distributed system with the right parameters.
+
+**Usage**:
+
+```bash
+accelerate launch [arguments] {training_script} --{training_script-argument-1} --{training_script-argument-2} ...
+```
+
+**Positional Arguments**:
+
+- `{training_script}` -- The full path to the script to be launched in parallel
+- `--{training_script-argument-1}` -- Arguments of the training script
+
+**Optional Arguments**:
+
+* `-h`, `--help` (`bool`) -- Show a help message and exit
+* `--config_file CONFIG_FILE` (`str`)-- The config file to use for the default values in the launching script.
+* `-m`, `--module` (`bool`) -- Change each process to interpret the launch script as a Python module, executing with the same behavior as 'python -m'.
+* `--no_python` (`bool`) -- Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.
+* `--debug` (`bool`) -- Whether to print out the torch.distributed stack trace when something fails.
+* `-q`, `--quiet` (`bool`) -- Silence subprocess errors from the launch stack trace to only show the relevant tracebacks. (Only applicable to DeepSpeed and single-process configurations).
+
+
+The rest of these arguments are configured through `accelerate config` and are read in from the specified `--config_file` (or default configuration) for their
+values. They can also be passed in manually.
+
+**Hardware Selection Arguments**:
+
+* `--cpu` (`bool`) -- Whether or not to force the training on the CPU.
+* `--multi_gpu` (`bool`) -- Whether or not this should launch a distributed GPU training.
+* `--tpu` (`bool`) -- Whether or not this should launch a TPU training.
+* `--ipex` (`bool`) -- Whether or not this should launch an Intel Pytorch Extension (IPEX) training.
+
+**Resource Selection Arguments**:
+
+The following arguments are useful for fine-tuning how available hardware should be used
+
+* `--mixed_precision {no,fp16,bf16,fp8}` (`str`) -- Whether or not to use mixed precision training. Choose between FP16 and BF16 (bfloat16) training. BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.
+* `--num_processes NUM_PROCESSES` (`int`) -- The total number of processes to be launched in parallel.
+* `--num_machines NUM_MACHINES` (`int`) -- The total number of machines used in this training.
+* `--num_cpu_threads_per_process NUM_CPU_THREADS_PER_PROCESS` (`int`) -- The number of CPU threads per process. Can be tuned for optimal performance.
+* `--enable_cpu_affinity` (`bool`) -- Whether or not CPU affinity and balancing should be enabled. Currently only supported on NVIDIA hardware.
+
+**Training Paradigm Arguments**:
+
+The following arguments are useful for selecting which training paradigm to use.
+
+* `--use_deepspeed` (`bool`) -- Whether or not to use DeepSpeed for training.
+* `--use_fsdp` (`bool`) -- Whether or not to use FullyShardedDataParallel for training.
+* `--use_megatron_lm` (`bool`) -- Whether or not to use Megatron-LM for training.
+* `--use_xpu` (`bool`) -- Whether to use IPEX plugin to speed up training on XPU specifically.
+
+**Distributed GPU Arguments**:
+
+The following arguments are only useful when `multi_gpu` is passed or multi-gpu training is configured through `accelerate config`:
+
+* `--gpu_ids` (`str`) -- What GPUs (by id) should be used for training on this machine as a comma-seperated list
+* `--same_network` (`bool`) -- Whether all machines used for multinode training exist on the same local network.
+* `--machine_rank` (`int`) -- The rank of the machine on which this script is launched.
+* `--main_process_ip` (`str`) -- The IP address of the machine of rank 0.
+* `--main_process_port` (`int`) -- The port to use to communicate with the machine of rank 0.
+* `-t`, `--tee` (`str`) -- Tee std streams into a log file and also to console.
+* `--log_dir` (`str`) -- Base directory to use for log files when using torchrun/torch.distributed.run as launcher. Use with --tee to redirect std streams info log files.
+* `--role` (`str`) -- User-defined role for the workers.
+* `--rdzv_backend` (`str`) -- The rendezvous method to use, such as 'static' (the default) or 'c10d'
+* `--rdzv_conf` (`str`) -- Additional rendezvous configuration (
+
+Tutorials
+ Learn the basics and become familiar with using Accelerate. Start here if you are using Accelerate for the first time!
+ +How-to guides
+ Practical guides to help you achieve a specific goal. Take a look at these guides to learn how to use Accelerate to solve real-world problems.
+ +Conceptual guides
+ High-level explanations for building a better understanding of important topics such as avoiding subtle nuances and pitfalls in distributed training and DeepSpeed.
+ +Reference
+ Technical descriptions of how Accelerate classes and methods work.
+ +
+
+
+
+
+
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/fsdp.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/fsdp.md
new file mode 100644
index 0000000000000000000000000000000000000000..a2f9c717a3f359e03fb150cdb1bfeb2183b7eb86
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/fsdp.md
@@ -0,0 +1,200 @@
+
+
+# Fully Sharded Data Parallel
+
+To accelerate training huge models on larger batch sizes, we can use a fully sharded data parallel model.
+This type of data parallel paradigm enables fitting more data and larger models by sharding the optimizer states, gradients and parameters.
+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/).
+We have integrated the latest PyTorch's Fully Sharded Data Parallel (FSDP) training feature.
+All you need to do is enable it through the config.
+
+## How it works out of the box
+
+On your machine(s) just run:
+
+```bash
+accelerate config
+```
+
+and answer the questions asked. This will generate a config file that will be used automatically to properly set the
+default options when doing
+
+```bash
+accelerate launch my_script.py --args_to_my_script
+```
+
+For instance, here is how you would run `examples/nlp_example.py` (from the root of the repo) with FSDP enabled:
+
+```bash
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+ fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+ fsdp_backward_prefetch_policy: BACKWARD_PRE
+ fsdp_forward_prefetch: false
+ fsdp_cpu_ram_efficient_loading: true
+ fsdp_offload_params: false
+ fsdp_sharding_strategy: FULL_SHARD
+ fsdp_state_dict_type: SHARDED_STATE_DICT
+ fsdp_sync_module_states: true
+ fsdp_transformer_layer_cls_to_wrap: BertLayer
+ fsdp_use_orig_params: true
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+```bash
+accelerate launch examples/nlp_example.py
+```
+
+Currently, `Accelerate` supports the following config through the CLI:
+
+`fsdp_sharding_strategy`: [1] FULL_SHARD (shards optimizer states, gradients and parameters), [2] SHARD_GRAD_OP (shards optimizer states and gradients), [3] NO_SHARD (DDP), [4] HYBRID_SHARD (shards optimizer states, gradients and parameters within each node while each node has full copy), [5] HYBRID_SHARD_ZERO2 (shards optimizer states and gradients within each node while each node has full copy). For more information, please refer the official [PyTorch docs](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy).
+
+`fsdp_offload_params` : Decides Whether to offload parameters and gradients to CPU
+
+`fsdp_auto_wrap_policy`: [1] TRANSFORMER_BASED_WRAP, [2] SIZE_BASED_WRAP, [3] NO_WRAP
+
+`fsdp_transformer_layer_cls_to_wrap`: Only applicable for Transformers. When using `fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP`, a user may provide a comma-separated string of transformer layer class names (case-sensitive) to wrap, e.g., `BertLayer`, `GPTJBlock`, `T5Block`, `BertLayer,BertEmbeddings,BertSelfOutput`. This is important because submodules that share weights (e.g., embedding layers) should not end up in different FSDP wrapped units. Using this policy, wrapping happens for each block containing Multi-Head Attention followed by a couple of MLP layers. Remaining layers including the shared embeddings are conveniently wrapped in same outermost FSDP unit. Therefore, use this for transformer-based models. You can use the `model._no_split_modules` for Transformer models by answering `yes` to `Do you want to use the model's `_no_split_modules` to wrap. It will try to use `model._no_split_modules` when possible.
+
+`fsdp_min_num_params`: minimum number of parameters when using `fsdp_auto_wrap_policy=SIZE_BASED_WRAP`.
+
+`fsdp_backward_prefetch_policy`: [1] BACKWARD_PRE, [2] BACKWARD_POST, [3] NO_PREFETCH
+
+`fsdp_forward_prefetch`: if True, then FSDP explicitly prefetches the next upcoming all-gather while executing in the forward pass. Should only be used for static-graph models since the prefetching follows the first iteration’s execution order. i.e., if the sub-modules' order changes dynamically during the model's execution do not enable this feature.
+
+`fsdp_state_dict_type`: [1] FULL_STATE_DICT, [2] LOCAL_STATE_DICT, [3] SHARDED_STATE_DICT
+
+`fsdp_use_orig_params`: If True, allows non-uniform `requires_grad` during init, which means support for interspersed frozen and trainable parameters. This setting is useful in cases such as parameter-efficient fine-tuning as discussed in [this post](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019). This option also allows one to have multiple optimizer param groups. This should be `True` when creating an optimizer before preparing/wrapping the model with FSDP.
+
+`fsdp_cpu_ram_efficient_loading`: Only applicable for Transformers models. If True, only the first process loads the pretrained model checkpoint while all other processes have empty weights. This should be set to False if you experience errors when loading the pretrained Transformers model via `from_pretrained` method. When this setting is True `fsdp_sync_module_states` also must to be True, otherwise all the processes except the main process would have random weights leading to unexpected behaviour during training. For this to work, make sure the distributed process group is initialized before calling Transformers `from_pretrained` method. When using Trainer API, the distributed process group is initialized when you create an instance of `TrainingArguments` class.
+
+`fsdp_sync_module_states`: If True, each individually wrapped FSDP unit will broadcast module parameters from rank 0.
+
+
+For additional and more nuanced control, you can specify other FSDP parameters via `FullyShardedDataParallelPlugin`.
+When creating `FullyShardedDataParallelPlugin` object, pass it the parameters that weren't part of the accelerate config or if you want to override them.
+The FSDP parameters will be picked based on the accelerate config file or launch command arguments and other parameters that you will pass directly through the `FullyShardedDataParallelPlugin` object will set/override that.
+
+Below is an example:
+
+```py
+from accelerate import FullyShardedDataParallelPlugin
+from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig
+
+fsdp_plugin = FullyShardedDataParallelPlugin(
+ state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),
+ optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=False, rank0_only=False),
+)
+
+accelerator = Accelerator(fsdp_plugin=fsdp_plugin)
+```
+
+## Saving and loading
+
+The new recommended way of checkpointing when using FSDP models is to use `SHARDED_STATE_DICT` as `StateDictType` when setting up the accelerate config.
+Below is the code snippet to save using `save_state` utility of accelerate.
+
+```py
+accelerator.save_state("ckpt")
+```
+
+Inspect the checkpoint folder to see model and optimizer as shards per process:
+```
+ls ckpt
+# optimizer_0 pytorch_model_0 random_states_0.pkl random_states_1.pkl scheduler.bin
+
+cd ckpt
+
+ls optimizer_0
+# __0_0.distcp __1_0.distcp
+
+ls pytorch_model_0
+# __0_0.distcp __1_0.distcp
+```
+
+To load them back for resuming the training, use the `load_state` utility of accelerate
+
+```py
+accelerator.load_state("ckpt")
+```
+
+When using transformers `save_pretrained`, pass `state_dict=accelerator.get_state_dict(model)` to save the model state dict.
+ Below is an example:
+
+```diff
+ unwrapped_model.save_pretrained(
+ args.output_dir,
+ is_main_process=accelerator.is_main_process,
+ save_function=accelerator.save,
++ state_dict=accelerator.get_state_dict(model),
+)
+```
+
+### State Dict
+
+`accelerator.get_state_dict` will call the underlying `model.state_dict` implementation using `FullStateDictConfig(offload_to_cpu=True, rank0_only=True)` context manager to get the state dict only for rank 0 and it will be offloaded to CPU.
+
+You can then pass `state` into the `save_pretrained` method. There are several modes for `StateDictType` and `FullStateDictConfig` that you can use to control the behavior of `state_dict`. For more information, see the [PyTorch documentation](https://pytorch.org/docs/stable/fsdp.html).
+
+If you choose to use `StateDictType.SHARDED_STATE_DICT`, the weights of the model during `Accelerator.save_state` will be split into `n` files for each sub-split on the model. To merge them back into
+a single dictionary to load back into the model later after training you can use the `merge_weights` utility:
+
+```py
+from accelerate.utils import merge_fsdp_weights
+
+# Our weights are saved usually in a `pytorch_model_fsdp_{model_number}` folder
+merge_fsdp_weights("pytorch_model_fsdp_0", "output_path", safe_serialization=True)
+```
+The final output will then either be saved to `model.safetensors` or `pytorch_model.bin` (if `safe_serialization=False` is passed).
+
+This can also be called using the CLI:
+```bash
+accelerate merge-weights pytorch_model_fsdp_0/ output_path
+```
+
+
+## Mapping between FSDP sharding strategies and DeepSpeed ZeRO Stages
+* `FULL_SHARD` maps to the DeepSpeed `ZeRO Stage-3`. Shards optimizer states, gradients and parameters.
+* `SHARD_GRAD_OP` maps to the DeepSpeed `ZeRO Stage-2`. Shards optimizer states and gradients.
+* `NO_SHARD` maps to `ZeRO Stage-0`. No sharding wherein each GPU has full copy of model, optimizer states and gradients.
+* `HYBRID_SHARD` maps to `ZeRO++ Stage-3` wherein `zero_hpz_partition_size=
+
+
+
+
+
+
+A community member has taken the idea and expanded it further, allowing you to filter models directly and see if you can run a particular LLM given GPU constraints and LoRA configurations. To play with it, see [here](https://huggingface.co/spaces/Vokturz/can-it-run-llm) for more details.
+
+## The Command
+
+When using `accelerate estimate-memory`, you need to pass in the name of the model you want to use, potentially the framework
+that model utilizing (if it can't be found automatically), and the data types you want the model to be loaded in with.
+
+For example, here is how we can calculate the memory footprint for `bert-base-cased`:
+
+```bash
+accelerate estimate-memory bert-base-cased
+```
+
+This will download the `config.json` for `bert-based-cased`, load the model on the `meta` device, and report back how much space
+it will use:
+
+Memory Usage for loading `bert-base-cased`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 84.95 MB | 418.18 MB | 1.61 GB |
+| float16 | 42.47 MB | 206.59 MB | 826.36 MB |
+| int8 | 21.24 MB | 103.29 MB | 413.18 MB |
+| int4 | 10.62 MB | 51.65 MB | 206.59 MB |
+
+By default it will return all the supported dtypes (`int4` through `float32`), but if you are interested in specific ones these can be filtered.
+
+### Specific libraries
+
+If the source library cannot be determined automatically (like it could in the case of `bert-base-cased`), a library name can
+be passed in.
+
+```bash
+accelerate estimate-memory HuggingFaceM4/idefics-80b-instruct --library_name transformers
+```
+
+Memory Usage for loading `HuggingFaceM4/idefics-80b-instruct`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 3.02 GB | 297.12 GB | 1.16 TB |
+| float16 | 1.51 GB | 148.56 GB | 594.24 GB |
+| int8 | 772.52 MB | 74.28 GB | 297.12 GB |
+| int4 | 386.26 MB | 37.14 GB | 148.56 GB |
+
+
+```bash
+accelerate estimate-memory timm/resnet50.a1_in1k --library_name timm
+```
+
+Memory Usage for loading `timm/resnet50.a1_in1k`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 9.0 MB | 97.7 MB | 390.78 MB |
+| float16 | 4.5 MB | 48.85 MB | 195.39 MB |
+| int8 | 2.25 MB | 24.42 MB | 97.7 MB |
+| int4 | 1.12 MB | 12.21 MB | 48.85 MB |
+
+### Specific dtypes
+
+As mentioned earlier, while we return `int4` through `float32` by default, any dtype can be used from `float32`, `float16`, `int8`, and `int4`.
+
+To do so, pass them in after specifying `--dtypes`:
+
+```bash
+accelerate estimate-memory bert-base-cased --dtypes float32 float16
+```
+
+Memory Usage for loading `bert-base-cased`:
+
+| dtype | Largest Layer | Total Size | Training using Adam |
+|---------|---------------|------------|---------------------|
+| float32 | 84.95 MB | 413.18 MB | 1.61 GB |
+| float16 | 42.47 MB | 206.59 MB | 826.36 MB |
+
+## Caveats with this calculator
+
+This calculator will tell you how much memory is needed to purely load the model in, *not* to perform inference.
+
+This calculation is accurate within a few % of the actual value, so it is a very good view of just how much memory it will take. For instance loading `bert-base-cased` actually takes `413.68 MB` when loaded on CUDA in full precision, and the calculator estimates `413.18 MB`.
+
+When performing inference you can expect to add up to an additional 20% as found by [EleutherAI](https://blog.eleuther.ai/transformer-math/). We'll be conducting research into finding a more accurate estimate to these values, and will update
+this calculator once done.
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/mps.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/mps.md
new file mode 100644
index 0000000000000000000000000000000000000000..f86cae5251147c86f6ed5ab39397a501679daa05
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/mps.md
@@ -0,0 +1,54 @@
+
+
+# Accelerated PyTorch Training on Mac
+
+With PyTorch v1.12 release, developers and researchers can take advantage of Apple silicon GPUs for significantly faster model training.
+This unlocks the ability to perform machine learning workflows like prototyping and fine-tuning locally, right on Mac.
+Apple's Metal Performance Shaders (MPS) as a backend for PyTorch enables this and can be used via the new `"mps"` device.
+This will map computational graphs and primitives on the MPS Graph framework and tuned kernels provided by MPS.
+For more information please refer official documents [Introducing Accelerated PyTorch Training on Mac](https://pytorch.org/blog/introducing-accelerated-pytorch-training-on-mac/)
+and [MPS BACKEND](https://pytorch.org/docs/stable/notes/mps.html).
+
+### Benefits of Training and Inference using Apple Silicon Chips
+
+1. Enables users to train larger networks or batch sizes locally
+2. Reduces data retrieval latency and provides the GPU with direct access to the full memory store due to unified memory architecture.
+Therefore, improving end-to-end performance.
+3. Reduces costs associated with cloud-based development or the need for additional local GPUs.
+
+**Pre-requisites**: To install torch with mps support,
+please follow this nice medium article [GPU-Acceleration Comes to PyTorch on M1 Macs](https://medium.com/towards-data-science/gpu-acceleration-comes-to-pytorch-on-m1-macs-195c399efcc1).
+
+
+## How it works out of the box
+It is enabled by default on MacOs machines with MPS enabled Apple Silicon GPUs.
+To disable it, pass `--cpu` flag to `accelerate launch` command or answer the corresponding question when answering the `accelerate config` questionnaire.
+
+You can directly run the following script to test it out on MPS enabled Apple Silicon machines:
+```bash
+accelerate launch /examples/cv_example.py --data_dir images
+```
+
+## A few caveats to be aware of
+
+1. We strongly recommend to install PyTorch >= 1.13 (nightly version at the time of writing) on your MacOS machine.
+It has major fixes related to model correctness and performance improvements for transformer based models.
+Please refer to https://github.com/pytorch/pytorch/issues/82707 for more details.
+2. Distributed setups `gloo` and `nccl` are not working with `mps` device.
+This means that currently only single GPU of `mps` device type can be used.
+
+Finally, please, remember that, `Accelerate` only integrates MPS backend, therefore if you
+have any problems or questions with regards to MPS backend usage, please, file an issue with [PyTorch GitHub](https://github.com/pytorch/pytorch/issues).
\ No newline at end of file
diff --git a/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/profiler.md b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/profiler.md
new file mode 100644
index 0000000000000000000000000000000000000000..d01101f9849bada0ec0d1f00e4e0300265ac4d60
--- /dev/null
+++ b/tasks/tasksmith-5db757e91a6e/tests/source/docs/source/usage_guides/profiler.md
@@ -0,0 +1,334 @@
+
+
+# Profiler
+
+Profiler is a tool that allows the collection of performance metrics during training and inference. Profiler’s context manager API can be used to better understand what model operators are the most expensive, examine their input shapes and stack traces, study device kernel activity, and visualize the execution trace. It provides insights into the performance of your model, allowing you to optimize and improve it.
+
+This guide explains how to use PyTorch Profiler to measure the time and memory consumption of the model’s operators and how to integrate this with Accelerate. We will cover various use cases and provide examples for each.
+
+## Using profiler to analyze execution time
+
+Profiler allows one to check which operators were called during the execution of a code range wrapped with a profiler context manager.
+
+Let’s see how we can use profiler to analyze the execution time:
+
+