




'''simple docstring'''






from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


lowercase	:      Optional[int]				=       logging.get_logger(__name__)

lowercase	:      List[Any]				=       {
    '''google/bigbird-pegasus-large-arxiv''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-pubmed''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-bigpatent''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'''
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}

class   SCREAMING_SNAKE_CASE_		(       lowerCamelCase_				):
 __snake_case	:     Union[str, Any]			   =      "bigbird_pegasus"
 __snake_case	:     str			   =      ["past_key_values"]
 __snake_case	:     Dict			   =      {
     "num_attention_heads": "encoder_attention_heads",
     "hidden_size": "d_model",
     "attention_probs_dropout_prob": "attention_dropout",
 }



 def __init__(  self			,		A=96103			,		A=4096			,		A=16			,		A=4096			,		A=16			,		A=16			,		A=4096			,		A=16			,		A=0.0			,		A=0.0			,		A=True			,		A=True			,		A="gelu_new"			,		A=1024			,		A=0.1			,		A=0.0			,		A=0.0			,		A=0.0_2			,		A=2			,		A=0.0			,		A=True			,		A=0			,		A=2			,		A=1			,		A="block_sparse"			,		A=64			,		A=3			,		A=False			,		**A			,		):






        '''simple docstring'''




        lowercase  :		Optional[Any]						=      vocab_size
        lowercase  :		Optional[int]						=      max_position_embeddings
        lowercase  :		List[str]						=      d_model
        lowercase  :		Tuple						=      encoder_ffn_dim
        lowercase  :		Union[str, Any]						=      encoder_layers
        lowercase  :		Optional[int]						=      encoder_attention_heads
        lowercase  :		Union[str, Any]						=      decoder_ffn_dim
        lowercase  :		Dict						=      decoder_layers
        lowercase  :		Union[str, Any]						=      decoder_attention_heads
        lowercase  :		Tuple						=      dropout
        lowercase  :		str						=      attention_dropout
        lowercase  :		str						=      activation_dropout
        lowercase  :		Union[str, Any]						=      activation_function
        lowercase  :		str						=      init_std
        lowercase  :		Dict						=      encoder_layerdrop
        lowercase  :		Dict						=      decoder_layerdrop
        lowercase  :		Tuple						=      classifier_dropout
        lowercase  :		Any						=      use_cache
        lowercase  :		Dict						=      encoder_layers
        lowercase  :		List[Any]						=      scale_embedding  # scale factor will be sqrt(d_model) if True

        # extra config
        lowercase  :		str						=      attention_type
        lowercase  :		Optional[int]						=      block_size
        lowercase  :		List[Any]						=      num_random_blocks
        lowercase  :		Dict						=      use_bias

        super().__init__(
            pad_token_id=A			,		bos_token_id=A			,		eos_token_id=A			,		is_encoder_decoder=A			,		decoder_start_token_id=A			,		**A			,		)






class   SCREAMING_SNAKE_CASE_		(       lowerCamelCase_				):



 @property
 def    SCREAMING_SNAKE_CASE(  self ):






        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
               lowercase  :		Any						=      OrderedDict(
                   [
                       ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                       ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ] )

               if self.use_past:
                      lowercase  :		List[Any]						=      {0: '''batch'''}
                      lowercase  :		Optional[Any]						=      {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
               else:
                      lowercase  :		Optional[int]						=      {0: '''batch''', 1: '''decoder_sequence'''}
                      lowercase  :		Optional[Any]						=      {0: '''batch''', 1: '''decoder_sequence'''}

               if self.use_past:
                      self.fill_with_past_key_values_(A			,		direction='''inputs''' )
        elif self.task == "causal-lm":
               # TODO: figure this case out.
               lowercase  :		str						=      OrderedDict(
                   [
                       ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                       ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ] )
               if self.use_past:
                      lowercase  :		Tuple						=      self.num_layers
                      for i in range(A ):
                             lowercase  :		str						=      {0: '''batch''', 2: '''past_sequence + sequence'''}
                             lowercase  :		Tuple						=      {0: '''batch''', 2: '''past_sequence + sequence'''}
        else:
               lowercase  :		Any						=      OrderedDict(
                   [
                       ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                       ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                       ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
                       ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
                   ] )

        return common_inputs



 @property
 def    SCREAMING_SNAKE_CASE(  self ):






        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
               lowercase  :		int						=      super().outputs
        else:
               lowercase  :		Optional[Any]						=      super(A			,		self ).outputs
               if self.use_past:
                      lowercase  :		Tuple						=      self.num_layers
                      for i in range(A ):
                             lowercase  :		Optional[int]						=      {0: '''batch''', 2: '''past_sequence + sequence'''}
                             lowercase  :		Union[str, Any]						=      {0: '''batch''', 2: '''past_sequence + sequence'''}
        return common_outputs



 def    SCREAMING_SNAKE_CASE(  self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		):






        '''simple docstring'''




        lowercase  :		Optional[int]						=      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A			,		A			,		A			,		A			,		A )

        # Generate decoder inputs
        lowercase  :		int						=      seq_length if not self.use_past else 1
        lowercase  :		Dict						=      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A			,		A			,		A			,		A			,		A )
        lowercase  :		Union[str, Any]						=      {f"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
        lowercase  :		List[Any]						=      dict(**A			,		**A )

        if self.use_past:
               if not is_torch_available():
                      raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' )
               else:
                      import torch
               lowercase  :		Dict						=      common_inputs['''input_ids'''].shape
               lowercase  :		str						=      common_inputs['''decoder_input_ids'''].shape[1]
               lowercase  :		Optional[Any]						=      self.num_attention_heads
               lowercase  :		Any						=      (
                   batch,
                   num_encoder_attention_heads,
                   encoder_seq_length,
                   self._config.hidden_size // num_encoder_attention_heads,
               )
               lowercase  :		Tuple						=      decoder_seq_length + 3
               lowercase  :		List[Any]						=      (
                   batch,
                   num_decoder_attention_heads,
                   decoder_past_length,
                   self._config.hidden_size // num_decoder_attention_heads,
               )

               lowercase  :		List[str]						=      torch.cat(
                   [common_inputs['''decoder_attention_mask'''], torch.ones(A			,		A )]			,		dim=1 )

               lowercase  :		Any						=      []
               # If the number of encoder and decoder layers are present in the model configuration, both are considered
               lowercase  :		Optional[int]						=      self.num_layers
               lowercase  :		Optional[Any]						=      min(A			,		A )
               lowercase  :		Optional[Any]						=      max(A			,		A ) - min_num_layers
               lowercase  :		List[str]						=      '''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

               for _ in range(A ):
                      common_inputs["past_key_values"].append(
                          (
                              torch.zeros(A ),
                              torch.zeros(A ),
                              torch.zeros(A ),
                              torch.zeros(A ),
                          ) )
               # TODO: test this.
               lowercase  :		Optional[Any]						=      encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
               for _ in range(A			,		A ):
                      common_inputs["past_key_values"].append((torch.zeros(A ), torch.zeros(A )) )
        return common_inputs



 def    SCREAMING_SNAKE_CASE(  self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		):






        '''simple docstring'''




        lowercase  :		int						=      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A			,		A			,		A			,		A			,		A )

        if self.use_past:
               if not is_torch_available():
                      raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' )
               else:
                      import torch
               lowercase  :		int						=      common_inputs['''input_ids'''].shape
               # Not using the same length for past_key_values
               lowercase  :		Any						=      seqlen + 2
               lowercase  :		List[str]						=      self.num_layers
               lowercase  :		Any						=      self.num_attention_heads
               lowercase  :		Union[str, Any]						=      (
                   batch,
                   num_encoder_attention_heads,
                   past_key_values_length,
                   self._config.hidden_size // num_encoder_attention_heads,
               )

               lowercase  :		List[Any]						=      common_inputs['''attention_mask'''].dtype
               lowercase  :		Dict						=      torch.cat(
                   [common_inputs['''attention_mask'''], torch.ones(A			,		A			,		dtype=A )]			,		dim=1 )
               lowercase  :		Optional[int]						=      [
                   (torch.zeros(A ), torch.zeros(A )) for _ in range(A )
               ]
        return common_inputs



 def    SCREAMING_SNAKE_CASE(  self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		):






        '''simple docstring'''




        lowercase  :		Optional[int]						=      compute_effective_axis_dimension(
            A			,		fixed_dimension=OnnxConfig.default_fixed_batch			,		num_token_to_add=0 )

        # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
        lowercase  :		Optional[Any]						=      tokenizer.num_special_tokens_to_add(A )
        lowercase  :		Union[str, Any]						=      compute_effective_axis_dimension(
            A			,		fixed_dimension=OnnxConfig.default_fixed_sequence			,		num_token_to_add=A )

        # Generate dummy inputs according to compute batch and sequence
        lowercase  :		Optional[Any]						=      [''' '''.join([tokenizer.unk_token] ) * seq_length] * batch_size
        lowercase  :		Union[str, Any]						=      dict(tokenizer(A			,		return_tensors=A ) )
        return common_inputs



 def    SCREAMING_SNAKE_CASE(  self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		):






        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
               lowercase  :		Dict						=      self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                   A			,		batch_size=A			,		seq_length=A			,		is_pair=A			,		framework=A )

        elif self.task == "causal-lm":
               lowercase  :		Optional[int]						=      self._generate_dummy_inputs_for_causal_lm(
                   A			,		batch_size=A			,		seq_length=A			,		is_pair=A			,		framework=A )
        else:
               lowercase  :		str						=      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                   A			,		batch_size=A			,		seq_length=A			,		is_pair=A			,		framework=A )

        return common_inputs





 def    SCREAMING_SNAKE_CASE(  self			,		A			,		A			,		A			,		A ):






        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
               lowercase  :		Optional[int]						=      super()._flatten_past_key_values_(A			,		A			,		A			,		A )
        else:
               lowercase  :		Optional[int]						=      super(A			,		self )._flatten_past_key_values_(
                   A			,		A			,		A			,		A )










'''simple docstring'''






class   SCREAMING_SNAKE_CASE_		:



 def __init__(  self ):






        '''simple docstring'''




        lowercase  :		List[str]						=      [0, 1]





 def    SCREAMING_SNAKE_CASE(  self   ,		A ):






        '''simple docstring'''




        if (difference := index - (len(self.sequence ) - 2)) >= 1:
               for _ in range(A ):
                      self.sequence.append(self.sequence[-1] + self.sequence[-2] )
        return self.sequence[:index]






def 		a_( )				->None:






       '''simple docstring'''




       print(
           '''Fibonacci Series Using Dynamic Programming\n'''   ,				'''Enter the index of the Fibonacci number you want to calculate '''   ,				'''in the prompt below. (To exit enter exit or Ctrl-C)\n'''   ,				sep=''''''   ,				)
       lowercase  :		Optional[int]						=      Fibonacci()

       while True:
              lowercase  :		str						=      input('''>> '''      )
              if prompt in {"exit", "quit"}:
                     break

              try:
                     lowercase  :		int						=      int(lowerCamelCase      )
              except ValueError:
                     print('''Enter a number or \'exit\''''      )
                     continue

              print(fibonacci.get(lowerCamelCase      )      )


if __name__ == "__main__":
      main()




