





"""simple docstring"""


import warnings
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__						= logging.get_logger(__name__)

lowerCamelCase__						= {
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}



class   __SCREAMING_SNAKE_CASE     (    lowerCamelCase__ ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Any						  =       "bart"
  SCREAMING_SNAKE_CASE__				:Dict						  =       ["past_key_values"]
  SCREAMING_SNAKE_CASE__				:str						  =       {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}

  def __init__(		self :							Optional[int]       , __a :							List[Any]=5_0265       , __a :							List[Any]=1024       , __a :							Dict=12       , __a :							Optional[Any]=4096       , __a :							Tuple=16       , __a :							int=12       , __a :							str=4096       , __a :							Dict=16       , __a :							List[Any]=0.0       , __a :							List[str]=0.0       , __a :							int="gelu"       , __a :							Union[str, Any]=1024       , __a :							Optional[int]=0.1       , __a :							Optional[int]=0.0       , __a :							Any=0.0       , __a :							List[str]=0.02       , __a :							Dict=0.0       , __a :							str=False       , __a :							Optional[Any]=True       , __a :							Optional[int]=3       , __a :							List[Any]=1       , __a :							List[Any]=0       , __a :							List[Any]=2       , __a :							Dict=True       , __a :							str=2       , __a :							Optional[Any]=2       , **__a :							List[Any]       , )		->					Optional[Any]:
        _UpperCamelCase   :						Union[str, Any]    =							vocab_size
        _UpperCamelCase   :						Union[str, Any]    =							max_position_embeddings
        _UpperCamelCase   :						int    =							d_model
        _UpperCamelCase   :						Any    =							encoder_ffn_dim
        _UpperCamelCase   :						str    =							encoder_layers
        _UpperCamelCase   :						str    =							encoder_attention_heads
        _UpperCamelCase   :						Optional[int]    =							decoder_ffn_dim
        _UpperCamelCase   :						Any    =							decoder_layers
        _UpperCamelCase   :						Dict    =							decoder_attention_heads
        _UpperCamelCase   :						str    =							dropout
        _UpperCamelCase   :						Tuple    =							attention_dropout
        _UpperCamelCase   :						Optional[Any]    =							activation_dropout
        _UpperCamelCase   :						Optional[Any]    =							activation_function
        _UpperCamelCase   :						int    =							init_std
        _UpperCamelCase   :						Any    =							encoder_layerdrop
        _UpperCamelCase   :						List[Any]    =							decoder_layerdrop
        _UpperCamelCase   :						Union[str, Any]    =							classifier_dropout
        _UpperCamelCase   :						List[Any]    =							use_cache
        _UpperCamelCase   :						str    =							encoder_layers
        _UpperCamelCase   :						int    =							scale_embedding  # scale factor will be sqrt(d_model) if True

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

        # ensure backward compatibility for BART CNN models
        if self.forced_bos_token_id is None and kwargs.get("force_bos_token_to_be_generated"       , SCREAMING_SNAKE_CASE__						):
              _UpperCamelCase   :						Any    =							self.bos_token_id
              warnings.warn(
                  F'''Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '''
                  "The config can simply be saved and uploaded again to be fixed."						)





class   __SCREAMING_SNAKE_CASE     (    lowerCamelCase__ ):







  '''simple docstring'''


  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[Any]						)		->					Mapping[str, Mapping[int, str]]:



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

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

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

        return common_inputs

  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							Union[str, Any]						)		->					Mapping[str, Mapping[int, str]]:



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

  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple       , __a :							int       , __a :							int = -1       , __a :							Dict = -1       , __a :							Optional[int] = False       , __a :							Tuple = None       , )		->					Mapping[str, Any]:
        _UpperCamelCase   :						str    =							self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__						)

        # Generate decoder inputs
        _UpperCamelCase   :						List[Any]    =							seq_length if not self.use_past else 1
        _UpperCamelCase   :						Tuple    =							self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__						)
        _UpperCamelCase   :						Union[str, Any]    =							{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
        _UpperCamelCase   :						str    =							dict(**SCREAMING_SNAKE_CASE__       , **SCREAMING_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   :						Any    =							common_inputs['''input_ids'''].shape
              _UpperCamelCase   :						Dict    =							common_inputs['''decoder_input_ids'''].shape[1]
              _UpperCamelCase   :						Any    =							self.num_attention_heads
              _UpperCamelCase   :						Dict    =							(
                  batch,
                  num_encoder_attention_heads,
                  encoder_seq_length,
                  self._config.hidden_size // num_encoder_attention_heads,
              )
              _UpperCamelCase   :						Tuple    =							decoder_seq_length + 3
              _UpperCamelCase   :						Optional[int]    =							(
                  batch,
                  num_decoder_attention_heads,
                  decoder_past_length,
                  self._config.hidden_size // num_decoder_attention_heads,
              )

              _UpperCamelCase   :						Optional[int]    =							torch.cat(
                  [common_inputs["decoder_attention_mask"], torch.ones(SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__						)]       , dim=1						)

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

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

  def  __SCREAMING_SNAKE_CASE					(		self :							str       , __a :							Optional[Any]       , __a :							List[str] = -1       , __a :							Union[str, Any] = -1       , __a :							Optional[int] = False       , __a :							Dict = None       , )		->					Mapping[str, Any]:
        _UpperCamelCase   :						Dict    =							self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_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   :						List[Any]    =							common_inputs['''input_ids'''].shape
              # Not using the same length for past_key_values
              _UpperCamelCase   :						str    =							seqlen + 2
              _UpperCamelCase   :						Dict    =							self.num_layers
              _UpperCamelCase   :						Union[str, Any]    =							self.num_attention_heads
              _UpperCamelCase   :						List[Any]    =							(
                  batch,
                  num_encoder_attention_heads,
                  past_key_values_length,
                  self._config.hidden_size // num_encoder_attention_heads,
              )

              _UpperCamelCase   :						Tuple    =							common_inputs['''attention_mask'''].dtype
              _UpperCamelCase   :						List[Any]    =							torch.cat(
                  [common_inputs["attention_mask"], torch.ones(SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , dtype=SCREAMING_SNAKE_CASE__						)]       , dim=1						)
              _UpperCamelCase   :						int    =							[
                  (torch.zeros(SCREAMING_SNAKE_CASE__						), torch.zeros(SCREAMING_SNAKE_CASE__						)) for _ in range(SCREAMING_SNAKE_CASE__						)
              ]
        return common_inputs

  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]       , __a :							int       , __a :							int = -1       , __a :							Tuple = -1       , __a :							Tuple = False       , __a :							Union[str, Any] = None       , )		->					Mapping[str, Any]:
        _UpperCamelCase   :						List[str]    =							compute_effective_axis_dimension(
            SCREAMING_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   :						str    =							tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__						)
        _UpperCamelCase   :						str    =							compute_effective_axis_dimension(
            SCREAMING_SNAKE_CASE__       , fixed_dimension=OnnxConfig.default_fixed_sequence       , num_token_to_add=SCREAMING_SNAKE_CASE__						)

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

  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]       , __a :							str       , __a :							Union[str, Any] = -1       , __a :							List[Any] = -1       , __a :							str = False       , __a :							int = None       , )		->					Mapping[str, Any]:



        if self.task in ["default", "seq2seq-lm"]:
              _UpperCamelCase   :						str    =							self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                  SCREAMING_SNAKE_CASE__       , batch_size=SCREAMING_SNAKE_CASE__       , seq_length=SCREAMING_SNAKE_CASE__       , is_pair=SCREAMING_SNAKE_CASE__       , framework=SCREAMING_SNAKE_CASE__						)

        elif self.task == "causal-lm":
              _UpperCamelCase   :						Optional[Any]    =							self._generate_dummy_inputs_for_causal_lm(
                  SCREAMING_SNAKE_CASE__       , batch_size=SCREAMING_SNAKE_CASE__       , seq_length=SCREAMING_SNAKE_CASE__       , is_pair=SCREAMING_SNAKE_CASE__       , framework=SCREAMING_SNAKE_CASE__						)
        else:
              _UpperCamelCase   :						Any    =							self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                  SCREAMING_SNAKE_CASE__       , batch_size=SCREAMING_SNAKE_CASE__       , seq_length=SCREAMING_SNAKE_CASE__       , is_pair=SCREAMING_SNAKE_CASE__       , framework=SCREAMING_SNAKE_CASE__						)

        return common_inputs


  def  __SCREAMING_SNAKE_CASE					(		self :							Any       , __a :							Optional[Any]       , __a :							List[Any]       , __a :							Any       , __a :							Union[str, Any]						)		->					Dict:



        if self.task in ["default", "seq2seq-lm"]:
              _UpperCamelCase   :						Union[str, Any]    =							super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__						)
        else:
              _UpperCamelCase   :						Tuple    =							super(SCREAMING_SNAKE_CASE__       , self						)._flatten_past_key_values_(
                  SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__       , SCREAMING_SNAKE_CASE__						)




"""simple docstring"""






import warnings
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


UpperCamelCase__				:Dict			   =	logging.get_logger(__name__)

UpperCamelCase__				:int			   =	{
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							"bart"
		A    =							["past_key_values"]
		A    =							{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}
		def __init__( self					,				SCREAMING_SNAKE_CASE__=5_02_65					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__="gelu"					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=0.1					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0_2					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=False					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=3					,				SCREAMING_SNAKE_CASE__=1					,				SCREAMING_SNAKE_CASE__=0					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=2					,				**SCREAMING_SNAKE_CASE__					,				)      ->	Optional[Any]:

					"""simple docstring"""



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

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

					# ensure backward compatibility for BART CNN models
					if self.forced_bos_token_id is None and kwargs.get('''force_bos_token_to_be_generated'''					,				SCREAMING_SNAKE_CASE__   ):
								_UpperCamelCase					:Any					     =	self.bos_token_id
								warnings.warn(
								    f"Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. "
								    '''The config can simply be saved and uploaded again to be fixed.'''   )






class      A(  lowerCamelCase__		):

		"""simple docstring"""





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

					"""simple docstring"""



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

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

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

					return common_inputs
		@property
		def   _UpperCamelCase( self   )      ->	Mapping[str, Mapping[int, str]]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Optional[int]					     =	super().outputs
					else:
								_UpperCamelCase					:List[str]					     =	super(SCREAMING_SNAKE_CASE__					,				self   ).outputs
								if self.use_past:
											_UpperCamelCase     ,      _UpperCamelCase					:int					     =	self.num_layers
											for i in range(SCREAMING_SNAKE_CASE__   ):
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
					return common_outputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

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

								_UpperCamelCase					:Optional[int]					     =	torch.cat(
								    [common_inputs['''decoder_attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )]					,				dim=1   )

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

								for _ in range(SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											    )   )
								# TODO: test this.
								_UpperCamelCase					:Optional[int]					     =	encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
								for _ in range(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append((torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   ))   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_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					:List[Any]					     =	common_inputs['''input_ids'''].shape
								# Not using the same length for past_key_values
								_UpperCamelCase					:str					     =	seqlen + 2
								_UpperCamelCase     ,      _UpperCamelCase					:Dict					     =	self.num_layers
								_UpperCamelCase     ,      _UpperCamelCase					:Union[str, Any]					     =	self.num_attention_heads
								_UpperCamelCase					:List[Any]					     =	(
								    batch,
								    num_encoder_attention_heads,
								    past_key_values_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)

								_UpperCamelCase					:Tuple					     =	common_inputs['''attention_mask'''].dtype
								_UpperCamelCase					:List[Any]					     =	torch.cat(
								    [common_inputs['''attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				dtype=SCREAMING_SNAKE_CASE__   )]					,				dim=1   )
								_UpperCamelCase					:int					     =	[
								    (torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   )) for _ in range(SCREAMING_SNAKE_CASE__   )
								]
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	compute_effective_axis_dimension(
					    SCREAMING_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					:str					     =	tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:str					     =	compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__					,				fixed_dimension=OnnxConfig.default_fixed_sequence					,				num_token_to_add=SCREAMING_SNAKE_CASE__   )

					# Generate dummy inputs according to compute batch and sequence
					_UpperCamelCase					:List[Any]					     =	[''' '''.join([tokenizer.unk_token]   ) * seq_length] * batch_size
					_UpperCamelCase					:Optional[Any]					     =	dict(tokenizer(SCREAMING_SNAKE_CASE__					,				return_tensors=SCREAMING_SNAKE_CASE__   )   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )

					elif self.task == "causal-lm":
								_UpperCamelCase					:Optional[Any]					     =	self._generate_dummy_inputs_for_causal_lm(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )
					else:
								_UpperCamelCase					:Any					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )

					return common_inputs





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	Dict:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Union[str, Any]					     =	super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
					else:
								_UpperCamelCase					:Tuple					     =	super(SCREAMING_SNAKE_CASE__					,				self   )._flatten_past_key_values_(
								    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

