



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/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}



class 		_snake_case      (			__lowerCamelCase				):





	"""simple docstring"""



	lowerCamelCase_          =			'''mbart'''
	lowerCamelCase_          =			['''past_key_values''']
	lowerCamelCase_          =			{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
	def __init__(						self	,    a=5_0_2_6_5	,    a=1_0_2_4	,    a=1_2	,    a=4_0_9_6	,    a=1_6	,    a=1_2	,    a=4_0_9_6	,    a=1_6	,    a=0.0	,    a=0.0	,    a=True	,    a=True	,    a="gelu"	,    a=1_0_2_4	,    a=0.1	,    a=0.0	,    a=0.0	,    a=0.02	,    a=0.0	,    a=False	,    a=1	,    a=0	,    a=2	,    a=2	,    **a	,    )	->							List[str]:




			"""simple docstring"""







			_A           =    vocab_size
			_A           =    max_position_embeddings
			_A           =    d_model
			_A           =    encoder_ffn_dim
			_A           =    encoder_layers
			_A           =    encoder_attention_heads
			_A           =    decoder_ffn_dim
			_A           =    decoder_layers
			_A           =    decoder_attention_heads
			_A           =    dropout
			_A           =    attention_dropout
			_A           =    activation_dropout
			_A           =    activation_function
			_A           =    init_std
			_A           =    encoder_layerdrop
			_A           =    decoder_layerdrop
			_A           =    classifier_dropout
			_A           =    use_cache
			_A           =    encoder_layers
			_A           =    scale_embedding  # scale factor will be sqrt(d_model) if True
			super().__init__(
			    pad_token_id=_lowerCAmelCase	,    bos_token_id=_lowerCAmelCase	,    eos_token_id=_lowerCAmelCase	,    is_encoder_decoder=_lowerCAmelCase	,    forced_eos_token_id=_lowerCAmelCase	,    **_lowerCAmelCase	,    )







class 		_snake_case      (			__lowerCamelCase				):





	"""simple docstring"""



	@property
	def lowercase_		(						self					)	->							List[str]:




			"""simple docstring"""







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

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

					if self.use_past:
							self.fill_with_past_key_values_(_lowerCAmelCase	,    direction='''inputs'''					)
			elif self.task == "causal-lm":
					# TODO: figure this case out.
					_A           =    OrderedDict(
					    [
					        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
					        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
					    ]					)
					if self.use_past:
							_A           =    self.num_layers
							for i in range(_lowerCAmelCase					):
									_A           =    {0: """batch""", 2: """past_sequence + sequence"""}
									_A           =    {0: """batch""", 2: """past_sequence + sequence"""}
			else:
					_A           =    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 lowercase_		(						self					)	->							Union[str, Any]:




			"""simple docstring"""







			if self.task in ["default", "seq2seq-lm"]:
					_A           =    super().outputs
			else:
					_A           =    super(_lowerCAmelCase	,    self					).outputs
					if self.use_past:
							_A           =    self.num_layers
							for i in range(_lowerCAmelCase					):
									_A           =    {0: """batch""", 2: """past_sequence + sequence"""}
									_A           =    {0: """batch""", 2: """past_sequence + sequence"""}
			return common_outputs
	def lowercase_		(						self	,    a	,    a = -1	,    a = -1	,    a = False	,    a = None	,    )	->							str:




			"""simple docstring"""







			_A           =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase					)

			# Generate decoder inputs
			_A           =    seq_length if not self.use_past else 1
			_A           =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase					)
			_A           =    {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
			_A           =    dict(**_lowerCAmelCase	,    **_lowerCAmelCase					)

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

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

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

					for _ in range(_lowerCAmelCase					):
							common_inputs["past_key_values"].append(
							    (
							        torch.zeros(_lowerCAmelCase					),
							        torch.zeros(_lowerCAmelCase					),
							        torch.zeros(_lowerCAmelCase					),
							        torch.zeros(_lowerCAmelCase					),
							    )					)
					# TODO: test this.
					_A           =    encoder_shape if remaining_side_name == """encoder""" else decoder_shape
					for _ in range(_lowerCAmelCase	,    _lowerCAmelCase					):
							common_inputs["past_key_values"].append((torch.zeros(_lowerCAmelCase					), torch.zeros(_lowerCAmelCase					))					)
			return common_inputs
	def lowercase_		(						self	,    a	,    a = -1	,    a = -1	,    a = False	,    a = None	,    )	->							str:




			"""simple docstring"""







			_A           =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase					)

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

					_A           =    common_inputs["""attention_mask"""].dtype
					_A           =    torch.cat(
					    [common_inputs['''attention_mask'''], torch.ones(_lowerCAmelCase	,    _lowerCAmelCase	,    dtype=_lowerCAmelCase					)]	,    dim=1					)
					_A           =    [
					    (torch.zeros(_lowerCAmelCase					), torch.zeros(_lowerCAmelCase					)) for _ in range(_lowerCAmelCase					)
					]
			return common_inputs
	def lowercase_		(						self	,    a	,    a = -1	,    a = -1	,    a = False	,    a = None	,    )	->							Any:




			"""simple docstring"""







			_A           =    compute_effective_axis_dimension(
			    _lowerCAmelCase	,    fixed_dimension=OnnxConfig.default_fixed_batch	,    num_token_to_add=0					)

			# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
			_A           =    tokenizer.num_special_tokens_to_add(_lowerCAmelCase					)
			_A           =    compute_effective_axis_dimension(
			    _lowerCAmelCase	,    fixed_dimension=OnnxConfig.default_fixed_sequence	,    num_token_to_add=_lowerCAmelCase					)

			# Generate dummy inputs according to compute batch and sequence
			_A           =    [""" """.join([tokenizer.unk_token]					) * seq_length] * batch_size
			_A           =    dict(tokenizer(_lowerCAmelCase	,    return_tensors=_lowerCAmelCase					)					)
			return common_inputs
	def lowercase_		(						self	,    a	,    a = -1	,    a = -1	,    a = False	,    a = None	,    )	->							Any:




			"""simple docstring"""







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

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

			return common_inputs



	def lowercase_		(						self	,    a	,    a	,    a	,    a					)	->							Tuple:




			"""simple docstring"""







			if self.task in ["default", "seq2seq-lm"]:
					_A           =    super()._flatten_past_key_values_(_lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase					)
			else:
					_A           =    super(_lowerCAmelCase	,    self					)._flatten_past_key_values_(
					    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase	,    _lowerCAmelCase					)




import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase  				=					logging.get_logger(__name__)

__lowerCamelCase  				=					{}



class 		_snake_case      (			lowerCamelCase				):





 """simple docstring"""



 lowerCamelCase_          =			'''fsmt_decoder'''
 def __init__(						self	,    a=0	,    a=0					)	->							str:




   """simple docstring"""







   super().__init__()
   _A           =    vocab_size
   _A           =    bos_token_id







class 		_snake_case      (			lowerCamelCase				):





 """simple docstring"""



 lowerCamelCase_          =			'''fsmt'''
 lowerCamelCase_          =			{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
 def __init__(						self	,    a=["en", "de"]	,    a=4_2_0_2_4	,    a=4_2_0_2_4	,    a="relu"	,    a=1_0_2_4	,    a=2_0_0	,    a=1_0_2_4	,    a=4_0_9_6	,    a=1_2	,    a=1_6	,    a=0.0	,    a=4_0_9_6	,    a=1_2	,    a=1_6	,    a=0.0	,    a=0.0	,    a=0.1	,    a=0.0	,    a=0.02	,    a=2	,    a=True	,    a=True	,    a=False	,    a=5	,    a=1.0	,    a=False	,    a=True	,    a=1	,    a=0	,    a=2	,    a=2	,    **a	,    )	->							Union[str, Any]:




   """simple docstring"""







   _A           =    langs
   _A           =    src_vocab_size
   _A           =    tgt_vocab_size
   _A           =    d_model  # encoder_embed_dim and decoder_embed_dim

   _A           =    encoder_ffn_dim
   _A           =    _A           =    encoder_layers
   _A           =    encoder_attention_heads
   _A           =    encoder_layerdrop
   _A           =    decoder_layerdrop
   _A           =    decoder_ffn_dim
   _A           =    decoder_layers
   _A           =    decoder_attention_heads
   _A           =    max_position_embeddings
   _A           =    init_std  # Normal(0, this parameter)
   _A           =    activation_function

   _A           =    DecoderConfig(vocab_size=a	,    bos_token_id=a					)
   if "decoder" in common_kwargs:
     del common_kwargs["decoder"]

   _A           =    scale_embedding  # scale factor will be sqrt(d_model) if True

   # 3 Types of Dropout
   _A           =    attention_dropout
   _A           =    activation_dropout
   _A           =    dropout

   _A           =    use_cache
   super().__init__(
       pad_token_id=a	,    bos_token_id=a	,    eos_token_id=a	,    decoder_start_token_id=a	,    is_encoder_decoder=a	,    tie_word_embeddings=a	,    forced_eos_token_id=a	,    max_length=a	,    num_beams=a	,    length_penalty=a	,    early_stopping=a	,    **a	,    )



 def lowercase_		(						self					)	->							Any:




   """simple docstring"""







   _A           =    copy.deepcopy(self.__dict__					)
   _A           =    self.decoder.to_dict()
   _A           =    self.__class__.model_type
   return output