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
  #
  ########################################################################
  
  _lowerCAmelCase     :			str    =32
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE = 1_6			):
  	UpperCAmelCase__:  Optional[Any]		       =   AutoTokenizer.from_pretrained("bert-base-cased"			)
  	UpperCAmelCase__:  Dict		       =   load_dataset("glue"  ,"mrpc"			)
  
  	def tokenize_function(SCREAMING_SNAKE_CASE			):
  		# 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(SCREAMING_SNAKE_CASE			):
  		# When using mixed precision we want round multiples of 8/16
  		if accelerator.mixed_precision == "fp8":
  			UpperCAmelCase__:  Tuple		       =   1_6
  		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
  
  					_lowerCAmelCase     :			int    =mocked_dataloaders  # noqa: F811
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	# 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(SCREAMING_SNAKE_CASE			):
  		# 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__:  Union[str, Any]		       =   get_dataloaders(__lowerCamelCase  ,__lowerCamelCase			)
  
  		# Instantiate scheduler
  		UpperCAmelCase__:  Any		       =   get_linear_schedule_with_warmup(
  		    optimizer=__lowerCamelCase  ,num_warmup_steps=1_0_0  ,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__:  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__:  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  _A  (			):
  	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""": 4_2, """batch_size""": 2_5_6}
  	training_function(__lowerCamelCase  ,__lowerCamelCase			)
  
  
  if __name__ == "__main__":
  					main()
style_context: 
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Optional[Any]		       =   [True] * n
  	UpperCAmelCase__:  Any		       =   False
  	UpperCAmelCase__:  Tuple		       =   False
  	UpperCAmelCase__:  Optional[Any]		       =   True
  
  	for i in range(3  ,int(n**0.5 + 1			)  ,2			):
  		UpperCAmelCase__:  Any		       =   i * 2
  		while index < n:
  			UpperCAmelCase__:  Optional[int]		       =   False
  			UpperCAmelCase__:  Tuple		       =   index + i
  
  	UpperCAmelCase__:  int		       =   [2]
  
  	for i in range(3  ,SCREAMING_SNAKE_CASE  ,2			):
  		if is_prime[i]:
  			primes.append(SCREAMING_SNAKE_CASE			)
  
  	return primes
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   str(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Tuple		       =   []
  	UpperCAmelCase__:  Optional[int]		       =   ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
  
  	for duplicate in Counter(SCREAMING_SNAKE_CASE			) - Counter(set(SCREAMING_SNAKE_CASE			)			):
  		UpperCAmelCase__:  Optional[Any]		       =   [int(number_str.replace(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			) for digit in digits]
  		replacements.append(SCREAMING_SNAKE_CASE			)
  
  	return replacements
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE = 8			):
  	UpperCAmelCase__:  Union[str, Any]		       =   set()
  
  	# Filter primes with less than 3 replaceable digits
  	UpperCAmelCase__:  Optional[Any]		       =   {
  	    x for x in set(prime_sieve(1_0_0_0_0_0_0			)			) if len(str(SCREAMING_SNAKE_CASE			)			) - len(set(str(SCREAMING_SNAKE_CASE			)			)			) >= 3
  	}
  
  	for prime in primes:
  		if prime in numbers_checked:
  			continue
  
  		UpperCAmelCase__:  Optional[int]		       =   digit_replacements(SCREAMING_SNAKE_CASE			)
  
  		for family in replacements:
  			numbers_checked.update(SCREAMING_SNAKE_CASE			)
  			UpperCAmelCase__:  Dict		       =   primes.intersection(SCREAMING_SNAKE_CASE			)
  
  			if len(SCREAMING_SNAKE_CASE			) != family_length:
  				continue
  
  			return min(SCREAMING_SNAKE_CASE			)
  
  	return -1
  
  
  if __name__ == "__main__":
  					print(solution())