
import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import MODEL_MAPPING, GLPNConfig, GLPNForDepthEstimation, GLPNModel
   from transformers.models.glpn.modeling_glpn import GLPN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import GLPNImageProcessor







class      lowerCamelCase		(  A_  ):





     def 		UpperCAmelCase(self      :    Optional[int]   )						->						int:
         snake_case      =					self.config_class(**self.inputs_dict   )
         self.parent.assertTrue(hasattr(_A				,    "hidden_sizes"   )   )
         self.parent.assertTrue(hasattr(_A				,    "num_attention_heads"   )   )
         self.parent.assertTrue(hasattr(_A				,    "num_encoder_blocks"   )   )







class      lowerCamelCase		:





     def __init__(self      :    Optional[Any]				,    _A      :    Dict				,    _A      :    str=1_3				,    _A      :    str=6_4				,    _A      :    List[Any]=3				,    _A      :    List[str]=4				,    _A      :    List[Any]=[2, 2, 2, 2]				,    _A      :    Tuple=[8, 4, 2, 1]				,    _A      :    List[Any]=[1_6, 3_2, 6_4, 1_2_8]				,    _A      :    Dict=[1, 4, 8, 1_6]				,    _A      :    int=[1, 2, 4, 8]				,    _A      :    str=True				,    _A      :    Union[str, Any]=True				,    _A      :    Union[str, Any]="gelu"				,    _A      :    Tuple=0.1				,    _A      :    List[Any]=0.1				,    _A      :    Optional[Any]=0.02				,    _A      :    Tuple=1_6				,    _A      :    Dict=3				,    _A      :    Tuple=None				,    )						->						Any:
         snake_case      =					parent
         snake_case      =					batch_size
         snake_case      =					image_size
         snake_case      =					num_channels
         snake_case      =					num_encoder_blocks
         snake_case      =					sr_ratios
         snake_case      =					depths
         snake_case      =					hidden_sizes
         snake_case      =					downsampling_rates
         snake_case      =					num_attention_heads
         snake_case      =					is_training
         snake_case      =					use_labels
         snake_case      =					hidden_act
         snake_case      =					hidden_dropout_prob
         snake_case      =					attention_probs_dropout_prob
         snake_case      =					initializer_range
         snake_case      =					decoder_hidden_size
         snake_case      =					num_labels
         snake_case      =					scope





     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						List[str]:
         snake_case      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

         snake_case      =					None
         if self.use_labels:
             snake_case      =					ids_tensor([self.batch_size, self.image_size, self.image_size]				,    self.num_labels   )

         snake_case      =					self.get_config()
         return config, pixel_values, labels





     def 		UpperCAmelCase(self      :    List[Any]   )						->						List[str]:
         return GLPNConfig(
             image_size=self.image_size				,    num_channels=self.num_channels				,    num_encoder_blocks=self.num_encoder_blocks				,    depths=self.depths				,    hidden_sizes=self.hidden_sizes				,    num_attention_heads=self.num_attention_heads				,    hidden_act=self.hidden_act				,    hidden_dropout_prob=self.hidden_dropout_prob				,    attention_probs_dropout_prob=self.attention_probs_dropout_prob				,    initializer_range=self.initializer_range				,    decoder_hidden_size=self.decoder_hidden_size				,    )





     def 		UpperCAmelCase(self      :    List[str]				,    _A      :    Optional[Any]				,    _A      :    List[Any]				,    _A      :    Optional[int]   )						->						Optional[Any]:
         snake_case      =					GLPNModel(config=_A   )
         model.to(_A   )
         model.eval()
         snake_case      =					model(_A   )
         snake_case      =					snake_case      =					self.image_size // (self.downsampling_rates[-1] * 2)
         self.parent.assertEqual(
             result.last_hidden_state.shape				,    (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)   )





     def 		UpperCAmelCase(self      :    Any				,    _A      :    Union[str, Any]				,    _A      :    str				,    _A      :    List[Any]   )						->						Union[str, Any]:
         snake_case      =					self.num_labels
         snake_case      =					GLPNForDepthEstimation(_A   )
         model.to(_A   )
         model.eval()
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.predicted_depth.shape				,    (self.batch_size, self.image_size, self.image_size)   )
         snake_case      =					model(_A				,    labels=_A   )
         self.parent.assertEqual(result.predicted_depth.shape				,    (self.batch_size, self.image_size, self.image_size)   )





     def 		UpperCAmelCase(self      :    Union[str, Any]   )						->						Dict:
         snake_case      =					self.prepare_config_and_inputs()
         snake_case     ,							snake_case     ,							snake_case      =					config_and_inputs
         snake_case      =					{"pixel_values": pixel_values}
         return config, inputs_dict







@require_torch
class      lowerCamelCase		(  A_							, A_							, unittest.TestCase  ):
     UpperCAmelCase__				:							Optional[Any]           =		(GLPNModel, GLPNForDepthEstimation) if is_torch_available() else ()
     UpperCAmelCase__				:							Optional[int]           =		(
         {"depth-estimation": GLPNForDepthEstimation, "feature-extraction": GLPNModel} if is_torch_available() else {}
     )

     UpperCAmelCase__				:							Tuple           =		False
     UpperCAmelCase__				:							Dict           =		False
     UpperCAmelCase__				:							Union[str, Any]           =		False





     def 		UpperCAmelCase(self      :    Any   )						->						List[Any]:
         snake_case      =					GLPNModelTester(self   )
         snake_case      =					GLPNConfigTester(self				,    config_class=_A   )





     def 		UpperCAmelCase(self      :    Union[str, Any]   )						->						Optional[Any]:
         self.config_tester.run_common_tests()





     def 		UpperCAmelCase(self      :    int   )						->						Union[str, Any]:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_A   )





     def 		UpperCAmelCase(self      :    int   )						->						Dict:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_depth_estimation(*_A   )





     @unittest.skip("GLPN does not use inputs_embeds"   )
     def 		UpperCAmelCase(self      :    List[Any]   )						->						str:
         pass





     @unittest.skip("GLPN does not have get_input_embeddings method and get_output_embeddings methods"   )
     def 		UpperCAmelCase(self      :    List[str]   )						->						str:
         pass





     def 		UpperCAmelCase(self      :    int   )						->						Any:
         snake_case     ,							snake_case      =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             snake_case      =					model_class(_A   )
             snake_case      =					inspect.signature(model.forward   )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             snake_case      =					[*signature.parameters.keys()]

             snake_case      =					["pixel_values"]
             self.assertListEqual(arg_names[:1]				,    _A   )





     def 		UpperCAmelCase(self      :    List[Any]   )						->						Union[str, Any]:
         snake_case     ,							snake_case      =					self.model_tester.prepare_config_and_inputs_for_common()
         snake_case      =					True

         for model_class in self.all_model_classes:
             snake_case      =					True
             snake_case      =					False
             snake_case      =					True
             snake_case      =					model_class(_A   )
             model.to(_A   )
             model.eval()
             with torch.no_grad():
                 snake_case      =					model(**self._prepare_for_class(_A				,    _A   )   )
             snake_case      =					outputs.attentions

             snake_case      =					sum(self.model_tester.depths   )
             self.assertEqual(len(_A   )				,    _A   )

             # check that output_attentions also work using config
             del inputs_dict["output_attentions"]
             snake_case      =					True
             snake_case      =					model_class(_A   )
             model.to(_A   )
             model.eval()
             with torch.no_grad():
                 snake_case      =					model(**self._prepare_for_class(_A				,    _A   )   )
             snake_case      =					outputs.attentions

             self.assertEqual(len(_A   )				,    _A   )

             # verify the first attentions (first block, first layer)
             snake_case      =					(self.model_tester.image_size // 4) ** 2
             snake_case      =					(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
             self.assertListEqual(
                 list(attentions[0].shape[-3:]   )				,    [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]				,    )

             # verify the last attentions (last block, last layer)
             snake_case      =					(self.model_tester.image_size // 3_2) ** 2
             snake_case      =					(self.model_tester.image_size // (3_2 * self.model_tester.sr_ratios[-1])) ** 2
             self.assertListEqual(
                 list(attentions[-1].shape[-3:]   )				,    [self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]				,    )
             snake_case      =					len(_A   )

             # Check attention is always last and order is fine
             snake_case      =					True
             snake_case      =					True
             snake_case      =					model_class(_A   )
             model.to(_A   )
             model.eval()
             with torch.no_grad():
                 snake_case      =					model(**self._prepare_for_class(_A				,    _A   )   )

             self.assertEqual(out_len + 1				,    len(_A   )   )

             snake_case      =					outputs.attentions

             self.assertEqual(len(_A   )				,    _A   )
             # verify the first attentions (first block, first layer)
             snake_case      =					(self.model_tester.image_size // 4) ** 2
             snake_case      =					(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
             self.assertListEqual(
                 list(self_attentions[0].shape[-3:]   )				,    [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]				,    )





     def 		UpperCAmelCase(self      :    int   )						->						Any:
         def check_hidden_states_output(_A      :    str				,    _A      :    Union[str, Any]				,    _A      :    Dict   ):
             snake_case      =					model_class(_A   )
             model.to(_A   )
             model.eval()

             with torch.no_grad():
                 snake_case      =					model(**self._prepare_for_class(_A				,    _A   )   )

             snake_case      =					outputs.hidden_states

             snake_case      =					self.model_tester.num_encoder_blocks
             self.assertEqual(len(_A   )				,    _A   )

             # verify the first hidden states (first block)
             self.assertListEqual(
                 list(hidden_states[0].shape[-3:]   )				,    [
                     self.model_tester.hidden_sizes[0],
                     self.model_tester.image_size // 4,
                     self.model_tester.image_size // 4,
                 ]				,    )

         snake_case     ,							snake_case      =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             snake_case      =					True
             check_hidden_states_output(_A				,    _A				,    _A   )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             snake_case      =					True

             check_hidden_states_output(_A				,    _A				,    _A   )





     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						Any:
         if not self.model_tester.is_training:
             return

         snake_case     ,							snake_case      =					self.model_tester.prepare_config_and_inputs_for_common()
         snake_case      =					True

         for model_class in self.all_model_classes:
             if model_class in get_values(_A   ):
                 continue
             # TODO: remove the following 3 lines once we have a MODEL_FOR_DEPTH_ESTIMATION_MAPPING
             # this can then be incorporated into _prepare_for_class in test_modeling_common.py
             if model_class.__name__ == "GLPNForDepthEstimation":
                 snake_case     ,							snake_case     ,							snake_case     ,							snake_case      =					inputs_dict["pixel_values"].shape
                 snake_case      =					torch.zeros(
                     [self.model_tester.batch_size, height, width]				,    device=_A   ).long()
             snake_case      =					model_class(_A   )
             model.to(_A   )
             model.train()
             snake_case      =					self._prepare_for_class(_A				,    _A				,    return_labels=_A   )
             snake_case      =					model(**_A   ).loss
             loss.backward()





     @slow
     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						Optional[int]:
         for model_name in GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case      =					GLPNModel.from_pretrained(_A   )
             self.assertIsNotNone(_A   )



def 						lowercase_			(   )							->							Union[str, Any]:
    """simple docstring"""

    snake_case      =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
    return image







@require_torch
@require_vision
@slow
class      lowerCamelCase		(  unittest.TestCase  ):





     @slow
     def 		UpperCAmelCase(self      :    int   )						->						int:
         snake_case      =					GLPNImageProcessor.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
         snake_case      =					GLPNForDepthEstimation.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(_A   )

         snake_case      =					prepare_img()
         snake_case      =					image_processor(images=_A				,    return_tensors="pt"   ).to(_A   )

         # forward pass
         with torch.no_grad():
             snake_case      =					model(**_A   )

         # verify the predicted depth
         snake_case      =					torch.Size([1, 4_8_0, 6_4_0]   )
         self.assertEqual(outputs.predicted_depth.shape				,    _A   )

         snake_case      =					torch.tensor(
             [[3.42_91, 2.78_65, 2.51_51], [3.28_41, 2.70_21, 2.35_02], [3.11_47, 2.46_25, 2.24_81]]   ).to(_A   )

         self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]				,    _A				,    atol=1E-4   )   )



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


_A  					= logging.get_logger(__name__)

_A  					= {
    "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		(  A_  ):
     UpperCAmelCase__				:							List[Any]           =		"bigbird_pegasus"
     UpperCAmelCase__				:							Tuple           =		["past_key_values"]
     UpperCAmelCase__				:							Optional[Any]           =		{
         "num_attention_heads": "encoder_attention_heads",
         "hidden_size": "d_model",
         "attention_probs_dropout_prob": "attention_dropout",
     }





     def __init__(self      :    Any				,    _A      :    List[str]=9_6_1_0_3				,    _A      :    List[Any]=4_0_9_6				,    _A      :    str=1_6				,    _A      :    Tuple=4_0_9_6				,    _A      :    List[str]=1_6				,    _A      :    Optional[int]=1_6				,    _A      :    List[Any]=4_0_9_6				,    _A      :    Dict=1_6				,    _A      :    Tuple=0.0				,    _A      :    List[str]=0.0				,    _A      :    Dict=True				,    _A      :    int=True				,    _A      :    List[Any]="gelu_new"				,    _A      :    int=1_0_2_4				,    _A      :    int=0.1				,    _A      :    List[Any]=0.0				,    _A      :    Optional[int]=0.0				,    _A      :    Any=0.02				,    _A      :    Dict=2				,    _A      :    List[Any]=0.0				,    _A      :    Any=True				,    _A      :    str=0				,    _A      :    Dict=2				,    _A      :    Any=1				,    _A      :    List[str]="block_sparse"				,    _A      :    int=6_4				,    _A      :    Optional[int]=3				,    _A      :    List[Any]=False				,    **_A      :    Tuple				,    )						->						Any:
         snake_case      =					vocab_size
         snake_case      =					max_position_embeddings
         snake_case      =					d_model
         snake_case      =					encoder_ffn_dim
         snake_case      =					encoder_layers
         snake_case      =					encoder_attention_heads
         snake_case      =					decoder_ffn_dim
         snake_case      =					decoder_layers
         snake_case      =					decoder_attention_heads
         snake_case      =					dropout
         snake_case      =					attention_dropout
         snake_case      =					activation_dropout
         snake_case      =					activation_function
         snake_case      =					init_std
         snake_case      =					encoder_layerdrop
         snake_case      =					decoder_layerdrop
         snake_case      =					classifier_dropout
         snake_case      =					use_cache
         snake_case      =					encoder_layers
         snake_case      =					scale_embedding  # scale factor will be sqrt(d_model) if True

         # extra config
         snake_case      =					attention_type
         snake_case      =					block_size
         snake_case      =					num_random_blocks
         snake_case      =					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      lowerCamelCase		(  A_  ):





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

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





     def 		UpperCAmelCase(self      :    Any				,    _A      :    PreTrainedTokenizer				,    _A      :    int = -1				,    _A      :    int = -1				,    _A      :    bool = False				,    _A      :    Optional[TensorType] = None				,    )						->						Mapping[str, Any]:
         snake_case      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             _A				,    _A				,    _A				,    _A				,    _A   )

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

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

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

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





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    PreTrainedTokenizer				,    _A      :    int = -1				,    _A      :    int = -1				,    _A      :    bool = False				,    _A      :    Optional[TensorType] = 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
         snake_case      =					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
         snake_case      =					tokenizer.num_special_tokens_to_add(_A   )
         snake_case      =					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
         snake_case      =					[" ".join([tokenizer.unk_token]   ) * seq_length] * batch_size
         snake_case      =					dict(tokenizer(_A				,    return_tensors=_A   )   )
         return common_inputs





     def 		UpperCAmelCase(self      :    Any				,    _A      :    PreTrainedTokenizer				,    _A      :    int = -1				,    _A      :    int = -1				,    _A      :    bool = False				,    _A      :    Optional[TensorType] = None				,    )						->						Mapping[str, Any]:
         if self.task in ["default", "seq2seq-lm"]:
             snake_case      =					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":
             snake_case      =					self._generate_dummy_inputs_for_causal_lm(
                 _A				,    batch_size=_A				,    seq_length=_A				,    is_pair=_A				,    framework=_A   )
         else:
             snake_case      =					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 		UpperCAmelCase(self      :    List[Any]				,    _A      :    str				,    _A      :    Union[str, Any]				,    _A      :    Tuple				,    _A      :    List[Any]   )						->						Any:
         if self.task in ["default", "seq2seq-lm"]:
             snake_case      =					super()._flatten_past_key_values_(_A				,    _A				,    _A				,    _A   )
         else:
             snake_case      =					super(_A				,    self   )._flatten_past_key_values_(
                 _A				,    _A				,    _A				,    _A   )

