


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

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


SCREAMING_SNAKE_CASE		:List[str]											=       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE		:List[str]											=       {
    '''facebook/m2m100_418M''': '''https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json''',
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}


class       __lowerCAmelCase       (	a   ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE						      =    'm2m_100'
  _SCREAMING_SNAKE_CASE						      =    ['past_key_values']
  _SCREAMING_SNAKE_CASE						      =    {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}



  def __init__(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tuple=1_2_8_1_1_2      ,			_lowerCAmelCase    :    str=1_0_2_4      ,			_lowerCAmelCase    :    Optional[Any]=1_2      ,			_lowerCAmelCase    :    Union[str, Any]=4_0_9_6      ,			_lowerCAmelCase    :    Dict=1_6      ,			_lowerCAmelCase    :    Optional[Any]=1_2      ,			_lowerCAmelCase    :    Tuple=4_0_9_6      ,			_lowerCAmelCase    :    List[Any]=1_6      ,			_lowerCAmelCase    :    Optional[Any]=0.05      ,			_lowerCAmelCase    :    Optional[Any]=0.05      ,			_lowerCAmelCase    :    Dict=True      ,			_lowerCAmelCase    :    Any=True      ,			_lowerCAmelCase    :    Optional[int]="relu"      ,			_lowerCAmelCase    :    Optional[Any]=1_0_2_4      ,			_lowerCAmelCase    :    Optional[int]=0.1      ,			_lowerCAmelCase    :    int=0.1      ,			_lowerCAmelCase    :    int=0.0      ,			_lowerCAmelCase    :    List[str]=0.02      ,			_lowerCAmelCase    :    Any=2      ,			_lowerCAmelCase    :    List[str]=True      ,			_lowerCAmelCase    :    str=1      ,			_lowerCAmelCase    :    Union[str, Any]=0      ,			_lowerCAmelCase    :    Dict=2      ,			**_lowerCAmelCase    :    Optional[int]      ,			)				->	Any:




     """simple docstring"""
     snake_case_         =   vocab_size
     snake_case_         =   max_position_embeddings
     snake_case_         =   d_model
     snake_case_         =   encoder_ffn_dim
     snake_case_         =   encoder_layers
     snake_case_         =   encoder_attention_heads
     snake_case_         =   decoder_ffn_dim
     snake_case_         =   decoder_layers
     snake_case_         =   decoder_attention_heads
     snake_case_         =   dropout
     snake_case_         =   attention_dropout
     snake_case_         =   activation_dropout
     snake_case_         =   activation_function
     snake_case_         =   init_std
     snake_case_         =   encoder_layerdrop
     snake_case_         =   decoder_layerdrop
     snake_case_         =   use_cache
     snake_case_         =   encoder_layers
     snake_case_         =   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      ,			decoder_start_token_id=_lowerCAmelCase      ,			**_lowerCAmelCase      ,			)






class       __lowerCAmelCase       (	a   ):






  """simple docstring"""





  @property
  def    lowerCAmelCase__					(       self    :    int					)				->	Mapping[str, Mapping[int, str]]:




     """simple docstring"""
     snake_case_         =   OrderedDict(
         [
             ("input_ids", {0: "batch", 1: "encoder_sequence"}),
             ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
         ]					)

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

     if self.use_past:
        self.fill_with_past_key_values_(_lowerCAmelCase      ,			direction="inputs"					)
     return common_inputs



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




     """simple docstring"""
     # 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
     snake_case_         =   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
     snake_case_         =   tokenizer.num_special_tokens_to_add(_lowerCAmelCase					)
     snake_case_         =   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
     snake_case_         =   [" ".join([tokenizer.unk_token]					) * seq_length] * batch_size
     snake_case_         =   dict(tokenizer(_lowerCAmelCase      ,			return_tensors=_lowerCAmelCase					)					)
     return common_inputs



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




     """simple docstring"""
     snake_case_         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         _lowerCAmelCase      ,			_lowerCAmelCase      ,			_lowerCAmelCase      ,			_lowerCAmelCase      ,			_lowerCAmelCase					)

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

        snake_case_         =   torch.cat(
            [common_inputs["decoder_attention_mask"], torch.ones(_lowerCAmelCase      ,			_lowerCAmelCase					)]      ,			dim=1					)

        snake_case_         =   []
        # If the number of encoder and decoder layers are present in the model configuration, both are considered
        snake_case_      ,      snake_case_         =   self.num_layers
        snake_case_         =   min(_lowerCAmelCase      ,			_lowerCAmelCase					)
        snake_case_         =   max(_lowerCAmelCase      ,			_lowerCAmelCase					) - min_num_layers
        snake_case_         =   "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.
        snake_case_         =   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

  _SCREAMING_SNAKE_CASE						      =    _generate_dummy_inputs_for_default_and_seqaseq_lm








from __future__ import annotations



def      _lowerCAmelCase  (							lowerCAmelCase_							:int							)->list[int]:
   '''simple docstring'''






   assert (
       isinstance(lowerCAmelCase_						,  lowerCAmelCase_							) and mask > 0
   ), F'''mask needs to be positive integer, your input {mask}'''
   snake_case_         =   []
   snake_case_         =   mask

   while submask:
      all_submasks.append(lowerCAmelCase_							)
      snake_case_         =   (submask - 1) & mask

   return all_submasks


if __name__ == "__main__":
   import doctest

   doctest.testmod()




