




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


lowerCamelCase__ :   str					=							16
lowerCamelCase__ :   Tuple					=							32

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	List[str]							)					-> Optional[int]:
      return int(x / 2**20							)





class        lowerCamelCase_							:


 '''simple docstring'''







 def __enter__(							self  :		Union[str, Any]						):
       gc.collect()
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
       SCREAMING_SNAKE_CASE_							=			torch.cuda.memory_allocated()
       return self




 def __exit__(							self  :		List[str]				,				*_lowerCAmelCase  :		Optional[int]						):
       gc.collect()
       torch.cuda.empty_cache()
       SCREAMING_SNAKE_CASE_							=			torch.cuda.memory_allocated()
       SCREAMING_SNAKE_CASE_							=			torch.cuda.max_memory_allocated()
       SCREAMING_SNAKE_CASE_							=			bamb(self.end - self.begin						)
       SCREAMING_SNAKE_CASE_							=			bamb(self.peak - self.begin						)
       # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")


def 					UpperCAmelCase_							(      __UpperCAmelCase						:	Accelerator			,			__UpperCAmelCase						:	int = 16			,			__UpperCAmelCase						:	str = "bert-base-cased"			,			__UpperCAmelCase						:	int = 3_20			,			__UpperCAmelCase						:	int = 1_60			,			)					-> Union[str, Any]:
      SCREAMING_SNAKE_CASE_							=			AutoTokenizer.from_pretrained(__UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_							=			load_dataset(
          'glue'			,			'mrpc'			,			split={'train': f"train[:{n_train}]", 'validation': f"validation[:{n_val}]"}							)

      def tokenize_function(__UpperCAmelCase						:	str							):
            # max_length=None => use the model max length (it's actually the default)
            SCREAMING_SNAKE_CASE_							=			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
      SCREAMING_SNAKE_CASE_							=			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
      SCREAMING_SNAKE_CASE_							=			tokenized_datasets.rename_column('label'			,			'labels'							)

      def collate_fn(__UpperCAmelCase						:	List[Any]							):
            # 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=1_28			,			return_tensors='pt'							)
            return tokenizer.pad(__UpperCAmelCase			,			padding='longest'			,			return_tensors='pt'							)

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

      return train_dataloader, eval_dataloader

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	Optional[Any]			,			__UpperCAmelCase						:	Optional[int]							)					-> Any:
      # Initialize accelerator
      SCREAMING_SNAKE_CASE_							=			Accelerator()

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

      set_seed(__UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			get_dataloaders(__UpperCAmelCase			,			__UpperCAmelCase			,			__UpperCAmelCase			,			args.n_train			,			args.n_val							)

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

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

      if accelerator.state.deepspeed_plugin is not None:
            SCREAMING_SNAKE_CASE_							=			accelerator.state.deepspeed_plugin.deepspeed_config[
                'gradient_accumulation_steps'
            ]
      else:
            SCREAMING_SNAKE_CASE_							=			1
      SCREAMING_SNAKE_CASE_							=			(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
      ):
            SCREAMING_SNAKE_CASE_							=			get_linear_schedule_with_warmup(
                optimizer=__UpperCAmelCase			,			num_warmup_steps=0			,			num_training_steps=__UpperCAmelCase			,			)
      else:
            SCREAMING_SNAKE_CASE_							=			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.
      SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			accelerator.prepare(
          __UpperCAmelCase			,			__UpperCAmelCase			,			__UpperCAmelCase			,			__UpperCAmelCase			,			__UpperCAmelCase							)

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

      # Now we train the model
      SCREAMING_SNAKE_CASE_							=			{}
      for epoch in range(__UpperCAmelCase			,			__UpperCAmelCase							):
            with TorchTracemalloc() as tracemalloc:
                  model.train()
                  for step, batch in enumerate(__UpperCAmelCase							):
                        SCREAMING_SNAKE_CASE_							=			model(**__UpperCAmelCase							)
                        SCREAMING_SNAKE_CASE_							=			outputs.loss
                        SCREAMING_SNAKE_CASE_							=			loss / gradient_accumulation_steps
                        accelerator.backward(__UpperCAmelCase							)
                        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							)							)							)
            SCREAMING_SNAKE_CASE_							=			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(__UpperCAmelCase			,			__UpperCAmelCase							)

def 					UpperCAmelCase_							(      )					-> Optional[int]:
      SCREAMING_SNAKE_CASE_							=			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(
          '--peak_memory_upper_bound'			,			type=__UpperCAmelCase			,			default=__UpperCAmelCase			,			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=__UpperCAmelCase			,			default=3_20			,			help='Number of training examples to use.'			,			)
      parser.add_argument(
          '--n_val'			,			type=__UpperCAmelCase			,			default=1_60			,			help='Number of validation examples to use.'			,			)
      parser.add_argument(
          '--num_epochs'			,			type=__UpperCAmelCase			,			default=1			,			help='Number of train epochs.'			,			)
      SCREAMING_SNAKE_CASE_							=			parser.parse_args()
      SCREAMING_SNAKE_CASE_							=			{'lr': 2E-5, 'num_epochs': args.num_epochs, 'seed': 42, 'batch_size': 16}
      training_function(__UpperCAmelCase			,			__UpperCAmelCase							)


if __name__ == "__main__":
   main()





import sys
import webbrowser

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
   print('Googling.....')
   lowerCamelCase__ :   List[Any]					=							'https://www.google.com/search?q=' + ' '.join(sys.argv[1:])
   lowerCamelCase__ :   List[Any]					=							requests.get(url, headers={'UserAgent': UserAgent().random})
   # res.raise_for_status()
   with open('project1a.html', 'wb') as out_file:  # only for knowing the class
      for data in res.iter_content(10_000):
         out_file.write(data)
   lowerCamelCase__ :   int					=							BeautifulSoup(res.text, 'html.parser')
   lowerCamelCase__ :   List[str]					=							list(soup.select('.eZt8xd'))[:5]

   print(len(links))
   for link in links:
      if link.text == "Maps":
         webbrowser.open(link.get('href'))
      else:
         webbrowser.open(f'''https://google.com{link.get('href')}''')