


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

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


a__    :							Optional[int]            =					logging.get_logger(__name__)

a__    :							Union[str, Any]            =					{
    '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 			UpperCamelCase_     (			_lowerCAmelCase):

	"""simple docstring"""





	snake_case__    :  int    =      "marian"
	snake_case__    :  Optional[int]    =      ["past_key_values"]
	snake_case__    :  Any    =      {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}




	def __init__(			self      :    List[Any]      ,      UpperCAmelCase__      :    Optional[int]=5_8_1_0_1      ,      UpperCAmelCase__      :    int=None      ,      UpperCAmelCase__      :    Any=1_0_2_4      ,      UpperCAmelCase__      :    Any=1_2      ,      UpperCAmelCase__      :    List[str]=4_0_9_6      ,      UpperCAmelCase__      :    Any=1_6      ,      UpperCAmelCase__      :    List[Any]=1_2      ,      UpperCAmelCase__      :    List[str]=4_0_9_6      ,      UpperCAmelCase__      :    Any=1_6      ,      UpperCAmelCase__      :    List[str]=0.0      ,      UpperCAmelCase__      :    Union[str, Any]=0.0      ,      UpperCAmelCase__      :    str=True      ,      UpperCAmelCase__      :    str=True      ,      UpperCAmelCase__      :    List[str]="gelu"      ,      UpperCAmelCase__      :    Optional[Any]=1_0_2_4      ,      UpperCAmelCase__      :    int=0.1      ,      UpperCAmelCase__      :    List[Any]=0.0      ,      UpperCAmelCase__      :    Optional[Any]=0.0      ,      UpperCAmelCase__      :    List[Any]=0.02      ,      UpperCAmelCase__      :    Optional[int]=5_8_1_0_0      ,      UpperCAmelCase__      :    Tuple=False      ,      UpperCAmelCase__      :    Optional[int]=5_8_1_0_0      ,      UpperCAmelCase__      :    Dict=0      ,      UpperCAmelCase__      :    Optional[Any]=0      ,      UpperCAmelCase__      :    str=True      ,      **UpperCAmelCase__      :    Optional[int]      ,      )	->     Tuple:
						__SCREAMING_SNAKE_CASE						       =    vocab_size
						__SCREAMING_SNAKE_CASE						       =    decoder_vocab_size or vocab_size
						__SCREAMING_SNAKE_CASE						       =    max_position_embeddings
						__SCREAMING_SNAKE_CASE						       =    d_model
						__SCREAMING_SNAKE_CASE						       =    encoder_ffn_dim
						__SCREAMING_SNAKE_CASE						       =    encoder_layers
						__SCREAMING_SNAKE_CASE						       =    encoder_attention_heads
						__SCREAMING_SNAKE_CASE						       =    decoder_ffn_dim
						__SCREAMING_SNAKE_CASE						       =    decoder_layers
						__SCREAMING_SNAKE_CASE						       =    decoder_attention_heads
						__SCREAMING_SNAKE_CASE						       =    dropout
						__SCREAMING_SNAKE_CASE						       =    attention_dropout
						__SCREAMING_SNAKE_CASE						       =    activation_dropout
						__SCREAMING_SNAKE_CASE						       =    activation_function
						__SCREAMING_SNAKE_CASE						       =    init_std
						__SCREAMING_SNAKE_CASE						       =    encoder_layerdrop
						__SCREAMING_SNAKE_CASE						       =    decoder_layerdrop
						__SCREAMING_SNAKE_CASE						       =    use_cache
						__SCREAMING_SNAKE_CASE						       =    encoder_layers
						__SCREAMING_SNAKE_CASE						       =    scale_embedding  # scale factor will be sqrt(d_model) if True
						__SCREAMING_SNAKE_CASE						       =    share_encoder_decoder_embeddings
						super().__init__(
						    pad_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_      ,      )




class 			UpperCamelCase_     (			_lowerCAmelCase):

	"""simple docstring"""





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

											if self.use_past:
																__SCREAMING_SNAKE_CASE						       =    {0: """batch"""}
																__SCREAMING_SNAKE_CASE						       =    {0: """batch""", 1: """past_decoder_sequence + sequence"""}
											else:
																__SCREAMING_SNAKE_CASE						       =    {0: """batch""", 1: """decoder_sequence"""}
																__SCREAMING_SNAKE_CASE						       =    {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.
											__SCREAMING_SNAKE_CASE						       =    OrderedDict(
											    [
											        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
											        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
											    ]       )
											if self.use_past:
																__SCREAMING_SNAKE_CASE						       =    self.num_layers
																for i in range(SCREAMING_SNAKE_CASE_       ):
																					__SCREAMING_SNAKE_CASE						       =    {0: """batch""", 2: """past_sequence + sequence"""}
																					__SCREAMING_SNAKE_CASE						       =    {0: """batch""", 2: """past_sequence + sequence"""}
						else:
											__SCREAMING_SNAKE_CASE						       =    OrderedDict(
											    [
											        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
											        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
											        ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
											        ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
											    ]       )

						return common_inputs




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




	def   UpperCAmelCase_				(			self      :    int      ,      UpperCAmelCase__      :    int      ,      UpperCAmelCase__      :    str = -1      ,      UpperCAmelCase__      :    List[Any] = -1      ,      UpperCAmelCase__      :    Dict = False      ,      UpperCAmelCase__      :    List[str] = None      ,      )	->     Mapping[str, Any]:
						__SCREAMING_SNAKE_CASE						       =    self._generate_dummy_inputs_for_encoder_and_decoder(
						    SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )

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

											__SCREAMING_SNAKE_CASE						       =    torch.cat(
											    [common_inputs["decoder_attention_mask"], torch.ones(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )]      ,      dim=1       )

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

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




	def   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    Any      ,      UpperCAmelCase__      :    List[str] = -1      ,      UpperCAmelCase__      :    List[str] = -1      ,      UpperCAmelCase__      :    int = False      ,      UpperCAmelCase__      :    List[str] = None      ,      )	->     Mapping[str, Any]:
						# Copied from OnnxConfig.generate_dummy_inputs
						# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
						# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
						__SCREAMING_SNAKE_CASE						       =    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
						__SCREAMING_SNAKE_CASE						       =    tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE_       )
						__SCREAMING_SNAKE_CASE						       =    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
						__SCREAMING_SNAKE_CASE						       =    [""" """.join([tokenizer.unk_token]       ) * seq_length] * batch_size
						__SCREAMING_SNAKE_CASE						       =    dict(tokenizer(SCREAMING_SNAKE_CASE_      ,      return_tensors=SCREAMING_SNAKE_CASE_       )       )
						return common_inputs




	def   UpperCAmelCase_				(			self      :    Optional[int]      ,      UpperCAmelCase__      :    Tuple      ,      UpperCAmelCase__      :    Optional[int] = -1      ,      UpperCAmelCase__      :    Optional[Any] = -1      ,      UpperCAmelCase__      :    Optional[int] = False      ,      UpperCAmelCase__      :    Optional[Any] = None      ,      )	->     Mapping[str, Any]:
						if self.task in ["default", "seq2seq-lm"]:
											__SCREAMING_SNAKE_CASE						       =    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_       )

						else:
											__SCREAMING_SNAKE_CASE						       =    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_       )

						return common_inputs




	def   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    List[Any]      ,      UpperCAmelCase__      :    List[str]      ,      UpperCAmelCase__      :    Optional[int]      ,      UpperCAmelCase__      :    int       )	->     Dict:
						if self.task in ["default", "seq2seq-lm"]:
											__SCREAMING_SNAKE_CASE						       =    super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )
						else:
											__SCREAMING_SNAKE_CASE						       =    super(SCREAMING_SNAKE_CASE_      ,      self       )._flatten_past_key_values_(
											    SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )




	@property
	def   UpperCAmelCase_				(			self      :    str       )	->     float:
						return 1E-4




"""simple docstring"""







from __future__ import annotations




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					if not nums:
										return 0
					__SCREAMING_SNAKE_CASE						       =    nums[0]
					__SCREAMING_SNAKE_CASE						       =    0
					for num in nums[1:]:
										__SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE						       =    (
										    max_excluding + num,
										    max(lowerCAmelCase_  ,						lowerCAmelCase_       ),
										)
					return max(lowerCAmelCase_  ,						lowerCAmelCase_       )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
