






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


SCREAMING_SNAKE_CASE__     =       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__     =       {
    '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     a_						(      lowerCamelCase    ):
  lowercase							=				"""marian"""
  lowercase							=				["""past_key_values"""]
  lowercase							=				{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}

  def __init__(				self      ,		_SCREAMING_SNAKE_CASE=58101      ,		_SCREAMING_SNAKE_CASE=None      ,		_SCREAMING_SNAKE_CASE=1024      ,		_SCREAMING_SNAKE_CASE=12      ,		_SCREAMING_SNAKE_CASE=4096      ,		_SCREAMING_SNAKE_CASE=16      ,		_SCREAMING_SNAKE_CASE=12      ,		_SCREAMING_SNAKE_CASE=4096      ,		_SCREAMING_SNAKE_CASE=16      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE="gelu"      ,		_SCREAMING_SNAKE_CASE=1024      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=0.0_2      ,		_SCREAMING_SNAKE_CASE=58100      ,		_SCREAMING_SNAKE_CASE=False      ,		_SCREAMING_SNAKE_CASE=58100      ,		_SCREAMING_SNAKE_CASE=0      ,		_SCREAMING_SNAKE_CASE=0      ,		_SCREAMING_SNAKE_CASE=True      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				List[Any]:



        """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=_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     a_						(      lowerCamelCase    ):

  @property
  # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
  def   A__						(				self				)  ->				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_(_SCREAMING_SNAKE_CASE      ,		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  ,UpperCamelCase      = self.num_layers
                    for i in range(_SCREAMING_SNAKE_CASE				):
                          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				)  ->				Mapping[str, Mapping[int, str]]:



        """simple docstring"""






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

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = False      ,		_SCREAMING_SNAKE_CASE = None      ,		)  ->				Mapping[str, Any]:



        """simple docstring"""






        UpperCamelCase      = 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
        UpperCamelCase      = seq_length if not self.use_past else 1
        UpperCamelCase      = self._generate_dummy_inputs_for_encoder_and_decoder(
            _SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = {F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
        UpperCamelCase      = 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
              UpperCamelCase  ,UpperCamelCase      = common_inputs["""input_ids"""].shape
              UpperCamelCase      = common_inputs["""decoder_input_ids"""].shape[1]
              UpperCamelCase  ,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(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)]      ,		dim=1				)

              UpperCamelCase      = []
              # If the number of encoder and decoder layers are present in the model configuration, both are considered
              UpperCamelCase  ,UpperCamelCase      = self.num_layers
              UpperCamelCase      = min(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = max(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				) - min_num_layers
              UpperCamelCase      = """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.
              UpperCamelCase      = 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   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = False      ,		_SCREAMING_SNAKE_CASE = None      ,		)  ->				Mapping[str, Any]:



        """simple docstring"""






        UpperCamelCase      = 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
              UpperCamelCase  ,UpperCamelCase      = common_inputs["""input_ids"""].shape
              # Not using the same length for past_key_values
              UpperCamelCase      = seqlen + 2
              UpperCamelCase  ,UpperCamelCase      = self.num_layers
              UpperCamelCase  ,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(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		dtype=_SCREAMING_SNAKE_CASE				)]      ,		dim=1				)
              UpperCamelCase      = [
                  (torch.zeros(_SCREAMING_SNAKE_CASE				), torch.zeros(_SCREAMING_SNAKE_CASE				)) for _ in range(_SCREAMING_SNAKE_CASE				)
              ]
        return common_inputs

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = False      ,		_SCREAMING_SNAKE_CASE = None      ,		)  ->				Mapping[str, Any]:



        """simple docstring"""






        UpperCamelCase      = 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
        UpperCamelCase      = tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = 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
        UpperCamelCase      = [""" """.join([tokenizer.unk_token]				) * seq_length] * batch_size
        UpperCamelCase      = dict(tokenizer(_SCREAMING_SNAKE_CASE      ,		return_tensors=_SCREAMING_SNAKE_CASE				)				)
        return common_inputs

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = -1      ,		_SCREAMING_SNAKE_CASE = False      ,		_SCREAMING_SNAKE_CASE = None      ,		)  ->				Mapping[str, Any]:



        """simple docstring"""






        if self.task in ["default", "seq2seq-lm"]:
              UpperCamelCase      = 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:
              UpperCamelCase      = 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   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Any:



        """simple docstring"""






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


  @property
  def   A__						(				self				)  ->				float:



        """simple docstring"""






        return 1e-4








'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE__     =       {
    'configuration_nllb_moe': [
        'NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'NllbMoeConfig',
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     SCREAMING_SNAKE_CASE__     =       [
         'NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST',
         'NllbMoeForConditionalGeneration',
         'NllbMoeModel',
         'NllbMoePreTrainedModel',
         'NllbMoeTop2Router',
         'NllbMoeSparseMLP',
     ]


if TYPE_CHECKING:
     from .configuration_nllb_moe import (
         NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
         NllbMoeConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_nllb_moe import (
              NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
              NllbMoeForConditionalGeneration,
              NllbMoeModel,
              NllbMoePreTrainedModel,
              NllbMoeSparseMLP,
              NllbMoeTopaRouter,
          )


else:
     import sys

     SCREAMING_SNAKE_CASE__     =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
