





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


_lowerCamelCase							=     logging.get_logger(__name__)

_lowerCamelCase							=     {
    '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 					UpperCamelCase_    (       UpperCamelCase__      ):
							lowerCamelCase_          =   "bigbird_pegasus"
							lowerCamelCase_          =   ["past_key_values"]
							lowerCamelCase_          =   {
							    "num_attention_heads": "encoder_attention_heads",
							    "hidden_size": "d_model",
							    "attention_probs_dropout_prob": "attention_dropout",
							}


							def __init__(							self      :Optional[int]							,			__A      :Optional[Any]=9_6103							,			__A      :Union[str, Any]=4096							,			__A      :List[str]=16							,			__A      :Union[str, Any]=4096							,			__A      :Optional[int]=16							,			__A      :List[str]=16							,			__A      :Union[str, Any]=4096							,			__A      :Optional[int]=16							,			__A      :Union[str, Any]=0.0							,			__A      :Optional[int]=0.0							,			__A      :Optional[Any]=True							,			__A      :Optional[Any]=True							,			__A      :Union[str, Any]="gelu_new"							,			__A      :Optional[Any]=1024							,			__A      :Optional[int]=0.1							,			__A      :Optional[int]=0.0							,			__A      :int=0.0							,			__A      :Optional[int]=0.0_2							,			__A      :Dict=2							,			__A      :Optional[Any]=0.0							,			__A      :Optional[int]=True							,			__A      :int=0							,			__A      :Optional[int]=2							,			__A      :Tuple=1							,			__A      :Optional[int]="block_sparse"							,			__A      :List[str]=64							,			__A      :List[str]=3							,			__A      :Optional[int]=False							,			**__A      :List[str]							,			)				->				List[str]:



									"""simple docstring"""



									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 					UpperCamelCase_    (       UpperCamelCase__      ):


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



									"""simple docstring"""



									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      :str						)				->				Mapping[str, Mapping[int, str]]:



									"""simple docstring"""



									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      :Optional[Any]							,			__A      :PreTrainedTokenizer							,			__A      :int = -1							,			__A      :int = -1							,			__A      :bool = False							,			__A      :Optional[TensorType] = None							,			)				->				Mapping[str, Any]:



									"""simple docstring"""



									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      :Dict							,			__A      :PreTrainedTokenizer							,			__A      :int = -1							,			__A      :int = -1							,			__A      :bool = False							,			__A      :Optional[TensorType] = None							,			)				->				Mapping[str, Any]:



									"""simple docstring"""



									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      :Tuple							,			__A      :PreTrainedTokenizer							,			__A      :int = -1							,			__A      :int = -1							,			__A      :bool = False							,			__A      :Optional[TensorType] = None							,			)				->				Mapping[str, Any]:



									"""simple docstring"""



									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      :List[Any]							,			__A      :PreTrainedTokenizer							,			__A      :int = -1							,			__A      :int = -1							,			__A      :bool = False							,			__A      :Optional[TensorType] = None							,			)				->				Mapping[str, Any]:



									"""simple docstring"""



									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      :Optional[Any]							,			__A      :List[Any]							,			__A      :Union[str, Any]							,			__A      :Any							,			__A      :Tuple						)				->				Dict:



									"""simple docstring"""



									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						)






from typing import Callable






def 			SCREAMING_SNAKE_CASE__							(    UpperCamelCase__:							Callable      ):

		def wrapper(UpperCamelCase__:							List[Any]      ):
				SCREAMING_SNAKE_CASE__								= function_with_docstring.__doc__
				return target_function

		return wrapper