


import argparse
import gc
import json
import os

import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType
from accelerate.utils.deepspeed import DummyOptim, DummyScheduler


A      = 16
A      = 32





def __UpperCAmelCase       (		__A			)						->					Tuple:



       '''simple docstring'''





       return int(x / 2**2_0			)


class     lowercase__  :






  def __enter__(					self      :					Any ):




         """simple docstring"""







         gc.collect()
         torch.cuda.empty_cache()
         torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
         UpperCAmelCase__										=     torch.cuda.memory_allocated()
         return self






  def __exit__(					self      :					Any		,						*_lowercase      :					List[Any] ):




         """simple docstring"""







         gc.collect()
         torch.cuda.empty_cache()
         UpperCAmelCase__										=     torch.cuda.memory_allocated()
         UpperCAmelCase__										=     torch.cuda.max_memory_allocated()
         UpperCAmelCase__										=     bamb(self.end - self.begin )
         UpperCAmelCase__										=     bamb(self.peak - self.begin )
         # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")





def __UpperCAmelCase       (		__A ,						__A = 1_6 ,						__A = "bert-base-cased" ,						__A = 3_2_0 ,						__A = 1_6_0 ,						)						->					Optional[int]:



       '''simple docstring'''





       UpperCAmelCase__										=     AutoTokenizer.from_pretrained(__A			)
       UpperCAmelCase__										=     load_dataset(
           "glue" ,						"mrpc" ,						split={"train": F"""train[:{n_train}]""", "validation": F"""validation[:{n_val}]"""}			)

       def tokenize_function(__A			):
              # max_length=None => use the model max length (it's actually the default)
              UpperCAmelCase__										=     tokenizer(examples["sentence1"] ,						examples["sentence2"] ,						truncation=__A ,						max_length=__A			)
              return outputs

       # Apply the method we just defined to all the examples in all the splits of the dataset
       UpperCAmelCase__										=     datasets.map(
           __A ,						batched=__A ,						remove_columns=["idx", "sentence1", "sentence2"] ,						load_from_cache_file=__A			)

       # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
       # transformers library
       UpperCAmelCase__										=     tokenized_datasets.rename_column("label" ,						"labels"			)

       def collate_fn(__A			):
              # On TPU it's best to pad everything to the same length or training will be very slow.
              if accelerator.distributed_type == DistributedType.TPU:
                     return tokenizer.pad(__A ,						padding="max_length" ,						max_length=1_2_8 ,						return_tensors="pt"			)
              return tokenizer.pad(__A ,						padding="longest" ,						return_tensors="pt"			)

       # Instantiate dataloaders.
       UpperCAmelCase__										=     DataLoader(
           tokenized_datasets["train"] ,						shuffle=__A ,						collate_fn=__A ,						batch_size=__A			)
       UpperCAmelCase__										=     DataLoader(
           tokenized_datasets["validation"] ,						shuffle=__A ,						collate_fn=__A ,						batch_size=__A			)

       return train_dataloader, eval_dataloader





def __UpperCAmelCase       (		__A ,						__A			)						->					Tuple:



       '''simple docstring'''





       UpperCAmelCase__										=     Accelerator()

       # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
       UpperCAmelCase__										=     config["lr"]
       UpperCAmelCase__										=     int(config["num_epochs"]			)
       UpperCAmelCase__										=     int(config["seed"]			)
       UpperCAmelCase__										=     int(config["batch_size"]			)
       UpperCAmelCase__										=     args.model_name_or_path

       set_seed(__A			)
       UpperCAmelCase__						,			UpperCAmelCase__										=     get_dataloaders(__A ,						__A ,						__A ,						args.n_train ,						args.n_val			)

       # Instantiate the model (we build the model here so that the seed also control new weights initialization)
       UpperCAmelCase__										=     AutoModelForSequenceClassification.from_pretrained(__A ,						return_dict=__A			)

       # Instantiate optimizer
       UpperCAmelCase__										=     (
           AdamW
           if accelerator.state.deepspeed_plugin is None
           or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
           else DummyOptim
       )
       UpperCAmelCase__										=     optimizer_cls(params=model.parameters() ,						lr=__A			)

       if accelerator.state.deepspeed_plugin is not None:
              UpperCAmelCase__										=     accelerator.state.deepspeed_plugin.deepspeed_config[
                  "gradient_accumulation_steps"
              ]
       else:
              UpperCAmelCase__										=     1
       UpperCAmelCase__										=     (len(__A			) * num_epochs) // gradient_accumulation_steps

       # Instantiate scheduler
       if (
           accelerator.state.deepspeed_plugin is None
           or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
       ):
              UpperCAmelCase__										=     get_linear_schedule_with_warmup(
                  optimizer=__A ,						num_warmup_steps=0 ,						num_training_steps=__A ,						)
       else:
              UpperCAmelCase__										=     DummyScheduler(__A ,						total_num_steps=__A ,						warmup_num_steps=0			)

       # Prepare everything
       # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
       # prepare method.
       UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__										=     accelerator.prepare(
           __A ,						__A ,						__A ,						__A ,						__A			)

       # We need to keep track of how many total steps we have iterated over
       UpperCAmelCase__										=     0
       # We also need to keep track of the stating epoch so files are named properly
       UpperCAmelCase__										=     0

       # Now we train the model
       UpperCAmelCase__										=     {}
       for epoch in range(__A ,						__A			):
              with TorchTracemalloc() as tracemalloc:
                     model.train()
                     for step, batch in enumerate(__A			):
                            UpperCAmelCase__										=     model(**__A			)
                            UpperCAmelCase__										=     outputs.loss
                            UpperCAmelCase__										=     loss / gradient_accumulation_steps
                            accelerator.backward(__A			)
                            if step % gradient_accumulation_steps == 0:
                                   optimizer.step()
                                   lr_scheduler.step()
                                   optimizer.zero_grad()

                            overall_step += 1

        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
              accelerator.print("Memory before entering the train : {}".format(bamb(tracemalloc.begin			)			)			)
              accelerator.print("Memory consumed at the end of the train (end-begin): {}".format(tracemalloc.used			)			)
              accelerator.print("Peak Memory consumed during the train (max-begin): {}".format(tracemalloc.peaked			)			)
              accelerator.print(
                  "Total Peak Memory consumed during the train (max): {}".format(
                      tracemalloc.peaked + bamb(tracemalloc.begin			)			)			)
              UpperCAmelCase__										=     tracemalloc.peaked + bamb(tracemalloc.begin			)
              if args.peak_memory_upper_bound is not None:
                     assert (
                         train_total_peak_memory[F"""epoch-{epoch}"""] <= args.peak_memory_upper_bound
                     ), "Peak memory usage exceeded the upper bound"

       accelerator.wait_for_everyone()
       if accelerator.is_main_process:
              with open(os.path.join(args.output_dir ,						"peak_memory_utilization.json"			) ,						"w"			) as f:
                     json.dump(__A ,						__A			)





def __UpperCAmelCase       (		)						->					Any:



       '''simple docstring'''





       UpperCAmelCase__										=     argparse.ArgumentParser(description="Simple example of training script tracking peak GPU memory usage."			)
       parser.add_argument(
           "--model_name_or_path" ,						type=__A ,						default="bert-base-cased" ,						help="Path to pretrained model or model identifier from huggingface.co/models." ,						required=__A ,						)
       parser.add_argument(
           "--output_dir" ,						type=__A ,						default="." ,						help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory." ,						)
       parser.add_argument(
           "--peak_memory_upper_bound" ,						type=__A ,						default=__A ,						help="The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value." ,						)
       parser.add_argument(
           "--n_train" ,						type=__A ,						default=3_2_0 ,						help="Number of training examples to use." ,						)
       parser.add_argument(
           "--n_val" ,						type=__A ,						default=1_6_0 ,						help="Number of validation examples to use." ,						)
       parser.add_argument(
           "--num_epochs" ,						type=__A ,						default=1 ,						help="Number of train epochs." ,						)
       UpperCAmelCase__										=     parser.parse_args()
       UpperCAmelCase__										=     {"lr": 2E-5, "num_epochs": args.num_epochs, "seed": 4_2, "batch_size": 1_6}
       training_function(__A ,						__A			)


if __name__ == "__main__":
    main()









import argparse
import os

import evaluate
import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType


########################################################################
# This is a fully working simple example to use Accelerate
# and perform gradient accumulation
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


A      = 16
A      = 32





def __UpperCAmelCase       (		__A ,						__A = 1_6			)						->					Tuple:



       '''simple docstring'''





       UpperCAmelCase__										=     AutoTokenizer.from_pretrained("bert-base-cased"			)
       UpperCAmelCase__										=     load_dataset("glue" ,						"mrpc"			)

       def tokenize_function(__A			):
              # max_length=None => use the model max length (it's actually the default)
              UpperCAmelCase__										=     tokenizer(examples["sentence1"] ,						examples["sentence2"] ,						truncation=__A ,						max_length=__A			)
              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:
       with accelerator.main_process_first():
              UpperCAmelCase__										=     datasets.map(
                  __A ,						batched=__A ,						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
       UpperCAmelCase__										=     tokenized_datasets.rename_column("label" ,						"labels"			)

       def collate_fn(__A			):
              # On TPU it's best to pad everything to the same length or training will be very slow.
              UpperCAmelCase__										=     1_2_8 if accelerator.distributed_type == DistributedType.TPU else None
              # When using mixed precision we want round multiples of 8/16
              if accelerator.mixed_precision == "fp8":
                     UpperCAmelCase__										=     1_6
              elif accelerator.mixed_precision != "no":
                     UpperCAmelCase__										=     8
              else:
                     UpperCAmelCase__										=     None

              return tokenizer.pad(
                  __A ,						padding="longest" ,						max_length=__A ,						pad_to_multiple_of=__A ,						return_tensors="pt" ,						)

       # Instantiate dataloaders.
       UpperCAmelCase__										=     DataLoader(
           tokenized_datasets["train"] ,						shuffle=__A ,						collate_fn=__A ,						batch_size=__A			)
       UpperCAmelCase__										=     DataLoader(
           tokenized_datasets["validation"] ,						shuffle=__A ,						collate_fn=__A ,						batch_size=__A			)

       return train_dataloader, eval_dataloader


# For testing only
if os.environ.get("TESTING_MOCKED_DATALOADERS", None) == "1":
    from accelerate.test_utils.training import mocked_dataloaders

    A      = mocked_dataloaders  # noqa: F811





def __UpperCAmelCase       (		__A ,						__A			)						->					Dict:



       '''simple docstring'''





       if os.environ.get("TESTING_MOCKED_DATALOADERS" ,						__A			) == "1":
              UpperCAmelCase__										=     2
       # New Code #
       UpperCAmelCase__										=     int(args.gradient_accumulation_steps			)
       # Initialize accelerator
       UpperCAmelCase__										=     Accelerator(
           cpu=args.cpu ,						mixed_precision=args.mixed_precision ,						gradient_accumulation_steps=__A			)
       if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1:
              raise NotImplementedError(
                  "Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`"			)
       # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
       UpperCAmelCase__										=     config["lr"]
       UpperCAmelCase__										=     int(config["num_epochs"]			)
       UpperCAmelCase__										=     int(config["seed"]			)
       UpperCAmelCase__										=     int(config["batch_size"]			)

       UpperCAmelCase__										=     evaluate.load("glue" ,						"mrpc"			)

       set_seed(__A			)
       UpperCAmelCase__						,			UpperCAmelCase__										=     get_dataloaders(__A ,						__A			)
       # Instantiate the model (we build the model here so that the seed also control new weights initialization)
       UpperCAmelCase__										=     AutoModelForSequenceClassification.from_pretrained("bert-base-cased" ,						return_dict=__A			)

       # We could avoid this line since the accelerator is set with `device_placement=True` (default value).
       # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
       # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
       UpperCAmelCase__										=     model.to(accelerator.device			)

       # Instantiate optimizer
       UpperCAmelCase__										=     AdamW(params=model.parameters() ,						lr=__A			)

       # Instantiate scheduler
       UpperCAmelCase__										=     get_linear_schedule_with_warmup(
           optimizer=__A ,						num_warmup_steps=1_0_0 ,						num_training_steps=(len(__A			) * num_epochs) ,						)

       # Prepare everything
       # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
       # prepare method.
       UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__						,			UpperCAmelCase__										=     accelerator.prepare(
           __A ,						__A ,						__A ,						__A ,						__A			)

       # Now we train the model
       for epoch in range(__A			):
              model.train()
              for step, batch in enumerate(__A			):
                     # We could avoid this line since we set the accelerator with `device_placement=True`.
                     batch.to(accelerator.device			)
                     # New code #
                     # We use the new `accumulate` context manager to perform gradient accumulation
                     # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests.
                     with accelerator.accumulate(__A			):
                            UpperCAmelCase__										=     model(**__A			)
                            UpperCAmelCase__										=     output.loss
                            accelerator.backward(__A			)
                            optimizer.step()
                            lr_scheduler.step()
                            optimizer.zero_grad()

              model.eval()
              for step, batch in enumerate(__A			):
                     # We could avoid this line since we set the accelerator with `device_placement=True`.
                     batch.to(accelerator.device			)
                     with torch.no_grad():
                            UpperCAmelCase__										=     model(**__A			)
                     UpperCAmelCase__										=     outputs.logits.argmax(dim=-1			)
                     UpperCAmelCase__						,			UpperCAmelCase__										=     accelerator.gather_for_metrics((predictions, batch["labels"])			)
                     metric.add_batch(
                         predictions=__A ,						references=__A ,						)

              UpperCAmelCase__										=     metric.compute()
              # Use accelerator.print to print only on the main process.
              accelerator.print(F"""epoch {epoch}:""" ,						__A			)





def __UpperCAmelCase       (		)						->					Dict:



       '''simple docstring'''





       UpperCAmelCase__										=     argparse.ArgumentParser(description="Simple example of training script."			)
       parser.add_argument(
           "--mixed_precision" ,						type=__A ,						default=__A ,						choices=["no", "fp16", "bf16", "fp8"] ,						help="Whether to use mixed precision. Choose"
           "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
           "and an Nvidia Ampere GPU." ,						)
       # New Code #
       parser.add_argument(
           "--gradient_accumulation_steps" ,						type=__A ,						default=1 ,						help="The number of minibatches to be ran before gradients are accumulated." ,						)
       parser.add_argument("--cpu" ,						action="store_true" ,						help="If passed, will train on the CPU."			)
       UpperCAmelCase__										=     parser.parse_args()
       UpperCAmelCase__										=     {"lr": 2E-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6}
       training_function(__A ,						__A			)


if __name__ == "__main__":
    main()





