




'''simple docstring'''







import argparse
import json
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
from accelerate.utils.deepspeed import DummyOptim, DummyScheduler


lowerCAmelCase_     						=				1_6
lowerCAmelCase_     						=				3_2







def 						_A      ( UpperCAmelCase      ,UpperCAmelCase = 16      ,UpperCAmelCase = "bert-base-cased"						):






   '''simple docstring'''







   A__       =     AutoTokenizer.from_pretrained(UpperCAmelCase						)
   A__       =     load_dataset('glue'      ,'mrpc'						)

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

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

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

   def collate_fn(UpperCAmelCase						):
      # 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(UpperCAmelCase      ,padding='max_length'      ,max_length=128      ,return_tensors='pt'						)
      return tokenizer.pad(UpperCAmelCase      ,padding='longest'      ,return_tensors='pt'						)

   # Instantiate dataloaders.
   A__       =     DataLoader(
       tokenized_datasets['train']      ,shuffle=UpperCAmelCase      ,collate_fn=UpperCAmelCase      ,batch_size=UpperCAmelCase						)
   A__       =     DataLoader(
       tokenized_datasets['validation']      ,shuffle=UpperCAmelCase      ,collate_fn=UpperCAmelCase      ,batch_size=UpperCAmelCase						)

   return train_dataloader, eval_dataloader







def 						_A      ( UpperCAmelCase      ,UpperCAmelCase						):






   '''simple docstring'''







   A__       =     Accelerator()

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

   set_seed(UpperCAmelCase						)
   A__  ,			A__       =     get_dataloaders(UpperCAmelCase      ,UpperCAmelCase      ,UpperCAmelCase						)

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

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

   if accelerator.state.deepspeed_plugin is not None:
      A__       =     accelerator.state.deepspeed_plugin.deepspeed_config[
          'gradient_accumulation_steps'
      ]
   else:
      A__       =     1
   A__       =     (len(UpperCAmelCase						) * num_epochs) // gradient_accumulation_steps

   # Instantiate scheduler
   if (
       accelerator.state.deepspeed_plugin is None
       or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
   ):
      A__       =     get_linear_schedule_with_warmup(
          optimizer=UpperCAmelCase      ,num_warmup_steps=0      ,num_training_steps=UpperCAmelCase      ,)
   else:
      A__       =     DummyScheduler(UpperCAmelCase      ,total_num_steps=UpperCAmelCase      ,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.
   A__  ,			A__  ,			A__  ,			A__  ,			A__       =     accelerator.prepare(
       UpperCAmelCase      ,UpperCAmelCase      ,UpperCAmelCase      ,UpperCAmelCase      ,UpperCAmelCase						)

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

   # Now we train the model
   A__       =     evaluate.load('glue'      ,'mrpc'						)
   A__       =     0
   A__       =     {}
   for epoch in range(UpperCAmelCase      ,UpperCAmelCase						):
      model.train()
      for step, batch in enumerate(UpperCAmelCase						):
         A__       =     model(**UpperCAmelCase						)
         A__       =     outputs.loss
         A__       =     loss / gradient_accumulation_steps
         accelerator.backward(UpperCAmelCase						)
         if step % gradient_accumulation_steps == 0:
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()

         overall_step += 1

      model.eval()
      A__       =     0
      for step, batch in enumerate(UpperCAmelCase						):
         # We could avoid this line since we set the accelerator with `device_placement=True`.
         batch.to(accelerator.device						)
         with torch.no_grad():
            A__       =     model(**UpperCAmelCase						)
         A__       =     outputs.logits.argmax(dim=-1						)
         # It is slightly faster to call this once, than multiple times
         A__  ,			A__       =     accelerator.gather(
             (predictions, batch['labels'])						)  # If we are in a multiprocess environment, the last batch has duplicates
         if accelerator.use_distributed:
            if step == len(UpperCAmelCase						) - 1:
               A__       =     predictions[: len(eval_dataloader.dataset						) - samples_seen]
               A__       =     references[: len(eval_dataloader.dataset						) - samples_seen]
            else:
               samples_seen += references.shape[0]
         metric.add_batch(
             predictions=UpperCAmelCase      ,references=UpperCAmelCase      ,)

      A__       =     metric.compute()
      # Use accelerator.print to print only on the main process.
      accelerator.print(F"""epoch {epoch}:"""      ,UpperCAmelCase						)
      A__       =     eval_metric['accuracy']

      if best_performance < eval_metric["accuracy"]:
         A__       =     eval_metric['accuracy']

   if args.performance_lower_bound is not None:
      assert (
          args.performance_lower_bound <= best_performance
      ), F"""Best performance metric {best_performance} is lower than the lower bound {args.performance_lower_bound}"""

   accelerator.wait_for_everyone()
   if accelerator.is_main_process:
      with open(os.path.join(args.output_dir      ,'all_results.json'						)      ,'w'						) as f:
         json.dump(UpperCAmelCase      ,UpperCAmelCase						)







def 						_A      ( ):






   '''simple docstring'''







   A__       =     argparse.ArgumentParser(description='Simple example of training script tracking peak GPU memory usage.'						)
   parser.add_argument(
       '--model_name_or_path'      ,type=UpperCAmelCase      ,default='bert-base-cased'      ,help='Path to pretrained model or model identifier from huggingface.co/models.'      ,required=UpperCAmelCase      ,)
   parser.add_argument(
       '--output_dir'      ,type=UpperCAmelCase      ,default='.'      ,help='Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'      ,)
   parser.add_argument(
       '--performance_lower_bound'      ,type=UpperCAmelCase      ,default=UpperCAmelCase      ,help='Optional lower bound for the performance metric. If set, the training will throw error when the performance metric drops below this value.'      ,)
   parser.add_argument(
       '--num_epochs'      ,type=UpperCAmelCase      ,default=3      ,help='Number of train epochs.'      ,)
   A__       =     parser.parse_args()
   A__       =     {'lr': 2e-5, 'num_epochs': args.num_epochs, 'seed': 42, 'batch_size': 16}
   training_function(UpperCAmelCase      ,UpperCAmelCase						)


if __name__ == "__main__":
    main()








'''simple docstring'''







def 						_A      ( ):






   '''simple docstring'''







   A__       =     [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

   A__       =     6
   A__       =     1
   A__       =     1901

   A__       =     0

   while year < 2001:
      day += 7

      if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
         if day > days_per_month[month - 1] and month != 2:
            month += 1
            A__       =     day - days_per_month[month - 2]
         elif day > 29 and month == 2:
            month += 1
            A__       =     day - 29
      else:
         if day > days_per_month[month - 1]:
            month += 1
            A__       =     day - days_per_month[month - 2]

      if month > 12:
         year += 1
         A__       =     1

      if year < 2001 and day == 1:
         sundays += 1
   return sundays


if __name__ == "__main__":
    print(solution())


