



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


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

_lowercase    :    Optional[int]			     =  {
    '''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 ):
				__magic_name__       :   Dict							= "marian"
				__magic_name__       :   Optional[int]							= ["past_key_values"]
				__magic_name__       :   int							= {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}




				def __init__(	self    :				Any   ,					lowerCAmelCase    :				Union[str, Any]=58101   ,					lowerCAmelCase    :				List[Any]=None   ,					lowerCAmelCase    :				str=1024   ,					lowerCAmelCase    :				Optional[int]=12   ,					lowerCAmelCase    :				str=4096   ,					lowerCAmelCase    :				Optional[int]=16   ,					lowerCAmelCase    :				Optional[Any]=12   ,					lowerCAmelCase    :				Union[str, Any]=4096   ,					lowerCAmelCase    :				Tuple=16   ,					lowerCAmelCase    :				Any=0.0   ,					lowerCAmelCase    :				int=0.0   ,					lowerCAmelCase    :				Tuple=True   ,					lowerCAmelCase    :				Union[str, Any]=True   ,					lowerCAmelCase    :				str="gelu"   ,					lowerCAmelCase    :				Optional[int]=1024   ,					lowerCAmelCase    :				Optional[Any]=0.1   ,					lowerCAmelCase    :				Union[str, Any]=0.0   ,					lowerCAmelCase    :				List[str]=0.0   ,					lowerCAmelCase    :				Union[str, Any]=0.02   ,					lowerCAmelCase    :				str=58100   ,					lowerCAmelCase    :				List[str]=False   ,					lowerCAmelCase    :				Union[str, Any]=58100   ,					lowerCAmelCase    :				int=0   ,					lowerCAmelCase    :				str=0   ,					lowerCAmelCase    :				str=True   ,					**lowerCAmelCase    :				Any   ,					)->  List[str]:

										"""simple docstring"""




										UpperCAmelCase         =			vocab_size
										UpperCAmelCase         =			decoder_vocab_size or vocab_size
										UpperCAmelCase         =			max_position_embeddings
										UpperCAmelCase         =			d_model
										UpperCAmelCase         =			encoder_ffn_dim
										UpperCAmelCase         =			encoder_layers
										UpperCAmelCase         =			encoder_attention_heads
										UpperCAmelCase         =			decoder_ffn_dim
										UpperCAmelCase         =			decoder_layers
										UpperCAmelCase         =			decoder_attention_heads
										UpperCAmelCase         =			dropout
										UpperCAmelCase         =			attention_dropout
										UpperCAmelCase         =			activation_dropout
										UpperCAmelCase         =			activation_function
										UpperCAmelCase         =			init_std
										UpperCAmelCase         =			encoder_layerdrop
										UpperCAmelCase         =			decoder_layerdrop
										UpperCAmelCase         =			use_cache
										UpperCAmelCase         =			encoder_layers
										UpperCAmelCase         =			scale_embedding  # scale factor will be sqrt(d_model) if True
										UpperCAmelCase         =			share_encoder_decoder_embeddings
										super().__init__(
										    pad_token_id=UpperCamelCase_   ,					eos_token_id=UpperCamelCase_   ,					is_encoder_decoder=UpperCamelCase_   ,					decoder_start_token_id=UpperCamelCase_   ,					forced_eos_token_id=UpperCamelCase_   ,					**UpperCamelCase_   ,					)







class  UpperCamelCase__(     lowerCAmelCase ):




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

										"""simple docstring"""




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

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

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

										"""simple docstring"""




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




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

										"""simple docstring"""




										UpperCAmelCase         =			self._generate_dummy_inputs_for_encoder_and_decoder(
										    UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   )

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

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

																UpperCAmelCase         =			torch.cat(
																    [common_inputs['''decoder_attention_mask'''], torch.ones(UpperCamelCase_   ,					UpperCamelCase_   )]   ,					dim=1   )

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

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




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

										"""simple docstring"""




										UpperCAmelCase         =			self._generate_dummy_inputs_for_encoder_and_decoder(
										    UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   ,					UpperCamelCase_   )

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

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




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

										"""simple docstring"""




										UpperCAmelCase         =			compute_effective_axis_dimension(
										    UpperCamelCase_   ,					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         =			tokenizer.num_special_tokens_to_add(UpperCamelCase_   )
										UpperCAmelCase         =			compute_effective_axis_dimension(
										    UpperCamelCase_   ,					fixed_dimension=OnnxConfig.default_fixed_sequence   ,					num_token_to_add=UpperCamelCase_   )

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




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

										"""simple docstring"""




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

										else:
																UpperCAmelCase         =			self._generate_dummy_inputs_for_causal_lm(
																    UpperCamelCase_   ,					batch_size=UpperCamelCase_   ,					seq_length=UpperCamelCase_   ,					is_pair=UpperCamelCase_   ,					framework=UpperCamelCase_   )

										return common_inputs




				def   a__(	self    :				List[str]   ,					lowerCAmelCase    :				Dict   ,					lowerCAmelCase    :				Union[str, Any]   ,					lowerCAmelCase    :				Tuple   ,					lowerCAmelCase    :				str   )->  Tuple:

										"""simple docstring"""




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





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

										"""simple docstring"""




										return 1E-4









'''simple docstring'''



from typing import TYPE_CHECKING

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


_lowercase    :    Any			     =  {
    """configuration_gpt_bigcode""": ["""GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTBigCodeConfig"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowercase    :    Optional[int]			     =  [
	    """GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """GPTBigCodeForSequenceClassification""",
	    """GPTBigCodeForTokenClassification""",
	    """GPTBigCodeForCausalLM""",
	    """GPTBigCodeModel""",
	    """GPTBigCodePreTrainedModel""",
	]

if TYPE_CHECKING:
	from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gpt_bigcode import (
		    GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTBigCodeForCausalLM,
		    GPTBigCodeForSequenceClassification,
		    GPTBigCodeForTokenClassification,
		    GPTBigCodeModel,
		    GPTBigCodePreTrainedModel,
		)


else:
	import sys

	_lowercase    :    Tuple			     =  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





