code: 
  
  
  
  
  
  
  import argparse
  import os
  
  # New Code #
  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
  from accelerate.utils import find_executable_batch_size
  
  
  ########################################################################
  # This is a fully working simple example to use Accelerate,
  # specifically showcasing how to combine both the gradient accumulation
  # and automatic batch size finder utilities of Accelerate to perfrom
  # automatic 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)
  #
  # New additions from the base script can be found quickly by
  # looking for the # New Code # tags
  #
  # 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
  #
  ########################################################################
  
  SCREAMING_SNAKE_CASE__		:       str   							=							32
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase = 16					)   -> Union[str, Any]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Optional[Any]										= AutoTokenizer.from_pretrained("""bert-base-cased"""					)
       UpperCAmelCase__			:     Dict										= load_dataset("""glue"""   ,       """mrpc"""					)
  
       def tokenize_function(__lowerCamelCase					):
            # max_length=None => use the model max length (it's actually the default)
            UpperCAmelCase__			:     List[Any]										= tokenizer(examples["""sentence1"""]   ,       examples["""sentence2"""]   ,       truncation=__lowerCamelCase   ,       max_length=__lowerCamelCase					)
            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__			:     Tuple										= datasets.map(
                __lowerCamelCase   ,       batched=__lowerCamelCase   ,       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__			:     Tuple										= tokenized_datasets.rename_column("""label"""   ,       """labels"""					)
  
       def collate_fn(__lowerCamelCase					):
            # When using mixed precision we want round multiples of 8/16
            if accelerator.mixed_precision == "fp8":
                 UpperCAmelCase__			:     Tuple										= 16
            elif accelerator.mixed_precision != "no":
                 UpperCAmelCase__			:     str										= 8
            else:
                 UpperCAmelCase__			:     Union[str, Any]										= None
  
            return tokenizer.pad(
                __lowerCamelCase   ,       padding="""longest"""   ,       pad_to_multiple_of=__lowerCamelCase   ,       return_tensors="""pt"""   ,       )
  
       # Instantiate dataloaders.
       UpperCAmelCase__			:     Union[str, Any]										= DataLoader(
           tokenized_datasets["""train"""]   ,       shuffle=__lowerCamelCase   ,       collate_fn=__lowerCamelCase   ,       batch_size=__lowerCamelCase					)
       UpperCAmelCase__			:     str										= DataLoader(
           tokenized_datasets["""validation"""]   ,       shuffle=__lowerCamelCase   ,       collate_fn=__lowerCamelCase   ,       batch_size=__lowerCamelCase					)
  
       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
  
        SCREAMING_SNAKE_CASE__		:       int   							=							mocked_dataloaders  # noqa: F811
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> int:
  
       '''simple docstring'''
       # For testing only
       if os.environ.get("""TESTING_MOCKED_DATALOADERS"""   ,       __lowerCamelCase					) == "1":
            UpperCAmelCase__			:     Any										= 2
       # Initialize accelerator
       UpperCAmelCase__			:     Optional[Any]										= Accelerator(cpu=args.cpu   ,       mixed_precision=args.mixed_precision					)
       # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
       UpperCAmelCase__			:     Optional[int]										= config["""lr"""]
       UpperCAmelCase__			:     Union[str, Any]										= int(config["""num_epochs"""]					)
       UpperCAmelCase__			:     Optional[int]										= int(config["""seed"""]					)
       UpperCAmelCase__			:     Optional[int]										= int(config["""batch_size"""]					)
  
       UpperCAmelCase__			:     List[Any]										= evaluate.load("""glue"""   ,       """mrpc"""					)
  
       # New Code #
       # We use the `find_executable_batch_size` decorator, passing in the desired observed batch size
       # to train on. If a CUDA OOM error occurs, it will retry this loop cutting the batch size in
       # half each time. From this, we can calculate the number of gradient accumulation steps needed
       # and modify the Accelerator object as a result
       @find_executable_batch_size(starting_batch_size=int(__lowerCamelCase					)					)
       def inner_training_loop(__lowerCamelCase					):
            # Since we need to modify the outside accelerator object, we need to bring it
            # to the local scope
            nonlocal accelerator
  
            # We can calculate the number of gradient accumulation steps based on the current
            # batch size vs the starting batch size
            UpperCAmelCase__			:     Optional[int]										= observed_batch_size // batch_size
  
            # And then set it in the Accelerator directly:
            UpperCAmelCase__			:     Any										= num_gradient_accumulation_steps
  
            # Next we need to free all of the stored model references in the Accelerator each time
            accelerator.free_memory()
  
            # And set the seed so our results are reproducable each reset
            set_seed(__lowerCamelCase					)
  
            # Instantiate the model (we build the model here so that the seed also control new weights initialization)
            UpperCAmelCase__			:     Optional[Any]										= AutoModelForSequenceClassification.from_pretrained("""bert-base-cased"""   ,       return_dict=__lowerCamelCase					)
  
            # 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__			:     str										= model.to(accelerator.device					)
  
            # Instantiate optimizer
            UpperCAmelCase__			:     Optional[int]										= AdamW(params=model.parameters()   ,       lr=__lowerCamelCase					)
            UpperCAmelCase__			,		UpperCAmelCase__			:     Union[str, Any]										= get_dataloaders(__lowerCamelCase   ,       __lowerCamelCase					)
  
            # Instantiate scheduler
            UpperCAmelCase__			:     Any										= get_linear_schedule_with_warmup(
                optimizer=__lowerCamelCase   ,       num_warmup_steps=100   ,       num_training_steps=(len(__lowerCamelCase					) * 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__			:     List[Any]										= accelerator.prepare(
                __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)
  
            # Now we train the model
            for epoch in range(__lowerCamelCase					):
                 model.train()
                 for step, batch in enumerate(__lowerCamelCase					):
                      # And perform gradient accumulation
                      with accelerator.accumulate(__lowerCamelCase					):
                           # We could avoid this line since we set the accelerator with `device_placement=True`.
                           batch.to(accelerator.device					)
                           UpperCAmelCase__			:     List[Any]										= model(**__lowerCamelCase					)
                           UpperCAmelCase__			:     Any										= outputs.loss
                           accelerator.backward(__lowerCamelCase					)
                           optimizer.step()
                           lr_scheduler.step()
                           optimizer.zero_grad()
  
                 model.eval()
                 for step, batch in enumerate(__lowerCamelCase					):
                      # We could avoid this line since we set the accelerator with `device_placement=True`.
                      batch.to(accelerator.device					)
                      with torch.no_grad():
                           UpperCAmelCase__			:     Union[str, Any]										= model(**__lowerCamelCase					)
                      UpperCAmelCase__			:     Tuple										= outputs.logits.argmax(dim=-1					)
                      UpperCAmelCase__			,		UpperCAmelCase__			:     Optional[Any]										= accelerator.gather_for_metrics((predictions, batch["""labels"""])					)
                      metric.add_batch(
                          predictions=__lowerCamelCase   ,       references=__lowerCamelCase   ,       )
  
                 UpperCAmelCase__			:     Dict										= metric.compute()
                 # Use accelerator.print to print only on the main process.
                 accelerator.print(F"epoch {epoch}:"   ,       __lowerCamelCase					)
  
      # New Code #
      # And call it at the end with no arguments
      # Note: You could also refactor this outside of your training loop function
       inner_training_loop()
  
  
  
  
  
  def    _lowerCamelCase	(	)   -> Union[str, Any]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Dict										= argparse.ArgumentParser(description="""Simple example of training script."""					)
       parser.add_argument(
           """--mixed_precision"""   ,       type=__lowerCamelCase   ,       default=__lowerCamelCase   ,       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."""   ,       )
       parser.add_argument("""--cpu"""   ,       action="""store_true"""   ,       help="""If passed, will train on the CPU."""					)
       UpperCAmelCase__			:     Any										= parser.parse_args()
       # New Code #
       # We modify the starting batch size to be an observed batch size of 256, to guarentee an initial CUDA OOM
       UpperCAmelCase__			:     Union[str, Any]										= {"""lr""": 2E-5, """num_epochs""": 3, """seed""": 42, """batch_size""": 256}
       training_function(__lowerCamelCase   ,       __lowerCamelCase					)
  
  
  if __name__ == "__main__":
        main()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import random
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase		):
            UpperCAmelCase__			:     Union[str, Any]										= x
            UpperCAmelCase__			:     Union[str, Any]										= y
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            return (self.x**2 + self.y**2) <= 1
  
  
  
  
       @classmethod
       def      __UpperCAmelCase     (							cls		):
            return cls(x=random.random()  ,	y=random.random()		)
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase					)   -> float:
  
       '''simple docstring'''
       if number_of_simulations < 1:
            raise ValueError("""At least one simulation is necessary to estimate PI."""					)
  
       UpperCAmelCase__			:     Dict										= 0
       for _ in range(__lowerCamelCase					):
            UpperCAmelCase__			:     Union[str, Any]										= Point.random_unit_square()
  
            if random_point.is_in_unit_circle():
                 number_in_unit_circle += 1
  
       return 4 * number_in_unit_circle / number_of_simulations
  
  
  if __name__ == "__main__":
        # import doctest
  
        # doctest.testmod()
        from math import pi
  
        SCREAMING_SNAKE_CASE__		:       List[str]   							=							"""Please enter the desired number of Monte Carlo simulations: """
        SCREAMING_SNAKE_CASE__		:       int   							=							estimate_pi(int(input(prompt).strip()))
        print(f'''An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}''')
  
  
  
  
  
  
  