
'''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


__SCREAMING_SNAKE_CASE						=      logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE						=      {
    "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     __snake_case			(    _a	):
		a_          =					"bigbird_pegasus"
		a_          =					["past_key_values"]
		a_          =					{
		    "num_attention_heads": "encoder_attention_heads",
		    "hidden_size": "d_model",
		    "attention_probs_dropout_prob": "attention_dropout",
		}




		def __init__(  self					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:Optional[Any]=9_6_1_0_3			,    _SCREAMING_SNAKE_CASE					:int=4_0_9_6			,    _SCREAMING_SNAKE_CASE					:List[str]=1_6			,    _SCREAMING_SNAKE_CASE					:Tuple=4_0_9_6			,    _SCREAMING_SNAKE_CASE					:Tuple=1_6			,    _SCREAMING_SNAKE_CASE					:int=1_6			,    _SCREAMING_SNAKE_CASE					:Union[str, Any]=4_0_9_6			,    _SCREAMING_SNAKE_CASE					:Tuple=1_6			,    _SCREAMING_SNAKE_CASE					:List[Any]=0.0			,    _SCREAMING_SNAKE_CASE					:Tuple=0.0			,    _SCREAMING_SNAKE_CASE					:Tuple=True			,    _SCREAMING_SNAKE_CASE					:Optional[Any]=True			,    _SCREAMING_SNAKE_CASE					:Union[str, Any]="gelu_new"			,    _SCREAMING_SNAKE_CASE					:Optional[int]=1_0_2_4			,    _SCREAMING_SNAKE_CASE					:Optional[int]=0.1			,    _SCREAMING_SNAKE_CASE					:int=0.0			,    _SCREAMING_SNAKE_CASE					:Optional[int]=0.0			,    _SCREAMING_SNAKE_CASE					:List[str]=0.02			,    _SCREAMING_SNAKE_CASE					:int=2			,    _SCREAMING_SNAKE_CASE					:Union[str, Any]=0.0			,    _SCREAMING_SNAKE_CASE					:Tuple=True			,    _SCREAMING_SNAKE_CASE					:Dict=0			,    _SCREAMING_SNAKE_CASE					:str=2			,    _SCREAMING_SNAKE_CASE					:Any=1			,    _SCREAMING_SNAKE_CASE					:Tuple="block_sparse"			,    _SCREAMING_SNAKE_CASE					:Tuple=6_4			,    _SCREAMING_SNAKE_CASE					:Dict=3			,    _SCREAMING_SNAKE_CASE					:List[str]=False			,    **_SCREAMING_SNAKE_CASE					:str			,    )					->			Union[str, Any]:






								'''simple docstring'''






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

								# extra config
								UpperCamelCase_     :	Dict					     =     attention_type
								UpperCamelCase_     :	Tuple					     =     block_size
								UpperCamelCase_     :	Dict					     =     num_random_blocks
								UpperCamelCase_     :	Optional[int]					     =     use_bias

								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			,    **_SCREAMING_SNAKE_CASE			,    )







class     __snake_case			(    _a	):




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






								'''simple docstring'''






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

														if self.use_past:
																				UpperCamelCase_     :	Tuple					     =     {0: """batch"""}
																				UpperCamelCase_     :	int					     =     {0: """batch""", 1: """past_decoder_sequence + sequence"""}
														else:
																				UpperCamelCase_     :	Optional[Any]					     =     {0: """batch""", 1: """decoder_sequence"""}
																				UpperCamelCase_     :	Any					     =     {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_     :	Any					     =     OrderedDict(
														    [
														        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
														        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
														    ])
														if self.use_past:
																				UpperCamelCase_     ,UpperCamelCase_     :	Optional[int]					     =     self.num_layers
																				for i in range(_SCREAMING_SNAKE_CASE):
																										UpperCamelCase_     :	List[str]					     =     {0: """batch""", 2: """past_sequence + sequence"""}
																										UpperCamelCase_     :	List[Any]					     =     {0: """batch""", 2: """past_sequence + sequence"""}
								else:
														UpperCamelCase_     :	List[Any]					     =     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					:List[str])					->			Mapping[str, Mapping[int, str]]:






								'''simple docstring'''






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




		def 	_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			,    )					->			Mapping[str, Any]:






								'''simple docstring'''






								UpperCamelCase_     :	Any					     =     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_     :	str					     =     seq_length if not self.use_past else 1
								UpperCamelCase_     :	str					     =     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_     :	Union[str, Any]					     =     {F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
								UpperCamelCase_     :	str					     =     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_     :	Union[str, Any]					     =     common_inputs["""input_ids"""].shape
														UpperCamelCase_     :	int					     =     common_inputs["""decoder_input_ids"""].shape[1]
														UpperCamelCase_     ,UpperCamelCase_     :	str					     =     self.num_attention_heads
														UpperCamelCase_     :	str					     =     (
														    batch,
														    num_encoder_attention_heads,
														    encoder_seq_length,
														    self._config.hidden_size // num_encoder_attention_heads,
														)
														UpperCamelCase_     :	Any					     =     decoder_seq_length + 3
														UpperCamelCase_     :	Tuple					     =     (
														    batch,
														    num_decoder_attention_heads,
														    decoder_past_length,
														    self._config.hidden_size // num_decoder_attention_heads,
														)

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

														UpperCamelCase_     :	Union[str, Any]					     =     []
														# If the number of encoder and decoder layers are present in the model configuration, both are considered
														UpperCamelCase_     ,UpperCamelCase_     :	int					     =     self.num_layers
														UpperCamelCase_     :	Union[str, Any]					     =     min(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	Any					     =     max(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE) - min_num_layers
														UpperCamelCase_     :	int					     =     """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_     :	Union[str, Any]					     =     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 	_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			,    )					->			Mapping[str, Any]:






								'''simple docstring'''






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

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




		def 	_snake_case	(  self					:Tuple			,    _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			,    )					->			Mapping[str, Any]:






								'''simple docstring'''






								UpperCamelCase_     :	Optional[int]					     =     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_     :	List[Any]					     =     tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	str					     =     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_     :	Optional[int]					     =     [""" """.join([tokenizer.unk_token]) * seq_length] * batch_size
								UpperCamelCase_     :	List[Any]					     =     dict(tokenizer(_SCREAMING_SNAKE_CASE			,    return_tensors=_SCREAMING_SNAKE_CASE))
								return common_inputs




		def 	_snake_case	(  self					:Optional[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			,    )					->			Mapping[str, Any]:






								'''simple docstring'''






								if self.task in ["default", "seq2seq-lm"]:
														UpperCamelCase_     :	List[Any]					     =     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_     :	List[str]					     =     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_     :	Tuple					     =     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 	_snake_case	(  self					:Optional[Any]			,    _SCREAMING_SNAKE_CASE					:Optional[Any]			,    _SCREAMING_SNAKE_CASE					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:List[str]			,    _SCREAMING_SNAKE_CASE					:Union[str, Any])					->			List[Any]:






								'''simple docstring'''






								if self.task in ["default", "seq2seq-lm"]:
														UpperCamelCase_     :	Optional[Any]					     =     super()._flatten_past_key_values_(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE)
								else:
														UpperCamelCase_     :	Dict					     =     super(_SCREAMING_SNAKE_CASE			,    self)._flatten_past_key_values_(
														    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE)






'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__SCREAMING_SNAKE_CASE						=      {
    "configuration_markuplm": ["MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "MarkupLMConfig"],
    "feature_extraction_markuplm": ["MarkupLMFeatureExtractor"],
    "processing_markuplm": ["MarkupLMProcessor"],
    "tokenization_markuplm": ["MarkupLMTokenizer"],
}

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

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__SCREAMING_SNAKE_CASE						=      [
	    "MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "MarkupLMForQuestionAnswering",
	    "MarkupLMForSequenceClassification",
	    "MarkupLMForTokenClassification",
	    "MarkupLMModel",
	    "MarkupLMPreTrainedModel",
	]


if TYPE_CHECKING:
	from .configuration_markuplm import MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP, MarkupLMConfig
	from .feature_extraction_markuplm import MarkupLMFeatureExtractor
	from .processing_markuplm import MarkupLMProcessor
	from .tokenization_markuplm import MarkupLMTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_markuplm_fast import MarkupLMTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_markuplm import (
		    MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    MarkupLMForQuestionAnswering,
		    MarkupLMForSequenceClassification,
		    MarkupLMForTokenClassification,
		    MarkupLMModel,
		    MarkupLMPreTrainedModel,
		)


else:
	import sys

	__SCREAMING_SNAKE_CASE						=      _LazyModule(__name__, globals()["__file__"], _import_structure)




