





'''simple docstring'''

import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
  from .tokenization_big_bird import BigBirdTokenizer
else:
  a        =						None

a        =						logging.get_logger(__name__)
a        =						{"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}

a        =						{
    "vocab_file": {
        "google/bigbird-roberta-base": "https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model",
        "google/bigbird-roberta-large": (
            "https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model"
        ),
        "google/bigbird-base-trivia-itc": (
            "https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model"
        ),
    },
    "tokenizer_file": {
        "google/bigbird-roberta-base": (
            "https://huggingface.co/google/bigbird-roberta-base/resolve/main/tokenizer.json"
        ),
        "google/bigbird-roberta-large": (
            "https://huggingface.co/google/bigbird-roberta-large/resolve/main/tokenizer.json"
        ),
        "google/bigbird-base-trivia-itc": (
            "https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/tokenizer.json"
        ),
    },
}

a        =						{
    "google/bigbird-roberta-base": 4096,
    "google/bigbird-roberta-large": 4096,
    "google/bigbird-base-trivia-itc": 4096,
}


a        =						"▁"







class __a (   __SCREAMING_SNAKE_CASE			):
   __UpperCamelCase   : Optional[int]	      =	VOCAB_FILES_NAMES
   __UpperCamelCase   : Tuple	      =	PRETRAINED_VOCAB_FILES_MAP
   __UpperCamelCase   : int	      =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   __UpperCamelCase   : List[Any]	      =	BigBirdTokenizer
   __UpperCamelCase   : Tuple	      =	['input_ids', 'attention_mask']
   __UpperCamelCase   : List[Any]	      =	[]





   def __init__(					self				:			str				,lowerCamelCase				:			Any=None				,lowerCamelCase				:			Optional[Any]=None				,lowerCamelCase				:			str="<unk>"				,lowerCamelCase				:			Union[str, Any]="<s>"				,lowerCamelCase				:			Optional[Any]="</s>"				,lowerCamelCase				:			Any="<pad>"				,lowerCamelCase				:			str="[SEP]"				,lowerCamelCase				:			Dict="[MASK]"				,lowerCamelCase				:			int="[CLS]"				,**lowerCamelCase				:			List[Any]				,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else bos_token
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else eos_token
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else unk_token
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else pad_token
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else cls_token
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else sep_token

      # Mask token behave like a normal word, i.e. include the space before it
      __SCREAMING_SNAKE_CASE      							=       AddedToken(_a				,lstrip=_a				,rstrip=_a    ) if isinstance(_a				,_a    ) else mask_token

      super().__init__(
          _a				,tokenizer_file=_a				,bos_token=_a				,eos_token=_a				,unk_token=_a				,sep_token=_a				,pad_token=_a				,cls_token=_a				,mask_token=_a				,**_a				,)

      __SCREAMING_SNAKE_CASE      							=       vocab_file
      __SCREAMING_SNAKE_CASE      							=       False if not self.vocab_file else True





   def      UpperCAmelCase__     (					self				:			Any				,lowerCamelCase				:			List[int]				,lowerCamelCase				:			Optional[List[int]] = None    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       [self.sep_token_id]
      __SCREAMING_SNAKE_CASE      							=       [self.cls_token_id]
      if token_ids_a is None:
         return cls + token_ids_a + sep
      return cls + token_ids_a + sep + token_ids_a + sep





   def      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			List[int]				,lowerCamelCase				:			Optional[List[int]] = None				,lowerCamelCase				:			bool = False    ):

      '''simple docstring'''

      if already_has_special_tokens:
         if token_ids_a is not None:
            raise ValueError(
                """You should not supply a second sequence if the provided sequence of """
                """ids is already formatted with special tokens for the model."""    )
         return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

      if token_ids_a is None:
         return [1] + ([0] * len(_a    )) + [1]
      return [1] + ([0] * len(_a    )) + [1] + ([0] * len(_a    )) + [1]





   def      UpperCAmelCase__     (					self				:			str				,lowerCamelCase				:			List[int]				,lowerCamelCase				:			Optional[List[int]] = None    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       [self.sep_token_id]
      __SCREAMING_SNAKE_CASE      							=       [self.cls_token_id]

      if token_ids_a is None:
         return len(cls + token_ids_a + sep    ) * [0]
      return len(cls + token_ids_a + sep    ) * [0] + len(token_ids_a + sep    ) * [1]





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,lowerCamelCase				:			str				,lowerCamelCase				:			Optional[str] = None    ):

      '''simple docstring'''

      if not self.can_save_slow_tokenizer:
         raise ValueError(
             """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
             """tokenizer."""    )

      if not os.path.isdir(_a    ):
         logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""    )
         return
      __SCREAMING_SNAKE_CASE      							=       os.path.join(
          _a				,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]    )

      if os.path.abspath(self.vocab_file    ) != os.path.abspath(_a    ):
         copyfile(self.vocab_file				,_a    )

      return (out_vocab_file,)












'''simple docstring'''

import math
from enum import Enum
from typing import Optional, Union

from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR

from .utils import logging


a        =						logging.get_logger(__name__)







class __a (   _snake_case			):
   __UpperCamelCase   : int	      =	'linear'
   __UpperCamelCase   : Tuple	      =	'cosine'
   __UpperCamelCase   : Tuple	      =	'cosine_with_restarts'
   __UpperCamelCase   : List[Any]	      =	'polynomial'
   __UpperCamelCase   : Optional[Any]	      =	'constant'
   __UpperCamelCase   : Optional[int]	      =	'constant_with_warmup'
   __UpperCamelCase   : List[Any]	      =	'piecewise_constant'





def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					int:

   '''simple docstring'''







   return LambdaLR(__UpperCAmelCase							,	lambda __UpperCAmelCase      : 1							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					List[Any]:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1.0							,	__UpperCAmelCase      )      )
      return 1.0

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = -1      )						->					int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       {}
   __SCREAMING_SNAKE_CASE      							=       step_rules.split(""","""      )
   for rule_str in rule_list[:-1]:
      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       rule_str.split(""":"""      )
      __SCREAMING_SNAKE_CASE      							=       int(__UpperCAmelCase      )
      __SCREAMING_SNAKE_CASE      							=       float(__UpperCAmelCase      )
      __SCREAMING_SNAKE_CASE      							=       value
   __SCREAMING_SNAKE_CASE      							=       float(rule_list[-1]      )

   def create_rules_function(__UpperCAmelCase							,	__UpperCAmelCase      ):
      def rule_func(__UpperCAmelCase      ) -> float:
         __SCREAMING_SNAKE_CASE      							=       sorted(rules_dict.keys()      )
         for i, sorted_step in enumerate(__UpperCAmelCase      ):
            if steps < sorted_step:
               return rules_dict[sorted_steps[i]]
         return last_lr_multiple

      return rule_func

   __SCREAMING_SNAKE_CASE      							=       create_rules_function(__UpperCAmelCase							,	__UpperCAmelCase      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase=-1      )						->					int:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      return max(
          0.0							,	float(num_training_steps - current_step      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = 0.5							,	__UpperCAmelCase = -1      )						->					Dict:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      __SCREAMING_SNAKE_CASE      							=       float(current_step - num_warmup_steps      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )
      return max(0.0							,	0.5 * (1.0 + math.cos(math.pi * float(__UpperCAmelCase      ) * 2.0 * progress      ))      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = 1							,	__UpperCAmelCase = -1      )						->					Tuple:

   '''simple docstring'''







   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      __SCREAMING_SNAKE_CASE      							=       float(current_step - num_warmup_steps      ) / float(max(1							,	num_training_steps - num_warmup_steps      )      )
      if progress >= 1.0:
         return 0.0
      return max(0.0							,	0.5 * (1.0 + math.cos(math.pi * ((float(__UpperCAmelCase      ) * progress) % 1.0)      ))      )

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase=1e-7							,	__UpperCAmelCase=1.0							,	__UpperCAmelCase=-1      )						->					Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       optimizer.defaults["""lr"""]
   if not (lr_init > lr_end):
      raise ValueError(f"""lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})"""      )

   def lr_lambda(__UpperCAmelCase      ):
      if current_step < num_warmup_steps:
         return float(__UpperCAmelCase      ) / float(max(1							,	__UpperCAmelCase      )      )
      elif current_step > num_training_steps:
         return lr_end / lr_init  # as LambdaLR multiplies by lr_init
      else:
         __SCREAMING_SNAKE_CASE      							=       lr_init - lr_end
         __SCREAMING_SNAKE_CASE      							=       num_training_steps - num_warmup_steps
         __SCREAMING_SNAKE_CASE      							=       1 - (current_step - num_warmup_steps) / decay_steps
         __SCREAMING_SNAKE_CASE      							=       lr_range * pct_remaining**power + lr_end
         return decay / lr_init  # as LambdaLR multiplies by lr_init

   return LambdaLR(__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )


a        =						{
    SchedulerType.LINEAR: get_linear_schedule_with_warmup,
    SchedulerType.COSINE: get_cosine_schedule_with_warmup,
    SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup,
    SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup,
    SchedulerType.CONSTANT: get_constant_schedule,
    SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup,
    SchedulerType.PIECEWISE_CONSTANT: get_piecewise_constant_schedule,
}







def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = None							,	__UpperCAmelCase = None							,	__UpperCAmelCase = None							,	__UpperCAmelCase = 1							,	__UpperCAmelCase = 1.0							,	__UpperCAmelCase = -1							,	)						->					str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       SchedulerType(__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       TYPE_TO_SCHEDULER_FUNCTION[name]
   if name == SchedulerType.CONSTANT:
      return schedule_func(__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   if name == SchedulerType.PIECEWISE_CONSTANT:
      return schedule_func(__UpperCAmelCase							,	step_rules=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   # All other schedulers require `num_warmup_steps`
   if num_warmup_steps is None:
      raise ValueError(f"""{name} requires `num_warmup_steps`, please provide that argument."""      )

   if name == SchedulerType.CONSTANT_WITH_WARMUP:
      return schedule_func(__UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )

   # All other schedulers require `num_training_steps`
   if num_training_steps is None:
      raise ValueError(f"""{name} requires `num_training_steps`, please provide that argument."""      )

   if name == SchedulerType.COSINE_WITH_RESTARTS:
      return schedule_func(
          __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	num_cycles=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase							,	)

   if name == SchedulerType.POLYNOMIAL:
      return schedule_func(
          __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	power=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase							,	)

   return schedule_func(
       __UpperCAmelCase							,	num_warmup_steps=__UpperCAmelCase							,	num_training_steps=__UpperCAmelCase							,	last_epoch=__UpperCAmelCase      )





