


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


__a     =			logging.get_logger(__name__)

__a     =			{
    """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   __lowercase				(  __snake_case  ):
      UpperCamelCase								=       '''bart'''
      UpperCamelCase								=       ['''past_key_values''']
      UpperCamelCase								=       {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}





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






         """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							=     classifier_dropout
         UpperCAmelCase							=     use_cache
         UpperCAmelCase							=     encoder_layers
         UpperCAmelCase							=     scale_embedding  # scale factor will be sqrt(d_model) if True

         super().__init__(
             num_labels=__lowerCamelCase					,       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					,       )

         # ensure backward compatibility for BART CNN models
         if self.forced_bos_token_id is None and kwargs.get("""force_bos_token_to_be_generated"""					,       __lowerCamelCase       ):
            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."""       )






class   __lowercase				(  __snake_case  ):





      @property
      def        _lowercase				(		self						:					List[Any]       )    ->   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_(__lowerCamelCase					,       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(__lowerCamelCase       ):
                  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        _lowercase				(		self						:					Any       )    ->   Mapping[str, Mapping[int, str]]:






         """simple docstring"""







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





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






         """simple docstring"""







         UpperCAmelCase							=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )

         # Generate decoder inputs
         UpperCAmelCase							=     seq_length if not self.use_past else 1
         UpperCAmelCase							=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )
         UpperCAmelCase							=     {F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
         UpperCAmelCase							=     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
            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(__lowerCamelCase					,       __lowerCamelCase       )]					,       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(__lowerCamelCase					,       __lowerCamelCase       )
            UpperCAmelCase							=     max(__lowerCamelCase					,       __lowerCamelCase       ) - min_num_layers
            UpperCAmelCase							=     """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.
            UpperCAmelCase							=     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        _lowercase				(		self						:					List[Any]					,       __lowerCamelCase						:					PreTrainedTokenizer					,       __lowerCamelCase						:					int = -1					,       __lowerCamelCase						:					int = -1					,       __lowerCamelCase						:					bool = False					,       __lowerCamelCase						:					Optional[TensorType] = None					,       )    ->   Mapping[str, Any]:






         """simple docstring"""







         UpperCAmelCase							=     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
            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(__lowerCamelCase					,       __lowerCamelCase					,       dtype=__lowerCamelCase       )]					,       dim=1       )
            UpperCAmelCase							=     [
                (torch.zeros(__lowerCamelCase       ), torch.zeros(__lowerCamelCase       )) for _ in range(__lowerCamelCase       )
            ]
         return common_inputs





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






         """simple docstring"""







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





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






         """simple docstring"""







         if self.task in ["default", "seq2seq-lm"]:
            UpperCAmelCase							=     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":
            UpperCAmelCase							=     self._generate_dummy_inputs_for_causal_lm(
                __lowerCamelCase					,       batch_size=__lowerCamelCase					,       seq_length=__lowerCamelCase					,       is_pair=__lowerCamelCase					,       framework=__lowerCamelCase       )
         else:
            UpperCAmelCase							=     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        _lowercase				(		self						:					List[Any]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					List[str]       )    ->   Union[str, Any]:






         """simple docstring"""







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







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


__a     =			{"""tokenization_herbert""": ["""HerbertTokenizer"""]}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __a     =			["""HerbertTokenizerFast"""]


if TYPE_CHECKING:
 from .tokenization_herbert import HerbertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_herbert_fast import HerbertTokenizerFast

else:
 import sys

 __a     =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



