






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


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

__magic_name__   :  Dict        =							{
    '''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 					A__     (     __snake_case ):

     '''simple docstring'''






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







     def __init__( self      :    Tuple   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]=5_0265   ,						_SCREAMING_SNAKE_CASE      :    Any=512   ,						_SCREAMING_SNAKE_CASE      :    int=8   ,						_SCREAMING_SNAKE_CASE      :    Optional[int]=2048   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]=16   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]=8   ,						_SCREAMING_SNAKE_CASE      :    Dict=2048   ,						_SCREAMING_SNAKE_CASE      :    Union[str, Any]=16   ,						_SCREAMING_SNAKE_CASE      :    List[str]=0.0   ,						_SCREAMING_SNAKE_CASE      :    Tuple=0.0   ,						_SCREAMING_SNAKE_CASE      :    Tuple=True   ,						_SCREAMING_SNAKE_CASE      :    Optional[int]=True   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]="gelu"   ,						_SCREAMING_SNAKE_CASE      :    int=512   ,						_SCREAMING_SNAKE_CASE      :    Dict=0.1   ,						_SCREAMING_SNAKE_CASE      :    str=0.0   ,						_SCREAMING_SNAKE_CASE      :    Tuple=0.0   ,						_SCREAMING_SNAKE_CASE      :    Tuple=0.0_2   ,						_SCREAMING_SNAKE_CASE      :    List[Any]=1   ,						_SCREAMING_SNAKE_CASE      :    List[str]=False   ,						_SCREAMING_SNAKE_CASE      :    Dict=0   ,						_SCREAMING_SNAKE_CASE      :    Tuple=1   ,						_SCREAMING_SNAKE_CASE      :    str=2   ,						_SCREAMING_SNAKE_CASE      :    List[Any]=2   ,						**_SCREAMING_SNAKE_CASE      :    List[Any]   ,						):






           """simple docstring"""




           UpperCamelCase					       =  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

           super().__init__(
               pad_token_id=_SCREAMING_SNAKE_CASE   ,						bos_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__     (     __snake_case ):

     '''simple docstring'''






     @property
     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """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
     def   _SCREAMING_SNAKE_CASE     ( self      :    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   _SCREAMING_SNAKE_CASE     ( self      :    List[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   ,						):






           """simple docstring"""




           UpperCamelCase					       =  self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
               _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_sequence_classification_and_question_answering(
               _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   _SCREAMING_SNAKE_CASE     ( 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   ,						):






           """simple docstring"""




           UpperCamelCase					       =  self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
               _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   _SCREAMING_SNAKE_CASE     ( 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   ,						):






           """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   _SCREAMING_SNAKE_CASE     ( self      :    Dict   ,						_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   ,						):






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

           elif self.task == "causal-lm":
                 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 )
           else:
                 UpperCamelCase					       =  self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                     _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   _SCREAMING_SNAKE_CASE     ( self      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    Tuple   ,						_SCREAMING_SNAKE_CASE      :    int   ,						_SCREAMING_SNAKE_CASE      :    int   ,						_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 )











def 		lowercase__  (				_UpperCamelCase       ,							_UpperCamelCase) ->			bool:
      """simple docstring"""

      return numa ^ numa < 0


if __name__ == "__main__":
       import doctest

       doctest.testmod()



