


'''simple docstring'''







import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


a__    :   Tuple								=			logging.getLogger(__name__)

require_version('pytorch_lightning>=1.0.4')

a__    :   Union[str, Any]								=			{
    'base': AutoModel,
    'sequence-classification': AutoModelForSequenceClassification,
    'question-answering': AutoModelForQuestionAnswering,
    'pretraining': AutoModelForPreTraining,
    'token-classification': AutoModelForTokenClassification,
    'language-modeling': AutoModelWithLMHead,
    'summarization': AutoModelForSeqaSeqLM,
    'translation': AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
a__    :   str								=			{
    'linear': get_linear_schedule_with_warmup,
    'cosine': get_cosine_schedule_with_warmup,
    'cosine_w_restarts': get_cosine_with_hard_restarts_schedule_with_warmup,
    'polynomial': get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
a__    :   Dict								=			sorted(arg_to_scheduler.keys())
a__    :   str								=			'{' + ', '.join(arg_to_scheduler_choices) + '}'
class    lowercase_	(       pl.LightningModule  ):


    def __init__(	self    ,   a    ,   a=None    ,   a="base"    ,   a=None    ,   a=None    ,   a=None    ,   **a    ,   ):
          super().__init__()
          # TODO: move to self.save_hyperparameters()
          # self.save_hyperparameters()
          # can also expand arguments into trainer signature for easier reading

          self.save_hyperparameters(a       )
          UpperCamelCase__      =							0
          UpperCamelCase__      =							Path(self.hparams.output_dir       )
          UpperCamelCase__      =							self.hparams.cache_dir if self.hparams.cache_dir else None
          if config is None:
                UpperCamelCase__      =							AutoConfig.from_pretrained(
                    self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path    ,   **({"num_labels": num_labels} if num_labels is not None else {})    ,   cache_dir=a    ,   **a    ,   )
          else:
                UpperCamelCase__      =							config

          UpperCamelCase__      =							("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
          for p in extra_model_params:
                if getattr(self.hparams    ,   a    ,   a       ):
                      assert hasattr(self.config    ,   a       ), f'''model config doesn\'t have a `{p}` attribute'''
                      setattr(self.config    ,   a    ,   getattr(self.hparams    ,   a       )       )

          if tokenizer is None:
                UpperCamelCase__      =							AutoTokenizer.from_pretrained(
                    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path    ,   cache_dir=a    ,   )
          else:
                UpperCamelCase__      =							tokenizer
          UpperCamelCase__      =							MODEL_MODES[mode]
          if model is None:
                UpperCamelCase__      =							self.model_type.from_pretrained(
                    self.hparams.model_name_or_path    ,   from_tf=bool(".ckpt" in self.hparams.model_name_or_path       )    ,   config=self.config    ,   cache_dir=a    ,   )
          else:
                UpperCamelCase__      =							model


    def   __a				(	self    ,   *a    ,   **a       ):
          UpperCamelCase__      =							self.model_type.from_pretrained(*a    ,   **a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							arg_to_scheduler[self.hparams.lr_scheduler]
          UpperCamelCase__      =							get_schedule_func(
              self.opt    ,   num_warmup_steps=self.hparams.warmup_steps    ,   num_training_steps=self.total_steps()       )
          UpperCamelCase__      =							{"scheduler": scheduler, "interval": "step", "frequency": 1}
          return scheduler


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model
          UpperCamelCase__      =							["bias", "LayerNorm.weight"]
          UpperCamelCase__      =							[
              {
                  "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay       )],
                  "weight_decay": self.hparams.weight_decay,
              },
              {
                  "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay       )],
                  "weight_decay": 0.0,
              },
          ]
          if self.hparams.adafactor:
                UpperCamelCase__      =							Adafactor(
                    a    ,   lr=self.hparams.learning_rate    ,   scale_parameter=a    ,   relative_step=a       )

          else:
                UpperCamelCase__      =							AdamW(
                    a    ,   lr=self.hparams.learning_rate    ,   eps=self.hparams.adam_epsilon       )
          UpperCamelCase__      =							optimizer

          UpperCamelCase__      =							self.get_lr_scheduler()

          return [optimizer], [scheduler]


    def   __a				(	self    ,   a    ,   a       ):
          return self.validation_step(a    ,   a       )


    def   __a				(	self    ,   a       ):
          return self.validation_end(a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							max(1    ,   self.hparams.gpus       )  # TODO: consider num_tpu_cores
          UpperCamelCase__      =							self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
          return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs


    def   __a				(	self    ,   a       ):
          if mode == "test":
                UpperCamelCase__      =							len(self.test_dataloader().dataset       )
          else:
                UpperCamelCase__      =							self.get_dataloader("train"    ,   self.hparams.train_batch_size    ,   shuffle=a       )
                UpperCamelCase__      =							len(self.train_dataloader().dataset       )


    def   __a				(	self    ,   a    ,   a    ,   a = False       ):
          raise NotImplementedError("You must implement this for your task"       )


    def   __a				(	self       ):
          return self.train_loader


    def   __a				(	self       ):
          return self.get_dataloader("dev"    ,   self.hparams.eval_batch_size    ,   shuffle=a       )


    def   __a				(	self       ):
          return self.get_dataloader("test"    ,   self.hparams.eval_batch_size    ,   shuffle=a       )


    def   __a				(	self    ,   a       ):
          return os.path.join(
              self.hparams.data_dir    ,   "cached_{}_{}_{}".format(
                  a    ,   list(filter(a    ,   self.hparams.model_name_or_path.split("/"       )       )       ).pop()    ,   str(self.hparams.max_seq_length       )    ,   )    ,   )


    @pl.utilities.rank_zero_only
    def   __a				(	self    ,   a       ):
          UpperCamelCase__      =							self.output_dir.joinpath("best_tfmr"       )
          UpperCamelCase__      =							self.step_count
          self.model.save_pretrained(a       )
          self.tokenizer.save_pretrained(a       )


    @staticmethod
    def   __a				(	a    ,   a       ):
          parser.add_argument(
              "--model_name_or_path"    ,   default=a    ,   type=a    ,   required=a    ,   help="Path to pretrained model or model identifier from huggingface.co/models"    ,   )
          parser.add_argument(
              "--config_name"    ,   default=""    ,   type=a    ,   help="Pretrained config name or path if not the same as model_name"       )
          parser.add_argument(
              "--tokenizer_name"    ,   default=a    ,   type=a    ,   help="Pretrained tokenizer name or path if not the same as model_name"    ,   )
          parser.add_argument(
              "--cache_dir"    ,   default=""    ,   type=a    ,   help="Where do you want to store the pre-trained models downloaded from huggingface.co"    ,   )
          parser.add_argument(
              "--encoder_layerdrop"    ,   type=a    ,   help="Encoder layer dropout probability (Optional). Goes into model.config"    ,   )
          parser.add_argument(
              "--decoder_layerdrop"    ,   type=a    ,   help="Decoder layer dropout probability (Optional). Goes into model.config"    ,   )
          parser.add_argument(
              "--dropout"    ,   type=a    ,   help="Dropout probability (Optional). Goes into model.config"    ,   )
          parser.add_argument(
              "--attention_dropout"    ,   type=a    ,   help="Attention dropout probability (Optional). Goes into model.config"    ,   )
          parser.add_argument("--learning_rate"    ,   default=5e-5    ,   type=a    ,   help="The initial learning rate for Adam."       )
          parser.add_argument(
              "--lr_scheduler"    ,   default="linear"    ,   choices=a    ,   metavar=a    ,   type=a    ,   help="Learning rate scheduler"    ,   )
          parser.add_argument("--weight_decay"    ,   default=0.0    ,   type=a    ,   help="Weight decay if we apply some."       )
          parser.add_argument("--adam_epsilon"    ,   default=1e-8    ,   type=a    ,   help="Epsilon for Adam optimizer."       )
          parser.add_argument("--warmup_steps"    ,   default=0    ,   type=a    ,   help="Linear warmup over warmup_steps."       )
          parser.add_argument("--num_workers"    ,   default=4    ,   type=a    ,   help="kwarg passed to DataLoader"       )
          parser.add_argument("--num_train_epochs"    ,   dest="max_epochs"    ,   default=3    ,   type=a       )
          parser.add_argument("--train_batch_size"    ,   default=32    ,   type=a       )
          parser.add_argument("--eval_batch_size"    ,   default=32    ,   type=a       )
          parser.add_argument("--adafactor"    ,   action="store_true"       )

class    lowercase_	(       pl.Callback  ):


    def   __a				(	self    ,   a    ,   a       ):
          UpperCamelCase__      =							trainer.lr_schedulers[0]["scheduler"]
          UpperCamelCase__      =							{f'''lr_group_{i}''': lr for i, lr in enumerate(lr_scheduler.get_lr()       )}
          pl_module.logger.log_metrics(a       )


    def   __a				(	self    ,   a    ,   a       ):
          rank_zero_info("***** Validation results *****"       )
          UpperCamelCase__      =							trainer.callback_metrics
          # Log results
          for key in sorted(a       ):
                if key not in ["log", "progress_bar"]:
                      rank_zero_info("{} = {}\n".format(a    ,   str(metrics[key]       )       )       )


    def   __a				(	self    ,   a    ,   a       ):
          rank_zero_info("***** Test results *****"       )
          UpperCamelCase__      =							trainer.callback_metrics
          # Log and save results to file
          UpperCamelCase__      =							os.path.join(pl_module.hparams.output_dir    ,   "test_results.txt"       )
          with open(a    ,   "w"       ) as writer:
                for key in sorted(a       ):
                      if key not in ["log", "progress_bar"]:
                            rank_zero_info("{} = {}\n".format(a    ,   str(metrics[key]       )       )       )
                            writer.write("{} = {}\n".format(a    ,   str(metrics[key]       )       )       )







def _UpperCamelCase			(	__A ,     __A       )				->						None:


      '''simple docstring'''



      parser.add_argument(
          "--output_dir" ,     default=__A ,     type=__A ,     required=__A ,     help="The output directory where the model predictions and checkpoints will be written." ,     )
      parser.add_argument(
          "--fp16" ,     action="store_true" ,     help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit" ,     )

      parser.add_argument(
          "--fp16_opt_level" ,     type=__A ,     default="O2" ,     help=(
              "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
              "See details at https://nvidia.github.io/apex/amp.html"
          ) ,     )
      parser.add_argument("--n_tpu_cores" ,     dest="tpu_cores" ,     type=__A       )
      parser.add_argument("--max_grad_norm" ,     dest="gradient_clip_val" ,     default=1.0 ,     type=__A ,     help="Max gradient norm"       )
      parser.add_argument("--do_train" ,     action="store_true" ,     help="Whether to run training."       )
      parser.add_argument("--do_predict" ,     action="store_true" ,     help="Whether to run predictions on the test set."       )
      parser.add_argument(
          "--gradient_accumulation_steps" ,     dest="accumulate_grad_batches" ,     type=__A ,     default=1 ,     help="Number of updates steps to accumulate before performing a backward/update pass." ,     )
      parser.add_argument("--seed" ,     type=__A ,     default=42 ,     help="random seed for initialization"       )
      parser.add_argument(
          "--data_dir" ,     default=__A ,     type=__A ,     required=__A ,     help="The input data dir. Should contain the training files for the CoNLL-2003 NER task." ,     )







def _UpperCamelCase			(	__A ,     __A ,     __A=None ,     __A=True ,     __A=[] ,     __A=None ,     __A=None ,     **__A ,     )				->						Dict:


      '''simple docstring'''



      pl.seed_everything(args.seed       )

      # init model
      UpperCamelCase__      =							Path(model.hparams.output_dir       )
      odir.mkdir(exist_ok=__A       )

      # add custom checkpoints
      if checkpoint_callback is None:
            UpperCamelCase__      =							pl.callbacks.ModelCheckpoint(
                filepath=args.output_dir ,     prefix="checkpoint" ,     monitor="val_loss" ,     mode="min" ,     save_top_k=1       )
      if early_stopping_callback:
            extra_callbacks.append(__A       )
      if logging_callback is None:
            UpperCamelCase__      =							LoggingCallback()

      UpperCamelCase__      =							{}

      # TODO: remove with PyTorch 1.6 since pl uses native amp
      if args.fpaa:
            UpperCamelCase__      =							16
            UpperCamelCase__      =							args.fpaa_opt_level

      if args.gpus > 1:
            UpperCamelCase__      =							"ddp"

      UpperCamelCase__      =							args.accumulate_grad_batches
      UpperCamelCase__      =							extra_train_kwargs.get("accelerator" ,     __A       )
      UpperCamelCase__      =							extra_train_kwargs.get("profiler" ,     __A       )

      UpperCamelCase__      =							pl.Trainer.from_argparse_args(
          __A ,     weights_summary=__A ,     callbacks=[logging_callback] + extra_callbacks ,     logger=__A ,     checkpoint_callback=__A ,     **__A ,     )

      if args.do_train:
            trainer.fit(__A       )

      return trainer









'''simple docstring'''







def _UpperCamelCase			(	__A ,     __A       )				->						int:


      '''simple docstring'''



      return (input_a, input_a).count(0       ) % 2







def _UpperCamelCase			(	)				->						None:


      '''simple docstring'''



      assert xor_gate(0 ,     0       ) == 0
      assert xor_gate(0 ,     1       ) == 1
      assert xor_gate(1 ,     0       ) == 1
      assert xor_gate(1 ,     1       ) == 0


if __name__ == "__main__":
  print(xor_gate(0, 0))
  print(xor_gate(0, 1))





