





'''simple docstring'''


import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_SCREAMING_SNAKE_CASE									=				get_tests_dir("fixtures/test_sentencepiece_no_bos.model")

@require_sentencepiece
@require_tokenizers
class  lowerCAmelCase_		(		__magic_name__    ,unittest.TestCase		):
 __lowerCamelCase    :				int								=       PegasusTokenizer
 __lowerCamelCase    :				Union[str, Any]								=       PegasusTokenizerFast
 __lowerCamelCase    :				Tuple								=       True
 __lowerCamelCase    :				Dict								=       True




 def 				_snake_case (						self		)     ->				Tuple:
     super().setUp()

     # We have a SentencePiece fixture for testing
     _lowerCAmelCase						      =   PegasusTokenizer(_lowerCAmelCase		)
     tokenizer.save_pretrained(self.tmpdirname		)




 @cached_property
 def 				_snake_case (						self		)     ->				Optional[int]:
     return PegasusTokenizer.from_pretrained("google/pegasus-large"		)




 def 				_snake_case (						self      ,  **_lowerCAmelCase		)     ->				PegasusTokenizer:
     return PegasusTokenizer.from_pretrained(self.tmpdirname      ,  **_lowerCAmelCase		)




 def 				_snake_case (						self      ,  _lowerCAmelCase		)     ->				str:
     return ("This is a test", "This is a test")




 def 				_snake_case (						self		)     ->				str:
     _lowerCAmelCase						      =   "</s>"
     _lowerCAmelCase						      =   1

     self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowerCAmelCase		)      ,  _lowerCAmelCase		)
     self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowerCAmelCase		)      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				List[Any]:
     _lowerCAmelCase						      =   list(self.get_tokenizer().get_vocab().keys()		)

     self.assertEqual(vocab_keys[0]      ,  "<pad>"		)
     self.assertEqual(vocab_keys[1]      ,  "</s>"		)
     self.assertEqual(vocab_keys[-1]      ,  "v"		)
     self.assertEqual(len(_lowerCAmelCase		)      ,  1103		)




 def 				_snake_case (						self		)     ->				Optional[int]:
     self.assertEqual(self.get_tokenizer().vocab_size      ,  1103		)




 def 				_snake_case (						self		)     ->				List[str]:
     _lowerCAmelCase						      =   self.rust_tokenizer_class.from_pretrained(self.tmpdirname		)
     _lowerCAmelCase						      =   self.tokenizer_class.from_pretrained(self.tmpdirname		)
     _lowerCAmelCase						      =   (
         "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important"
         " </s> <pad> <pad> <pad>"
     )
     _lowerCAmelCase						      =   rust_tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase      ,  add_special_tokens=_lowerCAmelCase		).input_ids[0]
     _lowerCAmelCase						      =   py_tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase      ,  add_special_tokens=_lowerCAmelCase		).input_ids[0]
     self.assertListEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Dict:
     _lowerCAmelCase						      =   self._large_tokenizer
     # <mask_1> masks whole sentence while <mask_2> masks single word
     _lowerCAmelCase						      =   "<mask_1> To ensure a <mask_2> flow of bank resolutions."
     _lowerCAmelCase						      =   [2, 413, 615, 114, 3, 1971, 113, 1679, 10710, 107, 1]
     _lowerCAmelCase						      =   tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase		).input_ids[0]
     self.assertListEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				int:
     _lowerCAmelCase						      =   self._large_tokenizer
     # The tracebacks for the following asserts are **better** without messages or self.assertEqual
     assert tokenizer.vocab_size == 96103
     assert tokenizer.pad_token_id == 0
     assert tokenizer.eos_token_id == 1
     assert tokenizer.offset == 103
     assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
     assert tokenizer.unk_token == "<unk>"
     assert tokenizer.model_max_length == 1024
     _lowerCAmelCase						      =   "To ensure a smooth flow of bank resolutions."
     _lowerCAmelCase						      =   [413, 615, 114, 2291, 1971, 113, 1679, 10710, 107, 1]
     _lowerCAmelCase						      =   tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase		).input_ids[0]
     self.assertListEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)
     assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]		) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]




 @require_torch
 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   ["This is going to be way too long." * 150, "short example"]
     _lowerCAmelCase						      =   ["not super long but more than 5 tokens", "tiny"]
     _lowerCAmelCase						      =   self._large_tokenizer(_lowerCAmelCase      ,  padding=_lowerCAmelCase      ,  truncation=_lowerCAmelCase      ,  return_tensors="pt"		)
     _lowerCAmelCase						      =   self._large_tokenizer(
         text_target=_lowerCAmelCase      ,  max_length=5      ,  padding=_lowerCAmelCase      ,  truncation=_lowerCAmelCase      ,  return_tensors="pt"		)

     assert batch.input_ids.shape == (2, 1024)
     assert batch.attention_mask.shape == (2, 1024)
     assert targets["input_ids"].shape == (2, 5)
     assert len(_lowerCAmelCase		) == 2  # input_ids, attention_mask.





 @slow
 def 				_snake_case (						self		)     ->				Dict:
     # fmt: off
     _lowerCAmelCase						      =   {"input_ids": [[38979, 143, 18485, 606, 130, 26669, 87686, 121, 54189, 1129, 111, 26669, 87686, 121, 9114, 14787, 121, 13249, 158, 592, 956, 121, 14621, 31576, 143, 62613, 108, 9688, 930, 43430, 11562, 62613, 304, 108, 11443, 897, 108, 9314, 17415, 63399, 108, 11443, 7614, 18316, 118, 4284, 7148, 12430, 143, 1400, 25703, 158, 111, 4284, 7148, 11772, 143, 21297, 1064, 158, 122, 204, 3506, 1754, 1133, 14787, 1581, 115, 33224, 4482, 111, 1355, 110, 29173, 317, 50833, 108, 20147, 94665, 111, 77198, 107, 1], [110, 62613, 117, 638, 112, 1133, 121, 20098, 1355, 79050, 13872, 135, 1596, 53541, 1352, 141, 13039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 18289, 17780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
     # fmt: on

     self.tokenizer_integration_test_util(
         expected_encoding=_lowerCAmelCase      ,  model_name="google/bigbird-pegasus-large-arxiv"      ,  revision="ba85d0851d708441f91440d509690f1ab6353415"      ,  )







@require_sentencepiece
@require_tokenizers
class  lowerCAmelCase_		(		__magic_name__    ,unittest.TestCase		):
 __lowerCamelCase    :				Optional[Any]								=       PegasusTokenizer
 __lowerCamelCase    :				str								=       PegasusTokenizerFast
 __lowerCamelCase    :				List[Any]								=       True
 __lowerCamelCase    :				int								=       True




 def 				_snake_case (						self		)     ->				Optional[Any]:
     super().setUp()

     # We have a SentencePiece fixture for testing
     _lowerCAmelCase						      =   PegasusTokenizer(_lowerCAmelCase      ,  offset=0      ,  mask_token_sent=_lowerCAmelCase      ,  mask_token="[MASK]"		)
     tokenizer.save_pretrained(self.tmpdirname		)




 @cached_property
 def 				_snake_case (						self		)     ->				List[Any]:
     return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv"		)




 def 				_snake_case (						self      ,  **_lowerCAmelCase		)     ->				PegasusTokenizer:
     return PegasusTokenizer.from_pretrained(self.tmpdirname      ,  **_lowerCAmelCase		)




 def 				_snake_case (						self      ,  _lowerCAmelCase		)     ->				Dict:
     return ("This is a test", "This is a test")




 def 				_snake_case (						self		)     ->				List[Any]:
     _lowerCAmelCase						      =   self.rust_tokenizer_class.from_pretrained(self.tmpdirname		)
     _lowerCAmelCase						      =   self.tokenizer_class.from_pretrained(self.tmpdirname		)
     _lowerCAmelCase						      =   (
         "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>"
         " <pad> <pad> <pad>"
     )
     _lowerCAmelCase						      =   rust_tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase      ,  add_special_tokens=_lowerCAmelCase		).input_ids[0]
     _lowerCAmelCase						      =   py_tokenizer([raw_input_str]      ,  return_tensors=_lowerCAmelCase      ,  add_special_tokens=_lowerCAmelCase		).input_ids[0]
     self.assertListEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 @require_torch
 def 				_snake_case (						self		)     ->				str:
     _lowerCAmelCase						      =   ["This is going to be way too long." * 1000, "short example"]
     _lowerCAmelCase						      =   ["not super long but more than 5 tokens", "tiny"]
     _lowerCAmelCase						      =   self._large_tokenizer(_lowerCAmelCase      ,  padding=_lowerCAmelCase      ,  truncation=_lowerCAmelCase      ,  return_tensors="pt"		)
     _lowerCAmelCase						      =   self._large_tokenizer(
         text_target=_lowerCAmelCase      ,  max_length=5      ,  padding=_lowerCAmelCase      ,  truncation=_lowerCAmelCase      ,  return_tensors="pt"		)

     assert batch.input_ids.shape == (2, 4096)
     assert batch.attention_mask.shape == (2, 4096)
     assert targets["input_ids"].shape == (2, 5)
     assert len(_lowerCAmelCase		) == 2  # input_ids, attention_mask.





 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   (
         "This is an example string that is used to test the original TF implementation against the HF"
         " implementation"
     )

     _lowerCAmelCase						      =   self._large_tokenizer(_lowerCAmelCase		).input_ids

     self.assertListEqual(
         _lowerCAmelCase      ,  [182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 25016, 3137, 464, 109, 26955, 3137, 1]      ,  )









'''simple docstring'''


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

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


_SCREAMING_SNAKE_CASE									=				logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE									=				{
    "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json",
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}

class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       "blenderbot-small"
 __lowerCamelCase    :				Optional[Any]								=       ["past_key_values"]
 __lowerCamelCase    :				str								=       {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}




 def __init__(						self      ,  _lowerCAmelCase=50265      ,  _lowerCAmelCase=512      ,  _lowerCAmelCase=8      ,  _lowerCAmelCase=2048      ,  _lowerCAmelCase=16      ,  _lowerCAmelCase=8      ,  _lowerCAmelCase=2048      ,  _lowerCAmelCase=16      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase="gelu"      ,  _lowerCAmelCase=512      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.02      ,  _lowerCAmelCase=1      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=0      ,  _lowerCAmelCase=1      ,  _lowerCAmelCase=2      ,  _lowerCAmelCase=2      ,  **_lowerCAmelCase      ,  )     ->				Dict:
     _lowerCAmelCase						      =   vocab_size
     _lowerCAmelCase						      =   max_position_embeddings
     _lowerCAmelCase						      =   d_model
     _lowerCAmelCase						      =   encoder_ffn_dim
     _lowerCAmelCase						      =   encoder_layers
     _lowerCAmelCase						      =   encoder_attention_heads
     _lowerCAmelCase						      =   decoder_ffn_dim
     _lowerCAmelCase						      =   decoder_layers
     _lowerCAmelCase						      =   decoder_attention_heads
     _lowerCAmelCase						      =   dropout
     _lowerCAmelCase						      =   attention_dropout
     _lowerCAmelCase						      =   activation_dropout
     _lowerCAmelCase						      =   activation_function
     _lowerCAmelCase						      =   init_std
     _lowerCAmelCase						      =   encoder_layerdrop
     _lowerCAmelCase						      =   decoder_layerdrop
     _lowerCAmelCase						      =   use_cache
     _lowerCAmelCase						      =   encoder_layers
     _lowerCAmelCase						      =   scale_embedding  # scale factor will be sqrt(d_model) if True

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







class  lowerCAmelCase_		(		__magic_name__		):




 @property
 def 				_snake_case (						self		)     ->				Mapping[str, Mapping[int, str]]:
     if self.task in ["default", "seq2seq-lm"]:
         _lowerCAmelCase						      =   OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]		)

         if self.use_past:
             _lowerCAmelCase						      =   {0: "batch"}
             _lowerCAmelCase						      =   {0: "batch", 1: "past_decoder_sequence + sequence"}
         else:
             _lowerCAmelCase						      =   {0: "batch", 1: "decoder_sequence"}
             _lowerCAmelCase						      =   {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.
         _lowerCAmelCase						      =   OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]		)
         if self.use_past:
             _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_layers
             for i in range(_lowerCAmelCase		):
                 _lowerCAmelCase						      =   {0: "batch", 2: "past_sequence + sequence"}
                 _lowerCAmelCase						      =   {0: "batch", 2: "past_sequence + sequence"}
     else:
         _lowerCAmelCase						      =   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 				_snake_case (						self		)     ->				Mapping[str, Mapping[int, str]]:
     if self.task in ["default", "seq2seq-lm"]:
         _lowerCAmelCase						      =   super().outputs
     else:
         _lowerCAmelCase						      =   super(_lowerCAmelCase      ,  self		).outputs
         if self.use_past:
             _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_layers
             for i in range(_lowerCAmelCase		):
                 _lowerCAmelCase						      =   {0: "batch", 2: "past_sequence + sequence"}
                 _lowerCAmelCase						      =   {0: "batch", 2: "past_sequence + sequence"}
     return common_outputs




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = False      ,  _lowerCAmelCase = None      ,  )     ->				Mapping[str, Any]:
     _lowerCAmelCase						      =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)

     # Generate decoder inputs
     _lowerCAmelCase						      =   seq_length if not self.use_past else 1
     _lowerCAmelCase						      =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)
     _lowerCAmelCase						      =   {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
     _lowerCAmelCase						      =   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
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   common_inputs["input_ids"].shape
         _lowerCAmelCase						      =   common_inputs["decoder_input_ids"].shape[1]
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_attention_heads
         _lowerCAmelCase						      =   (
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         _lowerCAmelCase						      =   decoder_seq_length + 3
         _lowerCAmelCase						      =   (
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )

         _lowerCAmelCase						      =   torch.cat(
             [common_inputs["decoder_attention_mask"], torch.ones(_lowerCAmelCase      ,  _lowerCAmelCase		)]      ,  dim=1		)

         _lowerCAmelCase						      =   []
         # If the number of encoder and decoder layers are present in the model configuration, both are considered
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_layers
         _lowerCAmelCase						      =   min(_lowerCAmelCase      ,  _lowerCAmelCase		)
         _lowerCAmelCase						      =   max(_lowerCAmelCase      ,  _lowerCAmelCase		) - min_num_layers
         _lowerCAmelCase						      =   "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.
         _lowerCAmelCase						      =   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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = False      ,  _lowerCAmelCase = None      ,  )     ->				Mapping[str, Any]:
     _lowerCAmelCase						      =   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
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   common_inputs["input_ids"].shape
         # Not using the same length for past_key_values
         _lowerCAmelCase						      =   seqlen + 2
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_layers
         _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.num_attention_heads
         _lowerCAmelCase						      =   (
             batch,
             num_encoder_attention_heads,
             past_key_values_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )

         _lowerCAmelCase						      =   common_inputs["attention_mask"].dtype
         _lowerCAmelCase						      =   torch.cat(
             [common_inputs["attention_mask"], torch.ones(_lowerCAmelCase      ,  _lowerCAmelCase      ,  dtype=_lowerCAmelCase		)]      ,  dim=1		)
         _lowerCAmelCase						      =   [
             (torch.zeros(_lowerCAmelCase		), torch.zeros(_lowerCAmelCase		)) for _ in range(_lowerCAmelCase		)
         ]
     return common_inputs




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = False      ,  _lowerCAmelCase = None      ,  )     ->				Mapping[str, Any]:
     # Copied from OnnxConfig.generate_dummy_inputs
     # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
     # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
     _lowerCAmelCase						      =   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
     _lowerCAmelCase						      =   tokenizer.num_special_tokens_to_add(_lowerCAmelCase		)
     _lowerCAmelCase						      =   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
     _lowerCAmelCase						      =   [" ".join([tokenizer.unk_token]		) * seq_length] * batch_size
     _lowerCAmelCase						      =   dict(tokenizer(_lowerCAmelCase      ,  return_tensors=_lowerCAmelCase		)		)
     return common_inputs




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = -1      ,  _lowerCAmelCase = False      ,  _lowerCAmelCase = None      ,  )     ->				Mapping[str, Any]:
     if self.task in ["default", "seq2seq-lm"]:
         _lowerCAmelCase						      =   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":
         _lowerCAmelCase						      =   self._generate_dummy_inputs_for_causal_lm(
             _lowerCAmelCase      ,  batch_size=_lowerCAmelCase      ,  seq_length=_lowerCAmelCase      ,  is_pair=_lowerCAmelCase      ,  framework=_lowerCAmelCase		)
     else:
         _lowerCAmelCase						      =   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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				Dict:
     if self.task in ["default", "seq2seq-lm"]:
         _lowerCAmelCase						      =   super()._flatten_past_key_values_(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)
     else:
         _lowerCAmelCase						      =   super(_lowerCAmelCase      ,  self		)._flatten_past_key_values_(
             _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)


