



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

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


UpperCAmelCase_		 =					logging.get_logger(__name__)

UpperCAmelCase_		 =					{
    """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json""",
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 a__					: Tuple =  "blenderbot-small"
 a__					: str =  ["past_key_values"]
 a__					: str =  {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}

 def __init__(    self					:					Optional[int]			,						__lowerCAmelCase					:					str=5_02_65			,						__lowerCAmelCase					:					Dict=5_12			,						__lowerCAmelCase					:					List[Any]=8			,						__lowerCAmelCase					:					Union[str, Any]=20_48			,						__lowerCAmelCase					:					Any=16			,						__lowerCAmelCase					:					List[str]=8			,						__lowerCAmelCase					:					Optional[int]=20_48			,						__lowerCAmelCase					:					Optional[Any]=16			,						__lowerCAmelCase					:					List[Any]=0.0			,						__lowerCAmelCase					:					List[str]=0.0			,						__lowerCAmelCase					:					int=True			,						__lowerCAmelCase					:					str=True			,						__lowerCAmelCase					:					Union[str, Any]="gelu"			,						__lowerCAmelCase					:					Union[str, Any]=5_12			,						__lowerCAmelCase					:					Union[str, Any]=0.1			,						__lowerCAmelCase					:					Union[str, Any]=0.0			,						__lowerCAmelCase					:					Optional[int]=0.0			,						__lowerCAmelCase					:					str=0.02			,						__lowerCAmelCase					:					Dict=1			,						__lowerCAmelCase					:					Any=False			,						__lowerCAmelCase					:					List[str]=0			,						__lowerCAmelCase					:					Optional[int]=1			,						__lowerCAmelCase					:					Optional[Any]=2			,						__lowerCAmelCase					:					Dict=2			,						**__lowerCAmelCase					:					Optional[Any]			,						)   ->	List[Any]:
    _A      =       vocab_size
    _A      =       max_position_embeddings
    _A      =       d_model
    _A      =       encoder_ffn_dim
    _A      =       encoder_layers
    _A      =       encoder_attention_heads
    _A      =       decoder_ffn_dim
    _A      =       decoder_layers
    _A      =       decoder_attention_heads
    _A      =       dropout
    _A      =       attention_dropout
    _A      =       activation_dropout
    _A      =       activation_function
    _A      =       init_std
    _A      =       encoder_layerdrop
    _A      =       decoder_layerdrop
    _A      =       use_cache
    _A      =       encoder_layers
    _A      =       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			,						forced_eos_token_id=__lowerCAmelCase			,						**__lowerCAmelCase			,						)


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 @property
 def     snake_case_      (    self					:					Union[str, Any]      )   ->	Mapping[str, Mapping[int, str]]:
    if self.task in ["default", "seq2seq-lm"]:
       _A      =       OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]      )

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

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

 def     snake_case_      (    self					:					int			,						__lowerCAmelCase					:					PreTrainedTokenizer			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					bool = False			,						__lowerCAmelCase					:					Optional[TensorType] = None			,						)   ->	Mapping[str, Any]:
    _A      =       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        __lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase      )

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

       _A      =       torch.cat(
           [common_inputs['''decoder_attention_mask'''], torch.ones(__lowerCAmelCase			,						__lowerCAmelCase      )]			,						dim=1      )

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

 def     snake_case_      (    self					:					Optional[Any]			,						__lowerCAmelCase					:					PreTrainedTokenizer			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					bool = False			,						__lowerCAmelCase					:					Optional[TensorType] = None			,						)   ->	Mapping[str, Any]:
    _A      =       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        __lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase			,						__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
       _A  ,    _A      =       common_inputs['''input_ids'''].shape
       # Not using the same length for past_key_values
       _A      =       seqlen + 2
       _A  ,    _A      =       self.num_layers
       _A  ,    _A      =       self.num_attention_heads
       _A      =       (
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )

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

 def     snake_case_      (    self					:					Any			,						__lowerCAmelCase					:					PreTrainedTokenizer			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					bool = False			,						__lowerCAmelCase					:					Optional[TensorType] = 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
    _A      =       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
    _A      =       tokenizer.num_special_tokens_to_add(__lowerCAmelCase      )
    _A      =       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
    _A      =       [''' '''.join([tokenizer.unk_token]      ) * seq_length] * batch_size
    _A      =       dict(tokenizer(__lowerCAmelCase			,						return_tensors=__lowerCAmelCase      )      )
    return common_inputs

 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					PreTrainedTokenizer			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					int = -1			,						__lowerCAmelCase					:					bool = False			,						__lowerCAmelCase					:					Optional[TensorType] = None			,						)   ->	Mapping[str, Any]:
    if self.task in ["default", "seq2seq-lm"]:
       _A      =       self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           __lowerCAmelCase			,						batch_size=__lowerCAmelCase			,						seq_length=__lowerCAmelCase			,						is_pair=__lowerCAmelCase			,						framework=__lowerCAmelCase      )

    elif self.task == "causal-lm":
       _A      =       self._generate_dummy_inputs_for_causal_lm(
           __lowerCAmelCase			,						batch_size=__lowerCAmelCase			,						seq_length=__lowerCAmelCase			,						is_pair=__lowerCAmelCase			,						framework=__lowerCAmelCase      )
    else:
       _A      =       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           __lowerCAmelCase			,						batch_size=__lowerCAmelCase			,						seq_length=__lowerCAmelCase			,						is_pair=__lowerCAmelCase			,						framework=__lowerCAmelCase      )

    return common_inputs

 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					List[str]			,						__lowerCAmelCase					:					Any			,						__lowerCAmelCase					:					str			,						__lowerCAmelCase					:					Optional[Any]      )   ->	Union[str, Any]:
    if self.task in ["default", "seq2seq-lm"]:
       _A      =       super()._flatten_past_key_values_(__lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase      )
    else:
       _A      =       super(__lowerCAmelCase			,						self      )._flatten_past_key_values_(
           __lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase			,						__lowerCAmelCase      )








import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_		 =					logging.get_logger(__name__)

UpperCAmelCase_		 =					{
    """xlnet-base-cased""": """https://huggingface.co/xlnet-base-cased/resolve/main/config.json""",
    """xlnet-large-cased""": """https://huggingface.co/xlnet-large-cased/resolve/main/config.json""",
}


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 a__					: Any =  "xlnet"
 a__					: Dict =  ["mems"]
 a__					: List[str] =  {
     "n_token": "vocab_size",  # Backward compatibility
     "hidden_size": "d_model",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }

 def __init__(    self					:					int			,						__lowerCAmelCase					:					Dict=3_20_00			,						__lowerCAmelCase					:					List[str]=10_24			,						__lowerCAmelCase					:					Dict=24			,						__lowerCAmelCase					:					Optional[Any]=16			,						__lowerCAmelCase					:					Dict=40_96			,						__lowerCAmelCase					:					Any="gelu"			,						__lowerCAmelCase					:					int=True			,						__lowerCAmelCase					:					List[str]="bi"			,						__lowerCAmelCase					:					Dict=0.02			,						__lowerCAmelCase					:					Union[str, Any]=1E-12			,						__lowerCAmelCase					:					Optional[Any]=0.1			,						__lowerCAmelCase					:					Optional[Any]=5_12			,						__lowerCAmelCase					:					List[str]=None			,						__lowerCAmelCase					:					Tuple=True			,						__lowerCAmelCase					:					Tuple=False			,						__lowerCAmelCase					:					Optional[Any]=False			,						__lowerCAmelCase					:					Union[str, Any]=-1			,						__lowerCAmelCase					:					Optional[Any]=False			,						__lowerCAmelCase					:					Any="last"			,						__lowerCAmelCase					:					List[Any]=True			,						__lowerCAmelCase					:					Tuple="tanh"			,						__lowerCAmelCase					:					int=0.1			,						__lowerCAmelCase					:					str=5			,						__lowerCAmelCase					:					str=5			,						__lowerCAmelCase					:					List[str]=5			,						__lowerCAmelCase					:					List[str]=1			,						__lowerCAmelCase					:					Optional[int]=2			,						**__lowerCAmelCase					:					List[str]			,						)   ->	Tuple:
    _A      =       vocab_size
    _A      =       d_model
    _A      =       n_layer
    _A      =       n_head
    if d_model % n_head != 0:
       raise ValueError(f'''\'d_model % n_head\' ({d_model % n_head}) should be equal to 0'''      )
    if "d_head" in kwargs:
       if kwargs["d_head"] != d_model // n_head:
          raise ValueError(
              f'''`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})'''      )
    _A      =       d_model // n_head
    _A      =       ff_activation
    _A      =       d_inner
    _A      =       untie_r
    _A      =       attn_type

    _A      =       initializer_range
    _A      =       layer_norm_eps

    _A      =       dropout
    _A      =       mem_len
    _A      =       reuse_len
    _A      =       bi_data
    _A      =       clamp_len
    _A      =       same_length

    _A      =       summary_type
    _A      =       summary_use_proj
    _A      =       summary_activation
    _A      =       summary_last_dropout
    _A      =       start_n_top
    _A      =       end_n_top

    _A      =       bos_token_id
    _A      =       pad_token_id
    _A      =       eos_token_id

    if "use_cache" in kwargs:
       warnings.warn(
           '''The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`'''
           ''' instead.'''			,						__lowerCAmelCase			,						)
       _A      =       kwargs['''use_cache''']

    _A      =       use_mems_eval
    _A      =       use_mems_train
    super().__init__(pad_token_id=__lowerCAmelCase			,						bos_token_id=__lowerCAmelCase			,						eos_token_id=__lowerCAmelCase			,						**__lowerCAmelCase      )

 @property
 def     snake_case_      (    self					:					Optional[Any]      )   ->	Union[str, Any]:
    logger.info(f'''The model {self.model_type} is one of the few models that has no sequence length limit.'''      )
    return -1

 @max_position_embeddings.setter
 def     snake_case_      (    self					:					Tuple			,						__lowerCAmelCase					:					Optional[Any]      )   ->	Dict:
    # Message copied from Transformer-XL documentation
    raise NotImplementedError(
        f'''The model {self.model_type} is one of the few models that has no sequence length limit.'''      )



