




import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      CpmAntConfig,
      CpmAntForCausalLM,
      CpmAntModel,
      CpmAntTokenizer,
  )
@require_torch
class       _UpperCamelCase   :
      def __init__(      self :Union[str, Any]			,   lowerCamelCase :List[str]			,   lowerCamelCase :str=2			,   lowerCamelCase :Optional[int]=8			,   lowerCamelCase :str=True			,   lowerCamelCase :List[Any]=False			,   lowerCamelCase :str=False			,   lowerCamelCase :Any=False			,   lowerCamelCase :Union[str, Any]=False			,   lowerCamelCase :List[Any]=99			,   lowerCamelCase :Any=32			,   lowerCamelCase :int=3			,   lowerCamelCase :List[Any]=4			,   lowerCamelCase :Tuple=37			,   lowerCamelCase :Optional[Any]=32			,   lowerCamelCase :Union[str, Any]=128			,   lowerCamelCase :Optional[int]=8			,   lowerCamelCase :Optional[int]=8			,   lowerCamelCase :Dict=8			,   lowerCamelCase :Any=1.0			,   lowerCamelCase :Optional[Any]=True			,   )  ->      List[str]:
       UpperCAmelCase__							=    parent
       UpperCAmelCase__							=    batch_size
       UpperCAmelCase__							=    seq_length
       UpperCAmelCase__							=    is_training
       UpperCAmelCase__							=    use_token_type_ids
       UpperCAmelCase__							=    use_input_mask
       UpperCAmelCase__							=    use_labels
       UpperCAmelCase__							=    use_mc_token_ids
       UpperCAmelCase__							=    vocab_size
       UpperCAmelCase__							=    hidden_size
       UpperCAmelCase__							=    num_hidden_layers
       UpperCAmelCase__							=    num_attention_heads
       UpperCAmelCase__							=    intermediate_size
       UpperCAmelCase__							=    num_buckets
       UpperCAmelCase__							=    max_distance
       UpperCAmelCase__							=    prompt_length
       UpperCAmelCase__							=    prompt_types
       UpperCAmelCase__							=    segment_types
       UpperCAmelCase__							=    init_std
       UpperCAmelCase__							=    return_dict
      def 						UpperCAmelCase_    (      self :List[str]   )  ->      Union[str, Any]:
       UpperCAmelCase__							=    {}
       UpperCAmelCase__							=    ids_tensor([self.batch_size, self.seq_length]			,   self.vocab_size   ).type(torch.intaa   )
       UpperCAmelCase__							=    False

       UpperCAmelCase__							=    self.get_config()

       return (config, input_ids)
      def 						UpperCAmelCase_    (      self :Dict   )  ->      str:
       return CpmAntConfig(
           vocab_size=self.vocab_size			,   hidden_size=self.hidden_size			,   num_hidden_layers=self.num_hidden_layers			,   num_attention_heads=self.num_attention_heads			,   dim_ff=self.intermediate_size			,   position_bias_num_buckets=self.num_buckets			,   position_bias_max_distance=self.max_distance			,   prompt_types=self.prompt_types			,   prompt_length=self.prompt_length			,   segment_types=self.segment_types			,   use_cache=__lowerCamelCase			,   init_std=self.init_std			,   return_dict=self.return_dict			,   )
      def 						UpperCAmelCase_    (      self :Any			,   lowerCamelCase :Any			,   lowerCamelCase :List[str]			,   *lowerCamelCase :List[Any]   )  ->      int:
       UpperCAmelCase__							=    CpmAntModel(config=__lowerCamelCase   )
       model.to(__lowerCamelCase   )
       model.eval()

       UpperCAmelCase__							=    model(**__lowerCamelCase   ).last_hidden_state

       self.parent.assertEqual(hidden_states.shape			,   (self.batch_size, self.seq_length, config.hidden_size)   )
      def 						UpperCAmelCase_    (      self :Tuple			,   lowerCamelCase :str			,   lowerCamelCase :List[str]			,   *lowerCamelCase :Any   )  ->      Optional[Any]:
       UpperCAmelCase__							=    CpmAntForCausalLM(__lowerCamelCase   )
       model.to(__lowerCamelCase   )
       UpperCAmelCase__							=    input_ids["""input_ids"""].to(__lowerCamelCase   )
       model.eval()

       UpperCAmelCase__							=    model(**__lowerCamelCase   )
       self.parent.assertEqual(
           model_output.logits.shape			,   (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)			,   )







      def 						UpperCAmelCase_    (      self :Dict   )  ->      Union[str, Any]:
       UpperCAmelCase__							=    self.prepare_config_and_inputs()
       return config, inputs_dict



@require_torch
class       _UpperCamelCase   (					__snake_case						,							__snake_case						,							unittest.TestCase		):
      UpperCAmelCase_          =		(CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
      UpperCAmelCase_          =		(
          {"""feature-extraction""": CpmAntModel, """text-generation""": CpmAntForCausalLM} if is_torch_available() else {}
      )

      UpperCAmelCase_          =		False
      UpperCAmelCase_          =		False
      UpperCAmelCase_          =		False
      UpperCAmelCase_          =		False
      UpperCAmelCase_          =		False
      def 						UpperCAmelCase_    (      self :Tuple   )  ->      Optional[Any]:
       UpperCAmelCase__							=    CpmAntModelTester(self   )
       UpperCAmelCase__							=    ConfigTester(self			,   config_class=__lowerCamelCase   )
      def 						UpperCAmelCase_    (      self :str   )  ->      Optional[Any]:
       self.config_tester.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()
      def 						UpperCAmelCase_    (      self :Optional[int]   )  ->      str:
       unittest.skip("CPMAnt doesn't support input_embeds."   )(self.test_inputs_embeds   )
      def 						UpperCAmelCase_    (      self :List[Any]   )  ->      Optional[int]:
       unittest.skip(
           "CPMAnt doesn't support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\\n                 So is attentions. We strongly recommand you use loss to tune model."   )(self.test_retain_grad_hidden_states_attentions   )
      def 						UpperCAmelCase_    (      self :str   )  ->      Tuple:
       UpperCAmelCase__							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_cpmant_model(__lowerCamelCase			,   __lowerCamelCase   )







      def 						UpperCAmelCase_    (      self :Dict   )  ->      List[Any]:
       UpperCAmelCase__							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_lm_head_model(__lowerCamelCase			,   __lowerCamelCase   )



@require_torch
class       _UpperCamelCase   (					unittest.TestCase		):
      @tooslow
      def 						UpperCAmelCase_    (      self :List[str]   )  ->      int:
       UpperCAmelCase__							=    """今天天气真好！"""
       UpperCAmelCase__							=    """openbmb/cpm-ant-10b"""
       UpperCAmelCase__							=    CpmAntModel.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    CpmAntTokenizer.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    tokenizer(__lowerCamelCase			,   return_tensors="pt"   )
       UpperCAmelCase__							=    model(**__lowerCamelCase   ).last_hidden_state

       UpperCAmelCase__							=    torch.tensor(
           [[[6.17_08, 5.92_44, 1.08_35], [6.52_07, 6.28_93, -11.33_24], [-1.01_07, -0.05_76, -5.95_77]]]			,   )
       self.assertTrue(torch.allclose(hidden_states[:, :3, :3]			,   __lowerCamelCase			,   atol=1e-2   )   )



@require_torch
class       _UpperCamelCase   (					unittest.TestCase		):
      @tooslow
      def 						UpperCAmelCase_    (      self :Optional[int]   )  ->      Optional[Any]:
       UpperCAmelCase__							=    """今天天气真好！"""
       UpperCAmelCase__							=    """openbmb/cpm-ant-10b"""
       UpperCAmelCase__							=    CpmAntForCausalLM.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    CpmAntTokenizer.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    tokenizer(__lowerCamelCase			,   return_tensors="pt"   )
       UpperCAmelCase__							=    model(**__lowerCamelCase   ).logits

       UpperCAmelCase__							=    torch.tensor(
           [[[-6.42_67, -6.40_83, -6.39_58], [-5.88_02, -5.94_47, -5.78_11], [-5.38_96, -5.48_20, -5.42_95]]]			,   )
       self.assertTrue(torch.allclose(hidden_states[:, :3, :3]			,   __lowerCamelCase			,   atol=1e-2   )   )
      @tooslow
      def 						UpperCAmelCase_    (      self :Optional[Any]   )  ->      Any:
       UpperCAmelCase__							=    """openbmb/cpm-ant-10b"""
       UpperCAmelCase__							=    CpmAntForCausalLM.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    CpmAntTokenizer.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    """今天天气不错，"""
       UpperCAmelCase__							=    """今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的"""
       UpperCAmelCase__							=    tokenizer(__lowerCamelCase			,   return_tensors="pt"   )
       UpperCAmelCase__							=    model.generate(**__lowerCamelCase   )
       UpperCAmelCase__							=    tokenizer.batch_decode(__lowerCamelCase   )
       self.assertEqual(__lowerCamelCase			,   __lowerCamelCase   )







      @tooslow
      def 						UpperCAmelCase_    (      self :Any   )  ->      Optional[Any]:
       UpperCAmelCase__							=    """openbmb/cpm-ant-10b"""
       UpperCAmelCase__							=    CpmAntForCausalLM.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    CpmAntTokenizer.from_pretrained(__lowerCamelCase   )
       UpperCAmelCase__							=    ["""今天天气不错，""", """新年快乐，万事如意！"""]
       UpperCAmelCase__							=    [
           """今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的""",
           """新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的""",
       ]
       UpperCAmelCase__							=    tokenizer(__lowerCamelCase			,   return_tensors="pt"			,   padding=__lowerCamelCase   )
       UpperCAmelCase__							=    model.generate(**__lowerCamelCase   )
       UpperCAmelCase__							=    tokenizer.batch_decode(__lowerCamelCase   )
       self.assertEqual(__lowerCamelCase			,   __lowerCamelCase   )






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


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

__lowerCAmelCase    :  Dict										= {
    '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 				lowerCamelCase			(							__snake_case					):
      __lowerCamelCase							=					'bigbird_pegasus'
      __lowerCamelCase							=					['past_key_values']
      __lowerCamelCase							=					{
          'num_attention_heads': 'encoder_attention_heads',
          'hidden_size': 'd_model',
          'attention_probs_dropout_prob': 'attention_dropout',
      }






      def __init__(      self  ,		__lowerCamelCase=9_61_03  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=16  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=True  ,		__lowerCamelCase=True  ,		__lowerCamelCase="gelu_new"  ,		__lowerCamelCase=10_24  ,		__lowerCamelCase=0.1  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.02  ,		__lowerCamelCase=2  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=True  ,		__lowerCamelCase=0  ,		__lowerCamelCase=2  ,		__lowerCamelCase=1  ,		__lowerCamelCase="block_sparse"  ,		__lowerCamelCase=64  ,		__lowerCamelCase=3  ,		__lowerCamelCase=False  ,		**__lowerCamelCase  ,		)     ->				Dict:


          '''simple docstring'''







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

          # extra config
          snake_case:						Union[str, Any]         =   attention_type
          snake_case:						Optional[int]         =   block_size
          snake_case:						Optional[int]         =   num_random_blocks
          snake_case:						List[Any]         =   use_bias

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





class 				lowerCamelCase			(							__snake_case					):






      @property
      def 			lowerCAmelCase_   (      self						)     ->				Mapping[str, Mapping[int, str]]:


          '''simple docstring'''







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

              if self.use_past:
                  snake_case:						List[Any]         =   {0: """batch"""}
                  snake_case:						Optional[int]         =   {0: """batch""", 1: """past_decoder_sequence + sequence"""}
              else:
                  snake_case:						List[Any]         =   {0: """batch""", 1: """decoder_sequence"""}
                  snake_case:						Union[str, Any]         =   {0: """batch""", 1: """decoder_sequence"""}

              if self.use_past:
                  self.fill_with_past_key_values_(__lowerCamelCase  ,		direction="""inputs"""						)
          elif self.task == "causal-lm":
              # TODO: figure this case out.
              snake_case:						List[str]         =   OrderedDict(
                  [
                      ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
                      ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
                  ]						)
              if self.use_past:
                  snake_case    , snake_case:						str         =   self.num_layers
                  for i in range(__lowerCamelCase						):
                      snake_case:						Any         =   {0: """batch""", 2: """past_sequence + sequence"""}
                      snake_case:						str         =   {0: """batch""", 2: """past_sequence + sequence"""}
          else:
              snake_case:						str         =   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 			lowerCAmelCase_   (      self						)     ->				Mapping[str, Mapping[int, str]]:


          '''simple docstring'''







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






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						List[Any]         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)

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

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

              snake_case:						Tuple         =   torch.cat(
                  [common_inputs["""decoder_attention_mask"""], torch.ones(__lowerCamelCase  ,		__lowerCamelCase						)]  ,		dim=1						)

              snake_case:						Tuple         =   []
              # If the number of encoder and decoder layers are present in the model configuration, both are considered
              snake_case    , snake_case:						Union[str, Any]         =   self.num_layers
              snake_case:						List[str]         =   min(__lowerCamelCase  ,		__lowerCamelCase						)
              snake_case:						List[str]         =   max(__lowerCamelCase  ,		__lowerCamelCase						) - min_num_layers
              snake_case:						Union[str, Any]         =   """encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

              for _ in range(__lowerCamelCase						):
                  common_inputs["past_key_values"].append(
                      (
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                      )						)
              # TODO: test this.
              snake_case:						Dict         =   encoder_shape if remaining_side_name == """encoder""" else decoder_shape
              for _ in range(__lowerCamelCase  ,		__lowerCamelCase						):
                  common_inputs["past_key_values"].append((torch.zeros(__lowerCamelCase						), torch.zeros(__lowerCamelCase						))						)
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						Any         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)

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

              snake_case:						int         =   common_inputs["""attention_mask"""].dtype
              snake_case:						Union[str, Any]         =   torch.cat(
                  [common_inputs["""attention_mask"""], torch.ones(__lowerCamelCase  ,		__lowerCamelCase  ,		dtype=__lowerCamelCase						)]  ,		dim=1						)
              snake_case:						Dict         =   [
                  (torch.zeros(__lowerCamelCase						), torch.zeros(__lowerCamelCase						)) for _ in range(__lowerCamelCase						)
              ]
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						str         =   compute_effective_axis_dimension(
              __lowerCamelCase  ,		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
          snake_case:						str         =   tokenizer.num_special_tokens_to_add(__lowerCamelCase						)
          snake_case:						int         =   compute_effective_axis_dimension(
              __lowerCamelCase  ,		fixed_dimension=OnnxConfig.default_fixed_sequence  ,		num_token_to_add=__lowerCamelCase						)

          # Generate dummy inputs according to compute batch and sequence
          snake_case:						Dict         =   [""" """.join([tokenizer.unk_token]						) * seq_length] * batch_size
          snake_case:						Any         =   dict(tokenizer(__lowerCamelCase  ,		return_tensors=__lowerCamelCase						)						)
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          if self.task in ["default", "seq2seq-lm"]:
              snake_case:						Union[str, Any]         =   self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)

          elif self.task == "causal-lm":
              snake_case:						Union[str, Any]         =   self._generate_dummy_inputs_for_causal_lm(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)
          else:
              snake_case:						int         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)

          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)     ->				List[Any]:


          '''simple docstring'''







          if self.task in ["default", "seq2seq-lm"]:
              snake_case:						Optional[int]         =   super()._flatten_past_key_values_(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)
          else:
              snake_case:						List[str]         =   super(__lowerCamelCase  ,		self						)._flatten_past_key_values_(
                  __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)


