




import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

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

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


if is_torch_available():
 import torch
 from torch import nn

 from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
 from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from transformers import VivitImageProcessor



class 			a     :

     '''simple docstring'''





     def __init__(	self   :			List[str]					,    __snake_case   :			List[str]					,    __snake_case   :			Optional[int]=2					,    __snake_case   :			Tuple=True					,    __snake_case   :			Union[str, Any]=True					,    __snake_case   :			List[Any]=10					,    __snake_case   :			str=10					,    __snake_case   :			int=8					,    __snake_case   :			Dict=[2, 4, 4]					,    __snake_case   :			str=3					,    __snake_case   :			Dict=7_68					,    __snake_case   :			List[str]=5					,    __snake_case   :			str=4					,    __snake_case   :			List[str]=37					,    __snake_case   :			Any="gelu_fast"					,    __snake_case   :			Any=0.0					,    __snake_case   :			Optional[int]=0.0					,    __snake_case   :			Optional[int]=0.02					,    __snake_case   :			Any=1E-06					,    __snake_case   :			Optional[int]=True					,    __snake_case   :			Union[str, Any]=None					,    ):
         UpperCAmelCase_							 =     parent
         UpperCAmelCase_							 =     batch_size
         UpperCAmelCase_							 =     is_training
         UpperCAmelCase_							 =     use_labels
         UpperCAmelCase_							 =     num_labels
         UpperCAmelCase_							 =     image_size
         UpperCAmelCase_							 =     num_frames
         UpperCAmelCase_							 =     tubelet_size
         UpperCAmelCase_							 =     num_channels
         UpperCAmelCase_							 =     hidden_size
         UpperCAmelCase_							 =     num_hidden_layers
         UpperCAmelCase_							 =     num_attention_heads
         UpperCAmelCase_							 =     intermediate_size
         UpperCAmelCase_							 =     hidden_act
         UpperCAmelCase_							 =     hidden_dropout_prob
         UpperCAmelCase_							 =     attention_probs_dropout_prob
         UpperCAmelCase_							 =     initializer_range
         UpperCAmelCase_							 =     layer_norm_eps
         UpperCAmelCase_							 =     qkv_bias
         UpperCAmelCase_							 =     scope

         UpperCAmelCase_							 =     (
             (self.image_size // self.tubelet_size[2])
             * (self.image_size // self.tubelet_size[1])
             * (self.num_frames // self.tubelet_size[0])
         ) + 1  # CLS token
     def   lowerCamelCase_   (	self   :			Any				):
         UpperCAmelCase_							 =     floats_tensor(
             [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]				)

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

         UpperCAmelCase_							 =     self.get_config()

         return config, pixel_values, labels
     def   lowerCamelCase_   (	self   :			Optional[int]				):
         UpperCAmelCase_							 =     VivitConfig(
             num_frames=self.num_frames					,    image_size=self.image_size					,    tubelet_size=self.tubelet_size					,    num_channels=self.num_channels					,    hidden_size=self.hidden_size					,    num_hidden_layers=self.num_hidden_layers					,    num_attention_heads=self.num_attention_heads					,    intermediate_size=self.intermediate_size					,    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					,    layer_norm_eps=self.layer_norm_eps					,    qkv_bias=self.qkv_bias					,    )
         UpperCAmelCase_							 =     self.num_labels
         return config
     def   lowerCamelCase_   (	self   :			Optional[int]					,    __snake_case   :			Any					,    __snake_case   :			List[str]					,    __snake_case   :			str				):
         UpperCAmelCase_							 =     VivitModel(config=__snake_case				)
         model.to(__snake_case				)
         model.eval()
         UpperCAmelCase_							 =     model(__snake_case				)
         self.parent.assertEqual(result.last_hidden_state.shape					,    (self.batch_size, self.seq_length, self.hidden_size)				)
     def   lowerCamelCase_   (	self   :			Dict					,    __snake_case   :			Tuple					,    __snake_case   :			int					,    __snake_case   :			int				):
         UpperCAmelCase_							 =     VivitForVideoClassification(__snake_case				)
         model.to(__snake_case				)
         model.eval()

         UpperCAmelCase_							 =     model(__snake_case				)

         # verify the logits shape
         UpperCAmelCase_							 =     torch.Size((self.batch_size, self.num_labels)				)
         self.parent.assertEqual(result.logits.shape					,    __snake_case				)




     def   lowerCamelCase_   (	self   :			Union[str, Any]				):
         UpperCAmelCase_							 =     self.prepare_config_and_inputs()
         UpperCAmelCase_ ,							UpperCAmelCase_ ,							UpperCAmelCase_							 =     config_and_inputs
         UpperCAmelCase_							 =     {'''pixel_values''': pixel_values}
         return config, inputs_dict



@require_torch
class 			a     (   _A	,   unittest.TestCase			):

     '''simple docstring'''





     lowerCAmelCase				:       List[Any]   		=  (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

     lowerCAmelCase				:       List[Any]   		=  False
     lowerCAmelCase				:       List[Any]   		=  False
     lowerCAmelCase				:       List[Any]   		=  False
     lowerCAmelCase				:       Optional[Any]   		=  False
     def   lowerCamelCase_   (	self   :			List[Any]				):
         UpperCAmelCase_							 =     VivitModelTester(self				)
         UpperCAmelCase_							 =     ConfigTester(self					,    config_class=__snake_case					,    has_text_modality=__snake_case					,    hidden_size=37				)
     def   lowerCamelCase_   (	self   :			Any					,    __snake_case   :			Optional[int]					,    __snake_case   :			Optional[int]					,    __snake_case   :			int=False				):
         UpperCAmelCase_							 =     copy.deepcopy(__snake_case				)

         if return_labels:
             if model_class in get_values(__snake_case				):
                 UpperCAmelCase_							 =     torch.zeros(
                     self.model_tester.batch_size					,    dtype=torch.long					,    device=__snake_case				)

         return inputs_dict
     def   lowerCamelCase_   (	self   :			int				):
         self.config_tester.run_common_tests()
     @unittest.skip(reason='''Vivit does not use inputs_embeds'''				)
     def   lowerCamelCase_   (	self   :			Any				):
         pass
     def   lowerCamelCase_   (	self   :			Any				):
         UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             UpperCAmelCase_							 =     model_class(__snake_case				)
             self.assertIsInstance(model.get_input_embeddings()					,    (nn.Module)				)
             UpperCAmelCase_							 =     model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(__snake_case					,    nn.Linear				)				)
     def   lowerCamelCase_   (	self   :			Optional[Any]				):
         UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCAmelCase_							 =     ['''pixel_values''', '''head_mask''']
             self.assertListEqual(arg_names[:2]					,    __snake_case				)
     def   lowerCamelCase_   (	self   :			Tuple				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case				)
     def   lowerCamelCase_   (	self   :			int				):
         UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_video_classification(*__snake_case				)
     @slow
     def   lowerCamelCase_   (	self   :			Optional[int]				):
         for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCAmelCase_							 =     VivitModel.from_pretrained(__snake_case				)
             self.assertIsNotNone(__snake_case				)
     def   lowerCamelCase_   (	self   :			int				):
         UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase_							 =     True

         for model_class in self.all_model_classes:
             UpperCAmelCase_							 =     self.model_tester.seq_length

             UpperCAmelCase_							 =     True
             UpperCAmelCase_							 =     False
             UpperCAmelCase_							 =     True
             UpperCAmelCase_							 =     model_class(__snake_case				)
             model.to(__snake_case				)
             model.eval()
             with torch.no_grad():
                 UpperCAmelCase_							 =     model(**self._prepare_for_class(__snake_case					,    __snake_case				)				)
             UpperCAmelCase_							 =     outputs.attentions
             self.assertEqual(len(__snake_case				)					,    self.model_tester.num_hidden_layers				)

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

             self.assertListEqual(
                 list(attentions[0].shape[-3:]				)					,    [self.model_tester.num_attention_heads, seq_len, seq_len]					,    )
             UpperCAmelCase_							 =     len(__snake_case				)

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

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

             UpperCAmelCase_							 =     outputs.attentions

             self.assertEqual(len(__snake_case				)					,    self.model_tester.num_hidden_layers				)

             self.assertListEqual(
                 list(self_attentions[0].shape[-3:]				)					,    [self.model_tester.num_attention_heads, seq_len, seq_len]					,    )
     def   lowerCamelCase_   (	self   :			List[str]				):
         def check_hidden_states_output(__snake_case   :			Optional[Any]					,    __snake_case   :			str					,    __snake_case   :			str				):
             UpperCAmelCase_							 =     model_class(__snake_case				)
             model.to(__snake_case				)
             model.eval()

             with torch.no_grad():
                 UpperCAmelCase_							 =     model(**self._prepare_for_class(__snake_case					,    __snake_case				)				)

             UpperCAmelCase_							 =     outputs.hidden_states
             UpperCAmelCase_							 =     self.model_tester.num_hidden_layers + 1
             self.assertEqual(len(__snake_case				)					,    __snake_case				)

             UpperCAmelCase_							 =     self.model_tester.seq_length

             self.assertListEqual(
                 list(hidden_states[0].shape[-2:]				)					,    [seq_length, self.model_tester.hidden_size]					,    )

         UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             UpperCAmelCase_							 =     True
             check_hidden_states_output(__snake_case					,    __snake_case					,    __snake_case				)

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

             check_hidden_states_output(__snake_case					,    __snake_case					,    __snake_case				)




     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''				)
     def   lowerCamelCase_   (	self   :			int				):
         pass




def 					SCREAMING_SNAKE_CASE	(       )  ->							List[Any]:
    UpperCAmelCase_							 =     hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''       ,     filename='''eating_spaghetti_32_frames.npy'''       ,     repo_type='''dataset'''      )
    UpperCAmelCase_							 =     np.load(__UpperCamelCase      )
    return list(__UpperCamelCase      )



@require_torch
@require_vision
class 			a     (   unittest.TestCase			):

     '''simple docstring'''





     @cached_property
     def   lowerCamelCase_   (	self   :			str				):
         return VivitImageProcessor() if is_vision_available() else None




     @slow
     def   lowerCamelCase_   (	self   :			Any				):
         UpperCAmelCase_							 =     VivitForVideoClassification.from_pretrained('''google/vivit-b-16x2-kinetics400'''				).to(__snake_case				)

         UpperCAmelCase_							 =     self.default_image_processor
         UpperCAmelCase_							 =     prepare_video()
         UpperCAmelCase_							 =     image_processor(__snake_case					,    return_tensors='''pt'''				).to(__snake_case				)

         # forward pass
         with torch.no_grad():
             UpperCAmelCase_							 =     model(**__snake_case				)

         # verify the logits
         UpperCAmelCase_							 =     torch.Size((1, 4_00)				)
         self.assertEqual(outputs.logits.shape					,    __snake_case				)

         # taken from original model
         UpperCAmelCase_							 =     torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]				).to(__snake_case				)

         self.assertTrue(torch.allclose(outputs.logits[0, :5]					,    __snake_case					,    atol=1E-4				)				)











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


_lowerCamelCase			 =						logging.get_logger(__name__)

_lowerCamelCase			 =						{
    'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json',
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}



class 			a     (   _A			):

     '''simple docstring'''





     lowerCAmelCase				:       List[Any]   		=  'blenderbot'
     lowerCAmelCase				:       int   		=  ['past_key_values']
     lowerCAmelCase				:       int   		=  {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}
     def __init__(	self   :			int					,    __snake_case   :			Optional[Any]=80_08					,    __snake_case   :			List[str]=1_28					,    __snake_case   :			List[str]=2					,    __snake_case   :			Tuple=1_02_40					,    __snake_case   :			List[Any]=32					,    __snake_case   :			int=24					,    __snake_case   :			str=1_02_40					,    __snake_case   :			Optional[int]=32					,    __snake_case   :			Dict=0.0					,    __snake_case   :			int=0.0					,    __snake_case   :			str=True					,    __snake_case   :			Dict=True					,    __snake_case   :			Dict="gelu"					,    __snake_case   :			List[str]=25_60					,    __snake_case   :			List[Any]=0.1					,    __snake_case   :			str=0.0					,    __snake_case   :			Dict=0.0					,    __snake_case   :			Tuple=0.02					,    __snake_case   :			Any=1					,    __snake_case   :			int=False					,    __snake_case   :			Any=0					,    __snake_case   :			Optional[Any]=1					,    __snake_case   :			Optional[int]=2					,    __snake_case   :			List[Any]=3					,    __snake_case   :			int=2					,    **__snake_case   :			Tuple					,    ):
         UpperCAmelCase_							 =     vocab_size
         UpperCAmelCase_							 =     max_position_embeddings
         UpperCAmelCase_							 =     d_model
         UpperCAmelCase_							 =     encoder_ffn_dim
         UpperCAmelCase_							 =     encoder_layers
         UpperCAmelCase_							 =     encoder_attention_heads
         UpperCAmelCase_							 =     decoder_ffn_dim
         UpperCAmelCase_							 =     decoder_layers
         UpperCAmelCase_							 =     decoder_attention_heads
         UpperCAmelCase_							 =     dropout
         UpperCAmelCase_							 =     attention_dropout
         UpperCAmelCase_							 =     activation_dropout
         UpperCAmelCase_							 =     activation_function
         UpperCAmelCase_							 =     init_std
         UpperCAmelCase_							 =     encoder_layerdrop
         UpperCAmelCase_							 =     decoder_layerdrop
         UpperCAmelCase_							 =     use_cache
         UpperCAmelCase_							 =     encoder_layers
         UpperCAmelCase_							 =     scale_embedding  # scale factor will be sqrt(d_model) if True

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



class 			a     (   _A			):

     '''simple docstring'''





     @property
     def   lowerCamelCase_   (	self   :			Any				):
         if self.task in ["default", "seq2seq-lm"]:
             UpperCAmelCase_							 =     OrderedDict(
                 [
                     ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ]				)
             if self.use_past:
                 UpperCAmelCase_							 =     {0: '''batch'''}
                 UpperCAmelCase_							 =     {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
             else:
                 UpperCAmelCase_							 =     {0: '''batch''', 1: '''decoder_sequence'''}
                 UpperCAmelCase_							 =     {0: '''batch''', 1: '''decoder_sequence'''}
             if self.use_past:
                 self.fill_with_past_key_values_(__snake_case					,    direction='''inputs'''				)
         elif self.task == "causal-lm":
             UpperCAmelCase_							 =     OrderedDict(
                 [
                     ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ]				)
             if self.use_past:
                 UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_layers
                 for i in range(__snake_case				):
                     UpperCAmelCase_							 =     {0: '''batch''', 2: '''past_sequence + sequence'''}
                     UpperCAmelCase_							 =     {0: '''batch''', 2: '''past_sequence + sequence'''}
         else:
             UpperCAmelCase_							 =     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
     # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
     def   lowerCamelCase_   (	self   :			Optional[Any]				):
         if self.task in ["default", "seq2seq-lm"]:
             UpperCAmelCase_							 =     super().outputs
         else:
             UpperCAmelCase_							 =     super(__snake_case					,    self				).outputs
             if self.use_past:
                 UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_layers
                 for i in range(__snake_case				):
                     UpperCAmelCase_							 =     {0: '''batch''', 2: '''past_sequence + sequence'''}
                     UpperCAmelCase_							 =     {0: '''batch''', 2: '''past_sequence + sequence'''}
         return common_outputs
     def   lowerCamelCase_   (	self   :			Optional[Any]					,    __snake_case   :			PreTrainedTokenizer					,    __snake_case   :			int = -1					,    __snake_case   :			int = -1					,    __snake_case   :			bool = False					,    __snake_case   :			Optional[TensorType] = None					,    ):
         UpperCAmelCase_							 =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             __snake_case					,    __snake_case					,    __snake_case					,    __snake_case					,    __snake_case				)
         # Generate decoder inputs
         UpperCAmelCase_							 =     seq_length if not self.use_past else 1
         UpperCAmelCase_							 =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             __snake_case					,    __snake_case					,    __snake_case					,    __snake_case					,    __snake_case				)
         UpperCAmelCase_							 =     {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
         UpperCAmelCase_							 =     dict(**__snake_case					,    **__snake_case				)

         if self.use_past:
             if not is_torch_available():
                 raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''				)
             else:
                 import torch
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     common_inputs['''input_ids'''].shape
             UpperCAmelCase_							 =     common_inputs['''decoder_input_ids'''].shape[1]
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_attention_heads
             UpperCAmelCase_							 =     (
                 batch,
                 num_encoder_attention_heads,
                 encoder_seq_length,
                 self._config.hidden_size // num_encoder_attention_heads,
             )
             UpperCAmelCase_							 =     decoder_seq_length
             UpperCAmelCase_							 =     (
                 batch,
                 num_decoder_attention_heads,
                 decoder_past_length,
                 self._config.hidden_size // num_decoder_attention_heads,
             )
             UpperCAmelCase_							 =     torch.cat(
                 [common_inputs['''decoder_attention_mask'''], torch.ones(__snake_case					,    __snake_case				)]					,    dim=1				)
             UpperCAmelCase_							 =     []
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_layers

             for _ in range(__snake_case				):
                 common_inputs["past_key_values"].append(
                     (
                         torch.zeros(__snake_case				),
                         torch.zeros(__snake_case				),
                         torch.zeros(__snake_case				),
                         torch.zeros(__snake_case				),
                     )				)
         return common_inputs
     def   lowerCamelCase_   (	self   :			Optional[Any]					,    __snake_case   :			PreTrainedTokenizer					,    __snake_case   :			int = -1					,    __snake_case   :			int = -1					,    __snake_case   :			bool = False					,    __snake_case   :			Optional[TensorType] = None					,    ):
         UpperCAmelCase_							 =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             __snake_case					,    __snake_case					,    __snake_case					,    __snake_case					,    __snake_case				)

         if self.use_past:
             if not is_torch_available():
                 raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''				)
             else:
                 import torch
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     common_inputs['''input_ids'''].shape
             UpperCAmelCase_							 =     seqlen
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_layers
             UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_attention_heads
             UpperCAmelCase_							 =     (
                 batch,
                 num_encoder_attention_heads,
                 past_key_values_length,
                 self._config.hidden_size // num_encoder_attention_heads,
             )
             UpperCAmelCase_							 =     common_inputs['''attention_mask'''].dtype
             UpperCAmelCase_							 =     torch.cat(
                 [common_inputs['''attention_mask'''], torch.ones(__snake_case					,    __snake_case					,    dtype=__snake_case				)]					,    dim=1				)
             UpperCAmelCase_							 =     [
                 (torch.zeros(__snake_case				), torch.zeros(__snake_case				)) for _ in range(__snake_case				)
             ]
         return common_inputs
     def   lowerCamelCase_   (	self   :			Any					,    __snake_case   :			PreTrainedTokenizer					,    __snake_case   :			int = -1					,    __snake_case   :			int = -1					,    __snake_case   :			bool = False					,    __snake_case   :			Optional[TensorType] = None					,    ):
         # 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
         UpperCAmelCase_							 =     compute_effective_axis_dimension(
             __snake_case					,    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
         UpperCAmelCase_							 =     tokenizer.num_special_tokens_to_add(__snake_case				)
         UpperCAmelCase_							 =     compute_effective_axis_dimension(
             __snake_case					,    fixed_dimension=OnnxConfig.default_fixed_sequence					,    num_token_to_add=__snake_case				)

         # Generate dummy inputs according to compute batch and sequence
         UpperCAmelCase_							 =     [''' '''.join([tokenizer.unk_token]				) * seq_length] * batch_size
         UpperCAmelCase_							 =     dict(tokenizer(__snake_case					,    return_tensors=__snake_case				)				)
         return common_inputs
     def   lowerCamelCase_   (	self   :			List[Any]					,    __snake_case   :			PreTrainedTokenizer					,    __snake_case   :			int = -1					,    __snake_case   :			int = -1					,    __snake_case   :			bool = False					,    __snake_case   :			Optional[TensorType] = None					,    ):
         if self.task in ["default", "seq2seq-lm"]:
             UpperCAmelCase_							 =     self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                 __snake_case					,    batch_size=__snake_case					,    seq_length=__snake_case					,    is_pair=__snake_case					,    framework=__snake_case				)

         elif self.task == "causal-lm":
             UpperCAmelCase_							 =     self._generate_dummy_inputs_for_causal_lm(
                 __snake_case					,    batch_size=__snake_case					,    seq_length=__snake_case					,    is_pair=__snake_case					,    framework=__snake_case				)
         else:
             UpperCAmelCase_							 =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                 __snake_case					,    batch_size=__snake_case					,    seq_length=__snake_case					,    is_pair=__snake_case					,    framework=__snake_case				)

         return common_inputs
     def   lowerCamelCase_   (	self   :			Dict					,    __snake_case   :			Optional[int]					,    __snake_case   :			int					,    __snake_case   :			str					,    __snake_case   :			Optional[int]				):
         if self.task in ["default", "seq2seq-lm"]:
             UpperCAmelCase_							 =     super()._flatten_past_key_values_(__snake_case					,    __snake_case					,    __snake_case					,    __snake_case				)
         else:
             UpperCAmelCase_							 =     super(__snake_case					,    self				)._flatten_past_key_values_(
                 __snake_case					,    __snake_case					,    __snake_case					,    __snake_case				)




     def   lowerCamelCase_   (	self   :			Dict					,    __snake_case   :			Mapping[str, Mapping[int, str]]					,    __snake_case   :			str				):
         if direction not in ["inputs", "outputs"]:
             raise ValueError(F'direction must either be "inputs" or "outputs", but {direction} was given'				)

         UpperCAmelCase_							 =     '''past_key_values''' if direction == '''inputs''' else '''present'''
         UpperCAmelCase_ ,							UpperCAmelCase_							 =     self.num_layers

         UpperCAmelCase_							 =     '''past_encoder_sequence'''
         UpperCAmelCase_							 =     '''past_decoder_sequence''' if direction == '''inputs''' else '''past_decoder_sequence + sequence'''

         for i in range(__snake_case				):
             UpperCAmelCase_							 =     {0: '''batch''', 2: decoder_sequence}
             UpperCAmelCase_							 =     {0: '''batch''', 2: decoder_sequence}
             UpperCAmelCase_							 =     {0: '''batch''', 2: encoder_sequence}
             UpperCAmelCase_							 =     {0: '''batch''', 2: encoder_sequence}





