





'''simple docstring'''

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


lowercase_         =			logging.get_logger(__name__)

lowercase_         =			{
    """google/bigbird-pegasus-large-arxiv""": (
        """https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json"""
    ),
    """google/bigbird-pegasus-large-pubmed""": (
        """https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json"""
    ),
    """google/bigbird-pegasus-large-bigpatent""": (
        """https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json"""
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}


class  a_					(    snake_case_	):

    '''simple docstring'''
    UpperCamelCase			   =			'''bigbird_pegasus'''
    UpperCamelCase			   =			['''past_key_values''']
    UpperCamelCase			   =			{
        '''num_attention_heads''': '''encoder_attention_heads''',
        '''hidden_size''': '''d_model''',
        '''attention_probs_dropout_prob''': '''attention_dropout''',
    }


    def __init__(		self			,		A=9_6103			,		A=4096			,		A=16			,		A=4096			,		A=16			,		A=16			,		A=4096			,		A=16			,		A=0.0			,		A=0.0			,		A=True			,		A=True			,		A="gelu_new"			,		A=1024			,		A=0.1			,		A=0.0			,		A=0.0			,		A=0.02			,		A=2			,		A=0.0			,		A=True			,		A=0			,		A=2			,		A=1			,		A="block_sparse"			,		A=64			,		A=3			,		A=False			,		**A			,		)		->       Tuple:
        _SCREAMING_SNAKE_CASE     =      vocab_size
        _SCREAMING_SNAKE_CASE     =      max_position_embeddings
        _SCREAMING_SNAKE_CASE     =      d_model
        _SCREAMING_SNAKE_CASE     =      encoder_ffn_dim
        _SCREAMING_SNAKE_CASE     =      encoder_layers
        _SCREAMING_SNAKE_CASE     =      encoder_attention_heads
        _SCREAMING_SNAKE_CASE     =      decoder_ffn_dim
        _SCREAMING_SNAKE_CASE     =      decoder_layers
        _SCREAMING_SNAKE_CASE     =      decoder_attention_heads
        _SCREAMING_SNAKE_CASE     =      dropout
        _SCREAMING_SNAKE_CASE     =      attention_dropout
        _SCREAMING_SNAKE_CASE     =      activation_dropout
        _SCREAMING_SNAKE_CASE     =      activation_function
        _SCREAMING_SNAKE_CASE     =      init_std
        _SCREAMING_SNAKE_CASE     =      encoder_layerdrop
        _SCREAMING_SNAKE_CASE     =      decoder_layerdrop
        _SCREAMING_SNAKE_CASE     =      classifier_dropout
        _SCREAMING_SNAKE_CASE     =      use_cache
        _SCREAMING_SNAKE_CASE     =      encoder_layers
        _SCREAMING_SNAKE_CASE     =      scale_embedding  # scale factor will be sqrt(d_model) if True

        # extra config
        _SCREAMING_SNAKE_CASE     =      attention_type
        _SCREAMING_SNAKE_CASE     =      block_size
        _SCREAMING_SNAKE_CASE     =      num_random_blocks
        _SCREAMING_SNAKE_CASE     =      use_bias

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




class  a_					(    snake_case_	):

    '''simple docstring'''


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

            if self.use_past:
                _SCREAMING_SNAKE_CASE     =      {0: """batch"""}
                _SCREAMING_SNAKE_CASE     =      {0: """batch""", 1: """past_decoder_sequence + sequence"""}
            else:
                _SCREAMING_SNAKE_CASE     =      {0: """batch""", 1: """decoder_sequence"""}
                _SCREAMING_SNAKE_CASE     =      {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.
            _SCREAMING_SNAKE_CASE     =      OrderedDict(
                [
                    ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
                    ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
                ]	)
            if self.use_past:
                _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      self.num_layers
                for i in range(A	):
                    _SCREAMING_SNAKE_CASE     =      {0: """batch""", 2: """past_sequence + sequence"""}
                    _SCREAMING_SNAKE_CASE     =      {0: """batch""", 2: """past_sequence + sequence"""}
        else:
            _SCREAMING_SNAKE_CASE     =      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	)		->       Mapping[str, Mapping[int, str]]:
        if self.task in ["default", "seq2seq-lm"]:
            _SCREAMING_SNAKE_CASE     =      super().outputs
        else:
            _SCREAMING_SNAKE_CASE     =      super(A			,		self	).outputs
            if self.use_past:
                _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      self.num_layers
                for i in range(A	):
                    _SCREAMING_SNAKE_CASE     =      {0: """batch""", 2: """past_sequence + sequence"""}
                    _SCREAMING_SNAKE_CASE     =      {0: """batch""", 2: """past_sequence + sequence"""}
        return common_outputs


    def       snake_case_(		self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		)		->       Mapping[str, Any]:
        _SCREAMING_SNAKE_CASE     =      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A			,		A			,		A			,		A			,		A	)

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

            _SCREAMING_SNAKE_CASE     =      torch.cat(
                [common_inputs["""decoder_attention_mask"""], torch.ones(A			,		A	)]			,		dim=1	)

            _SCREAMING_SNAKE_CASE     =      []
            # If the number of encoder and decoder layers are present in the model configuration, both are considered
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      self.num_layers
            _SCREAMING_SNAKE_CASE     =      min(A			,		A	)
            _SCREAMING_SNAKE_CASE     =      max(A			,		A	) - min_num_layers
            _SCREAMING_SNAKE_CASE     =      """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.
            _SCREAMING_SNAKE_CASE     =      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       snake_case_(		self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		)		->       Mapping[str, Any]:
        _SCREAMING_SNAKE_CASE     =      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
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      common_inputs["""input_ids"""].shape
            # Not using the same length for past_key_values
            _SCREAMING_SNAKE_CASE     =      seqlen + 2
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      self.num_layers
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      self.num_attention_heads
            _SCREAMING_SNAKE_CASE     =      (
                batch,
                num_encoder_attention_heads,
                past_key_values_length,
                self._config.hidden_size // num_encoder_attention_heads,
            )

            _SCREAMING_SNAKE_CASE     =      common_inputs["""attention_mask"""].dtype
            _SCREAMING_SNAKE_CASE     =      torch.cat(
                [common_inputs["""attention_mask"""], torch.ones(A			,		A			,		dtype=A	)]			,		dim=1	)
            _SCREAMING_SNAKE_CASE     =      [
                (torch.zeros(A	), torch.zeros(A	)) for _ in range(A	)
            ]
        return common_inputs


    def       snake_case_(		self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = 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
        _SCREAMING_SNAKE_CASE     =      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
        _SCREAMING_SNAKE_CASE     =      tokenizer.num_special_tokens_to_add(A	)
        _SCREAMING_SNAKE_CASE     =      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
        _SCREAMING_SNAKE_CASE     =      [""" """.join([tokenizer.unk_token]	) * seq_length] * batch_size
        _SCREAMING_SNAKE_CASE     =      dict(tokenizer(A			,		return_tensors=A	)	)
        return common_inputs


    def       snake_case_(		self			,		A			,		A = -1			,		A = -1			,		A = False			,		A = None			,		)		->       Mapping[str, Any]:
        if self.task in ["default", "seq2seq-lm"]:
            _SCREAMING_SNAKE_CASE     =      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":
            _SCREAMING_SNAKE_CASE     =      self._generate_dummy_inputs_for_causal_lm(
                A			,		batch_size=A			,		seq_length=A			,		is_pair=A			,		framework=A	)
        else:
            _SCREAMING_SNAKE_CASE     =      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       snake_case_(		self			,		A			,		A			,		A			,		A	)		->       Dict:
        if self.task in ["default", "seq2seq-lm"]:
            _SCREAMING_SNAKE_CASE     =      super()._flatten_past_key_values_(A			,		A			,		A			,		A	)
        else:
            _SCREAMING_SNAKE_CASE     =      super(A			,		self	)._flatten_past_key_values_(
                A			,		A			,		A			,		A	)










'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase_         =			logging.get_logger(__name__)

lowercase_         =			{
    """google/rembert""": """https://huggingface.co/google/rembert/resolve/main/config.json""",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}


class  a_					(    snake_case_	):

    '''simple docstring'''
    UpperCamelCase			   =			'''rembert'''


    def __init__(		self			,		A=25_0300			,		A=1152			,		A=32			,		A=18			,		A=256			,		A=1664			,		A=4608			,		A="gelu"			,		A=0.0			,		A=0.0			,		A=0.1			,		A=512			,		A=2			,		A=0.02			,		A=1e-12			,		A=True			,		A=0			,		A=312			,		A=313			,		**A			,		)		->       Dict:
        super().__init__(pad_token_id=A			,		bos_token_id=A			,		eos_token_id=A			,		**A	)

        _SCREAMING_SNAKE_CASE     =      vocab_size
        _SCREAMING_SNAKE_CASE     =      input_embedding_size
        _SCREAMING_SNAKE_CASE     =      output_embedding_size
        _SCREAMING_SNAKE_CASE     =      max_position_embeddings
        _SCREAMING_SNAKE_CASE     =      hidden_size
        _SCREAMING_SNAKE_CASE     =      num_hidden_layers
        _SCREAMING_SNAKE_CASE     =      num_attention_heads
        _SCREAMING_SNAKE_CASE     =      intermediate_size
        _SCREAMING_SNAKE_CASE     =      hidden_act
        _SCREAMING_SNAKE_CASE     =      hidden_dropout_prob
        _SCREAMING_SNAKE_CASE     =      attention_probs_dropout_prob
        _SCREAMING_SNAKE_CASE     =      classifier_dropout_prob
        _SCREAMING_SNAKE_CASE     =      initializer_range
        _SCREAMING_SNAKE_CASE     =      type_vocab_size
        _SCREAMING_SNAKE_CASE     =      layer_norm_eps
        _SCREAMING_SNAKE_CASE     =      use_cache
        _SCREAMING_SNAKE_CASE     =      False




class  a_					(    snake_case_	):

    '''simple docstring'''


    @property
    def       snake_case_(		self	)		->       Mapping[str, Mapping[int, str]]:
        if self.task == "multiple-choice":
            _SCREAMING_SNAKE_CASE     =      {0: """batch""", 1: """choice""", 2: """sequence"""}
        else:
            _SCREAMING_SNAKE_CASE     =      {0: """batch""", 1: """sequence"""}
        return OrderedDict(
            [
                ("""input_ids""", dynamic_axis),
                ("""attention_mask""", dynamic_axis),
                ("""token_type_ids""", dynamic_axis),
            ]	)





    @property
    def       snake_case_(		self	)		->       float:
        return 1e-4



