

'''simple docstring'''






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

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


lowerCAmelCase__   		=      logging.get_logger(__name__)

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






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE       :    Dict							     =     'blenderbot-small'
  SCREAMING_SNAKE_CASE       :    int							     =     ['past_key_values']
  SCREAMING_SNAKE_CASE       :    List[str]							     =     {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}






  def __init__( self  :	Optional[int]   ,lowercase__  :	List[str]=5_0_2_6_5   ,lowercase__  :	Optional[Any]=5_1_2   ,lowercase__  :	Optional[int]=8   ,lowercase__  :	List[Any]=2_0_4_8   ,lowercase__  :	List[str]=1_6   ,lowercase__  :	str=8   ,lowercase__  :	Any=2_0_4_8   ,lowercase__  :	Tuple=1_6   ,lowercase__  :	Tuple=0.0   ,lowercase__  :	List[str]=0.0   ,lowercase__  :	Any=True   ,lowercase__  :	str=True   ,lowercase__  :	int="gelu"   ,lowercase__  :	Tuple=5_1_2   ,lowercase__  :	List[Any]=0.1   ,lowercase__  :	Tuple=0.0   ,lowercase__  :	str=0.0   ,lowercase__  :	Any=0.0_2   ,lowercase__  :	Union[str, Any]=1   ,lowercase__  :	List[Any]=False   ,lowercase__  :	Optional[int]=0   ,lowercase__  :	Optional[int]=1   ,lowercase__  :	str=2   ,lowercase__  :	int=2   ,**lowercase__  :	List[str]   ,):
   __lowercase				    =					vocab_size
   __lowercase				    =					max_position_embeddings
   __lowercase				    =					d_model
   __lowercase				    =					encoder_ffn_dim
   __lowercase				    =					encoder_layers
   __lowercase				    =					encoder_attention_heads
   __lowercase				    =					decoder_ffn_dim
   __lowercase				    =					decoder_layers
   __lowercase				    =					decoder_attention_heads
   __lowercase				    =					dropout
   __lowercase				    =					attention_dropout
   __lowercase				    =					activation_dropout
   __lowercase				    =					activation_function
   __lowercase				    =					init_std
   __lowercase				    =					encoder_layerdrop
   __lowercase				    =					decoder_layerdrop
   __lowercase				    =					use_cache
   __lowercase				    =					encoder_layers
   __lowercase				    =					scale_embedding  # scale factor will be sqrt(d_model) if True

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






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  @property
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					OrderedDict(
        [
            ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
        ]     )

    if self.use_past:
     __lowercase				    =					{0: '''batch'''}
     __lowercase				    =					{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
    else:
     __lowercase				    =					{0: '''batch''', 1: '''decoder_sequence'''}
     __lowercase				    =					{0: '''batch''', 1: '''decoder_sequence'''}

    if self.use_past:
     self.fill_with_past_key_values_(lowercase__   ,direction='''inputs'''     )
   elif self.task == "causal-lm":
    # TODO: figure this case out.
    __lowercase				    =					OrderedDict(
        [
            ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
        ]     )
    if self.use_past:
     __lowercase    ,      __lowercase				    =					self.num_layers
     for i in range(lowercase__     ):
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
   else:
    __lowercase				    =					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  :	List[Any]     ):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					super().outputs
   else:
    __lowercase				    =					super(lowercase__   ,self     ).outputs
    if self.use_past:
     __lowercase    ,      __lowercase				    =					self.num_layers
     for i in range(lowercase__     ):
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
   return common_outputs






  def    SCREAMING_SNAKE_CASE ( self  :	Dict   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	Optional[TensorType] = None   ,):
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )

   # Generate decoder inputs
   __lowercase				    =					seq_length if not self.use_past else 1
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )
   __lowercase				    =					{F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
   __lowercase				    =					dict(**lowercase__   ,**lowercase__     )

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

    __lowercase				    =					torch.cat(
        [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase__   ,lowercase__     )]   ,dim=1     )

    __lowercase				    =					[]
    # If the number of encoder and decoder layers are present in the model configuration, both are considered
    __lowercase    ,      __lowercase				    =					self.num_layers
    __lowercase				    =					min(lowercase__   ,lowercase__     )
    __lowercase				    =					max(lowercase__   ,lowercase__     ) - min_num_layers
    __lowercase				    =					'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

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






  def    SCREAMING_SNAKE_CASE ( self  :	Any   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	Optional[TensorType] = None   ,):
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )

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

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






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	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
   __lowercase				    =					compute_effective_axis_dimension(
       lowercase__   ,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
   __lowercase				    =					tokenizer.num_special_tokens_to_add(lowercase__     )
   __lowercase				    =					compute_effective_axis_dimension(
       lowercase__   ,fixed_dimension=OnnxConfig.default_fixed_sequence   ,num_token_to_add=lowercase__     )

   # Generate dummy inputs according to compute batch and sequence
   __lowercase				    =					[''' '''.join([tokenizer.unk_token]     ) * seq_length] * batch_size
   __lowercase				    =					dict(tokenizer(lowercase__   ,return_tensors=lowercase__     )     )
   return common_inputs






  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	Optional[TensorType] = None   ,):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
        lowercase__   ,batch_size=lowercase__   ,seq_length=lowercase__   ,is_pair=lowercase__   ,framework=lowercase__     )

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

   return common_inputs






  def    SCREAMING_SNAKE_CASE ( self  :	Tuple   ,lowercase__  :	List[Any]   ,lowercase__  :	Tuple   ,lowercase__  :	List[Any]   ,lowercase__  :	Optional[Any]     ):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					super()._flatten_past_key_values_(lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )
   else:
    __lowercase				    =					super(lowercase__   ,self     )._flatten_past_key_values_(
        lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )








"""simple docstring"""





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

_UpperCamelCase					      =   {
    'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json',
    # See all Marian models at https://huggingface.co/models?filter=marian
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Tuple									=		"""marian"""
				__snake_case :							Any									=		["""past_key_values"""]
				__snake_case :							Optional[Any]									=		{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}




				def __init__(  self	:List[Any]    ,     __lowercase	:Any=5_8101    ,     __lowercase	:Tuple=None    ,     __lowercase	:Union[str, Any]=1024    ,     __lowercase	:Dict=12    ,     __lowercase	:int=4096    ,     __lowercase	:int=16    ,     __lowercase	:List[Any]=12    ,     __lowercase	:Dict=4096    ,     __lowercase	:Dict=16    ,     __lowercase	:Tuple=0.0    ,     __lowercase	:Tuple=0.0    ,     __lowercase	:List[Any]=True    ,     __lowercase	:int=True    ,     __lowercase	:Tuple="gelu"    ,     __lowercase	:str=1024    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:List[str]=0.0    ,     __lowercase	:Union[str, Any]=0.0    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Tuple=5_8100    ,     __lowercase	:Optional[Any]=False    ,     __lowercase	:int=5_8100    ,     __lowercase	:Any=0    ,     __lowercase	:str=0    ,     __lowercase	:str=True    ,     **__lowercase	:Any    ,     ):
											__lowerCamelCase   :   List[Any]       =vocab_size
											__lowerCamelCase   :   Optional[int]       =decoder_vocab_size or vocab_size
											__lowerCamelCase   :   Tuple       =max_position_embeddings
											__lowerCamelCase   :   List[Any]       =d_model
											__lowerCamelCase   :   Any       =encoder_ffn_dim
											__lowerCamelCase   :   str       =encoder_layers
											__lowerCamelCase   :   List[str]       =encoder_attention_heads
											__lowerCamelCase   :   str       =decoder_ffn_dim
											__lowerCamelCase   :   Tuple       =decoder_layers
											__lowerCamelCase   :   Any       =decoder_attention_heads
											__lowerCamelCase   :   List[Any]       =dropout
											__lowerCamelCase   :   Any       =attention_dropout
											__lowerCamelCase   :   Union[str, Any]       =activation_dropout
											__lowerCamelCase   :   Optional[int]       =activation_function
											__lowerCamelCase   :   Dict       =init_std
											__lowerCamelCase   :   List[Any]       =encoder_layerdrop
											__lowerCamelCase   :   Optional[Any]       =decoder_layerdrop
											__lowerCamelCase   :   Any       =use_cache
											__lowerCamelCase   :   Any       =encoder_layers
											__lowerCamelCase   :   Optional[int]       =scale_embedding  # scale factor will be sqrt(d_model) if True
											__lowerCamelCase   :   int       =share_encoder_decoder_embeddings
											super().__init__(
											    pad_token_id=__lowercase    ,     eos_token_id=__lowercase    ,     is_encoder_decoder=__lowercase    ,     decoder_start_token_id=__lowercase    ,     forced_eos_token_id=__lowercase    ,     **__lowercase    ,     )

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""




				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
				def        __lowercase	(  self	:int      ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   Tuple       =OrderedDict(
																		    [
																		        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		    ]      )

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

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

											return common_inputs




				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
				def        __lowercase	(  self	:Optional[int]      ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   Tuple       =super().outputs
											else:
																		__lowerCamelCase   :   List[str]       =super(__lowercase    ,     self      ).outputs
																		if self.use_past:
																									__lowerCamelCase     ,    __lowerCamelCase   :   int       =self.num_layers
																									for i in range(__lowercase      ):
																																__lowerCamelCase   :   Any       ={0: '''batch''', 2: '''past_sequence + sequence'''}
																																__lowerCamelCase   :   Optional[int]       ={0: '''batch''', 2: '''past_sequence + sequence'''}
											return common_outputs




				def        __lowercase	(  self	:str    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											__lowerCamelCase   :   List[str]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )

											# Generate decoder inputs
											__lowerCamelCase   :   Optional[Any]       =seq_length if not self.use_past else 1
											__lowerCamelCase   :   List[Any]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )
											__lowerCamelCase   :   Dict       ={f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
											__lowerCamelCase   :   str       =dict(**__lowercase    ,     **__lowercase      )

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

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

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

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




				def        __lowercase	(  self	:Dict    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											__lowerCamelCase   :   List[str]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )

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

																		__lowerCamelCase   :   Any       =common_inputs['''attention_mask'''].dtype
																		__lowerCamelCase   :   Optional[int]       =torch.cat(
																		    [common_inputs['''attention_mask'''], torch.ones(__lowercase    ,     __lowercase    ,     dtype=__lowercase      )]    ,     dim=1      )
																		__lowerCamelCase   :   List[str]       =[
																		    (torch.zeros(__lowercase      ), torch.zeros(__lowercase      )) for _ in range(__lowercase      )
																		]
											return common_inputs




				def        __lowercase	(  self	:int    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	: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
											__lowerCamelCase   :   Union[str, Any]       =compute_effective_axis_dimension(
											    __lowercase    ,     fixed_dimension=OnnxConfig.default_fixed_batch    ,     num_token_to_add=0      )

											# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
											__lowerCamelCase   :   Optional[int]       =tokenizer.num_special_tokens_to_add(__lowercase      )
											__lowerCamelCase   :   Optional[int]       =compute_effective_axis_dimension(
											    __lowercase    ,     fixed_dimension=OnnxConfig.default_fixed_sequence    ,     num_token_to_add=__lowercase      )

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




				def        __lowercase	(  self	:Tuple    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   int       =self._generate_dummy_inputs_for_default_and_seqaseq_lm(
																		    __lowercase    ,     batch_size=__lowercase    ,     seq_length=__lowercase    ,     is_pair=__lowercase    ,     framework=__lowercase      )

											else:
																		__lowerCamelCase   :   List[Any]       =self._generate_dummy_inputs_for_causal_lm(
																		    __lowercase    ,     batch_size=__lowercase    ,     seq_length=__lowercase    ,     is_pair=__lowercase    ,     framework=__lowercase      )

											return common_inputs




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




				@property
				def        __lowercase	(  self	:List[str]      ):
											return 1e-4




