



"""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


A_						:    Union[str, Any]				=      logging.get_logger(__name__)

A_						:    Optional[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     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		Dict  						= '''marian'''
	_SCREAMING_SNAKE_CASE	:		int  						= ['''past_key_values''']
	_SCREAMING_SNAKE_CASE	:		str  						= {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}





	def __init__(      self				:       List[str]     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=58_101     ,       _SCREAMING_SNAKE_CASE				:       str=None     ,       _SCREAMING_SNAKE_CASE				:       str=1_024     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]=12     ,       _SCREAMING_SNAKE_CASE				:       Dict=4_096     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]=16     ,       _SCREAMING_SNAKE_CASE				:       int=12     ,       _SCREAMING_SNAKE_CASE				:       Any=4_096     ,       _SCREAMING_SNAKE_CASE				:       Dict=16     ,       _SCREAMING_SNAKE_CASE				:       List[str]=0.0     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=0.0     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=True     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=True     ,       _SCREAMING_SNAKE_CASE				:       List[str]="gelu"     ,       _SCREAMING_SNAKE_CASE				:       Tuple=1_024     ,       _SCREAMING_SNAKE_CASE				:       Dict=0.1     ,       _SCREAMING_SNAKE_CASE				:       Any=0.0     ,       _SCREAMING_SNAKE_CASE				:       List[str]=0.0     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=0.0_2     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]=58_100     ,       _SCREAMING_SNAKE_CASE				:       Dict=False     ,       _SCREAMING_SNAKE_CASE				:       str=58_100     ,       _SCREAMING_SNAKE_CASE				:       Tuple=0     ,       _SCREAMING_SNAKE_CASE				:       Tuple=0     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=True     ,       **_SCREAMING_SNAKE_CASE				:       int     ,       )						->	Union[str, Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							int							=     vocab_size
					SCREAMING_SNAKE_CASE						:							Any							=     decoder_vocab_size or vocab_size
					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     max_position_embeddings
					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     d_model
					SCREAMING_SNAKE_CASE						:							Tuple							=     encoder_ffn_dim
					SCREAMING_SNAKE_CASE						:							Any							=     encoder_layers
					SCREAMING_SNAKE_CASE						:							str							=     encoder_attention_heads
					SCREAMING_SNAKE_CASE						:							Dict							=     decoder_ffn_dim
					SCREAMING_SNAKE_CASE						:							Tuple							=     decoder_layers
					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     decoder_attention_heads
					SCREAMING_SNAKE_CASE						:							Any							=     dropout
					SCREAMING_SNAKE_CASE						:							int							=     attention_dropout
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     activation_dropout
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     activation_function
					SCREAMING_SNAKE_CASE						:							str							=     init_std
					SCREAMING_SNAKE_CASE						:							Any							=     encoder_layerdrop
					SCREAMING_SNAKE_CASE						:							Any							=     decoder_layerdrop
					SCREAMING_SNAKE_CASE						:							Any							=     use_cache
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     encoder_layers
					SCREAMING_SNAKE_CASE						:							List[Any]							=     scale_embedding  # scale factor will be sqrt(d_model) if True
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     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     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	@property
	# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
	def 			_lowerCAmelCase     (      self				:       List[Any]    )						->	Mapping[str, Mapping[int, str]]:





					"""simple docstring"""


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

									if self.use_past:
													SCREAMING_SNAKE_CASE						:							int							=     {0: 'batch'}
													SCREAMING_SNAKE_CASE						:							str							=     {0: 'batch', 1: 'past_decoder_sequence + sequence'}
									else:
													SCREAMING_SNAKE_CASE						:							Any							=     {0: 'batch', 1: 'decoder_sequence'}
													SCREAMING_SNAKE_CASE						:							List[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.
									SCREAMING_SNAKE_CASE						:							Tuple							=     OrderedDict(
									    [
									        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
									        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
									    ]    )
									if self.use_past:
													SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						:							List[str]							=     self.num_layers
													for i in range(_SCREAMING_SNAKE_CASE    ):
																	SCREAMING_SNAKE_CASE						:							List[Any]							=     {0: 'batch', 2: 'past_sequence + sequence'}
																	SCREAMING_SNAKE_CASE						:							Tuple							=     {0: 'batch', 2: 'past_sequence + sequence'}
					else:
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     OrderedDict(
									    [
									        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
									        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
									        ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
									        ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
									    ]    )

					return common_inputs





	@property
	# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Mapping[str, Mapping[int, str]]:





					"""simple docstring"""


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





	def 			_lowerCAmelCase     (      self				:       Tuple     ,       _SCREAMING_SNAKE_CASE				:       PreTrainedTokenizer     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       bool = False     ,       _SCREAMING_SNAKE_CASE				:       Optional[TensorType] = None     ,       )						->	Mapping[str, Any]:





					"""simple docstring"""


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

									SCREAMING_SNAKE_CASE						:							Any							=     torch.cat(
									    [common_inputs['decoder_attention_mask'], torch.ones(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )]     ,       dim=1    )

									SCREAMING_SNAKE_CASE						:							Any							=     []
									# If the number of encoder and decoder layers are present in the model configuration, both are considered
									SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						:							Any							=     self.num_layers
									SCREAMING_SNAKE_CASE						:							Dict							=     min(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE						:							str							=     max(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    ) - min_num_layers
									SCREAMING_SNAKE_CASE						:							str							=     '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						:							List[str]							=     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 			_lowerCAmelCase     (      self				:       int     ,       _SCREAMING_SNAKE_CASE				:       PreTrainedTokenizer     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       bool = False     ,       _SCREAMING_SNAKE_CASE				:       Optional[TensorType] = None     ,       )						->	Mapping[str, Any]:





					"""simple docstring"""


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

									SCREAMING_SNAKE_CASE						:							List[Any]							=     common_inputs['attention_mask'].dtype
									SCREAMING_SNAKE_CASE						:							Dict							=     torch.cat(
									    [common_inputs['attention_mask'], torch.ones(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       dtype=_SCREAMING_SNAKE_CASE    )]     ,       dim=1    )
									SCREAMING_SNAKE_CASE						:							Tuple							=     [
									    (torch.zeros(_SCREAMING_SNAKE_CASE    ), torch.zeros(_SCREAMING_SNAKE_CASE    )) for _ in range(_SCREAMING_SNAKE_CASE    )
									]
					return common_inputs





	def 			_lowerCAmelCase     (      self				:       Optional[Any]     ,       _SCREAMING_SNAKE_CASE				:       PreTrainedTokenizer     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       bool = False     ,       _SCREAMING_SNAKE_CASE				:       Optional[TensorType] = None     ,       )						->	Mapping[str, Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							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
					SCREAMING_SNAKE_CASE						:							Dict							=     tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							Any							=     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						:							str							=     [' '.join([tokenizer.unk_token]    ) * seq_length] * batch_size
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     dict(tokenizer(_SCREAMING_SNAKE_CASE     ,       return_tensors=_SCREAMING_SNAKE_CASE    )    )
					return common_inputs





	def 			_lowerCAmelCase     (      self				:       Union[str, Any]     ,       _SCREAMING_SNAKE_CASE				:       PreTrainedTokenizer     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       bool = False     ,       _SCREAMING_SNAKE_CASE				:       Optional[TensorType] = None     ,       )						->	Mapping[str, Any]:





					"""simple docstring"""


					if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE						:							Tuple							=     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						:							Optional[int]							=     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 			_lowerCAmelCase     (      self				:       List[Any]     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]     ,       _SCREAMING_SNAKE_CASE				:       List[Any]     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]     ,       _SCREAMING_SNAKE_CASE				:       int    )						->	Dict:





					"""simple docstring"""


					if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE						:							str							=     super()._flatten_past_key_values_(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
					else:
									SCREAMING_SNAKE_CASE						:							Tuple							=     super(_SCREAMING_SNAKE_CASE     ,       self    )._flatten_past_key_values_(
									    _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )







	@property
	def 			_lowerCAmelCase     (      self				:       List[Any]    )						->	float:





					"""simple docstring"""


					return 1E-4










"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


A_						:    Optional[int]				=      {
    'configuration_llama': ['LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LlamaConfig'],
}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    int				=      ['LlamaTokenizer']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    List[str]				=      ['LlamaTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    List[str]				=      [
							    'LlamaForCausalLM',
							    'LlamaModel',
							    'LlamaPreTrainedModel',
							    'LlamaForSequenceClassification',
							]


if TYPE_CHECKING:
							from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_llama import LlamaTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_llama_fast import LlamaTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
							import sys

							A_						:    str				=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





