





import warnings
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


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

UpperCAmelCase	:	List[str]		     =       {
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}







class 				__lowerCAmelCase       (    A_):
      _lowercase				:					Optional[int]						=			"bart"
      _lowercase				:					List[Any]						=			["past_key_values"]
      _lowercase				:					Optional[int]						=			{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}







      def __init__(    self		,      lowerCAmelCase__=5_0_2_6_5		,      lowerCAmelCase__=1_0_2_4		,      lowerCAmelCase__=1_2		,      lowerCAmelCase__=4_0_9_6		,      lowerCAmelCase__=1_6		,      lowerCAmelCase__=1_2		,      lowerCAmelCase__=4_0_9_6		,      lowerCAmelCase__=1_6		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__="gelu"		,      lowerCAmelCase__=1_0_2_4		,      lowerCAmelCase__=0.1		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=0.02		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=False		,      lowerCAmelCase__=True		,      lowerCAmelCase__=3		,      lowerCAmelCase__=1		,      lowerCAmelCase__=0		,      lowerCAmelCase__=2		,      lowerCAmelCase__=True		,      lowerCAmelCase__=2		,      lowerCAmelCase__=2		,      **lowerCAmelCase__		,      )   ->						Optional[int]:



        '''simple docstring'''




        a__	:					List[str]										=vocab_size
        a__	:					List[str]										=max_position_embeddings
        a__	:					Tuple										=d_model
        a__	:					Union[str, Any]										=encoder_ffn_dim
        a__	:					Union[str, Any]										=encoder_layers
        a__	:					str										=encoder_attention_heads
        a__	:					Tuple										=decoder_ffn_dim
        a__	:					Tuple										=decoder_layers
        a__	:					List[Any]										=decoder_attention_heads
        a__	:					Optional[Any]										=dropout
        a__	:					Tuple										=attention_dropout
        a__	:					Any										=activation_dropout
        a__	:					List[str]										=activation_function
        a__	:					Dict										=init_std
        a__	:					str										=encoder_layerdrop
        a__	:					Any										=decoder_layerdrop
        a__	:					Tuple										=classifier_dropout
        a__	:					Optional[Any]										=use_cache
        a__	:					int										=encoder_layers
        a__	:					Tuple										=scale_embedding  # scale factor will be sqrt(d_model) if True

        super().__init__(
            num_labels=A_		,      pad_token_id=A_		,      bos_token_id=A_		,      eos_token_id=A_		,      is_encoder_decoder=A_		,      decoder_start_token_id=A_		,      forced_eos_token_id=A_		,      **A_		,      )

        # ensure backward compatibility for BART CNN models
        if self.forced_bos_token_id is None and kwargs.get("force_bos_token_to_be_generated"		,      A_							):
          a__	:					Optional[int]										=self.bos_token_id
          warnings.warn(
              F'''Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '''
              "The config can simply be saved and uploaded again to be fixed."							)







class 				__lowerCAmelCase       (    A_):







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



        '''simple docstring'''




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

          if self.use_past:
            a__	:					int										={0: "batch"}
            a__	:					List[str]										={0: "batch", 1: "past_decoder_sequence + sequence"}
          else:
            a__	:					Tuple										={0: "batch", 1: "decoder_sequence"}
            a__	:					List[str]										={0: "batch", 1: "decoder_sequence"}

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



        '''simple docstring'''




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







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



        '''simple docstring'''




        a__	:					Optional[int]										=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A_		,      A_		,      A_		,      A_		,      A_							)

        # Generate decoder inputs
        a__	:					Optional[int]										=seq_length if not self.use_past else 1
        a__	:					Any										=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A_		,      A_		,      A_		,      A_		,      A_							)
        a__	:					Optional[Any]										={F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
        a__	:					List[str]										=dict(**A_		,      **A_							)

        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__	:					Tuple										=common_inputs["input_ids"].shape
          a__	:					Tuple										=common_inputs["decoder_input_ids"].shape[1]
          a__					,							a__	:					int										=self.num_attention_heads
          a__	:					Union[str, Any]										=(
              batch,
              num_encoder_attention_heads,
              encoder_seq_length,
              self._config.hidden_size // num_encoder_attention_heads,
          )
          a__	:					Dict										=decoder_seq_length + 3
          a__	:					Any										=(
              batch,
              num_decoder_attention_heads,
              decoder_past_length,
              self._config.hidden_size // num_decoder_attention_heads,
          )

          a__	:					int										=torch.cat(
              [common_inputs["decoder_attention_mask"], torch.ones(A_		,      A_							)]		,      dim=1							)

          a__	:					Any										=[]
          # If the number of encoder and decoder layers are present in the model configuration, both are considered
          a__					,							a__	:					Any										=self.num_layers
          a__	:					Tuple										=min(A_		,      A_							)
          a__	:					Optional[int]										=max(A_		,      A_							) - min_num_layers
          a__	:					Union[str, Any]										="encoder" if num_encoder_layers > num_decoder_layers else "decoder"

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







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



        '''simple docstring'''




        a__	:					Dict										=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A_		,      A_		,      A_		,      A_		,      A_							)

        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__	:					int										=common_inputs["input_ids"].shape
          # Not using the same length for past_key_values
          a__	:					Optional[int]										=seqlen + 2
          a__					,							a__	:					Dict										=self.num_layers
          a__					,							a__	:					Optional[int]										=self.num_attention_heads
          a__	:					Any										=(
              batch,
              num_encoder_attention_heads,
              past_key_values_length,
              self._config.hidden_size // num_encoder_attention_heads,
          )

          a__	:					str										=common_inputs["attention_mask"].dtype
          a__	:					Tuple										=torch.cat(
              [common_inputs["attention_mask"], torch.ones(A_		,      A_		,      dtype=A_							)]		,      dim=1							)
          a__	:					Optional[int]										=[
              (torch.zeros(A_							), torch.zeros(A_							)) for _ in range(A_							)
          ]
        return common_inputs







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



        '''simple docstring'''




        a__	:					int										=compute_effective_axis_dimension(
            A_		,      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__	:					Tuple										=tokenizer.num_special_tokens_to_add(A_							)
        a__	:					str										=compute_effective_axis_dimension(
            A_		,      fixed_dimension=OnnxConfig.default_fixed_sequence		,      num_token_to_add=A_							)

        # Generate dummy inputs according to compute batch and sequence
        a__	:					int										=[" ".join([tokenizer.unk_token]							) * seq_length] * batch_size
        a__	:					Union[str, Any]										=dict(tokenizer(A_		,      return_tensors=A_							)							)
        return common_inputs







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



        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
          a__	:					List[str]										=self._generate_dummy_inputs_for_default_and_seqaseq_lm(
              A_		,      batch_size=A_		,      seq_length=A_		,      is_pair=A_		,      framework=A_							)

        elif self.task == "causal-lm":
          a__	:					Tuple										=self._generate_dummy_inputs_for_causal_lm(
              A_		,      batch_size=A_		,      seq_length=A_		,      is_pair=A_		,      framework=A_							)
        else:
          a__	:					Any										=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              A_		,      batch_size=A_		,      seq_length=A_		,      is_pair=A_		,      framework=A_							)

        return common_inputs







      def    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__		,      lowerCAmelCase__							)   ->						str:



        '''simple docstring'''




        if self.task in ["default", "seq2seq-lm"]:
          a__	:					int										=super()._flatten_past_key_values_(A_		,      A_		,      A_		,      A_							)
        else:
          a__	:					Optional[Any]										=super(A_		,      self							)._flatten_past_key_values_(
              A_		,      A_		,      A_		,      A_							)










import warnings

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


_A		       =						logging.get_logger(__name__)

_A		       =						{
    'RUCAIBox/mvp': 'https://huggingface.co/RUCAIBox/mvp/resolve/main/config.json',
}






class     UpperCAmelCase__       (					A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Optional[int]      =  "mvp"
    UpperCAmelCase__						:		Tuple      =  ["past_key_values"]
    UpperCAmelCase__						:		Union[str, Any]      =  {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






    def __init__(			self					,   A_=50267					,   A_=1024					,   A_=12					,   A_=4096					,   A_=16					,   A_=12					,   A_=4096					,   A_=16					,   A_=0.0					,   A_=0.0					,   A_="gelu"					,   A_=1024					,   A_=0.1					,   A_=0.0					,   A_=0.0					,   A_=0.02					,   A_=0.0					,   A_=False					,   A_=True					,   A_=1					,   A_=0					,   A_=2					,   A_=True					,   A_=2					,   A_=2					,   A_=False					,   A_=100					,   A_=800					,   **A_					,   )  ->       Union[str, Any]:
         __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    							=classifier_dropout
         __UpperCamelCase    							=use_cache
         __UpperCamelCase    							=encoder_layers
         __UpperCamelCase    							=scale_embedding  # scale factor will be sqrt(d_model) if True
         __UpperCamelCase    							=use_prompt
         __UpperCamelCase    							=prompt_length
         __UpperCamelCase    							=prompt_mid_dim

         super().__init__(
             pad_token_id=A_					,   bos_token_id=A_					,   eos_token_id=A_					,   is_encoder_decoder=A_					,   decoder_start_token_id=A_					,   forced_eos_token_id=A_					,   **A_					,   )

         if self.forced_bos_token_id is None and kwargs.get('force_bos_token_to_be_generated'					,   A_    ):
              __UpperCamelCase    							=self.bos_token_id
              warnings.warn(
                  f'Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '
                  'The config can simply be saved and uploaded again to be fixed.'    )





