



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


UpperCAmelCase_			      =  logging.get_logger(__name__)

UpperCAmelCase_			      =  {
    '''openbmb/cpm-ant-10b''': '''https://huggingface.co/openbmb/cpm-ant-10b/blob/main/config.json'''
    # See all CPMAnt models at https://huggingface.co/models?filter=cpmant
}





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				SCREAMING_SNAKE_CASE_ 				=  'cpmant'







				def __init__(				self						,	SCREAMING_SNAKE_CASE__ = 3_07_20						,	SCREAMING_SNAKE_CASE__ = 40_96						,	SCREAMING_SNAKE_CASE__ = 32						,	SCREAMING_SNAKE_CASE__ = 1_28						,	SCREAMING_SNAKE_CASE__ = 1_02_40						,	SCREAMING_SNAKE_CASE__ = 48						,	SCREAMING_SNAKE_CASE__ = 0.0						,	SCREAMING_SNAKE_CASE__ = 5_12						,	SCREAMING_SNAKE_CASE__ = 20_48						,	SCREAMING_SNAKE_CASE__ = 1e-6						,	SCREAMING_SNAKE_CASE__ = 1.0						,	SCREAMING_SNAKE_CASE__ = 32						,	SCREAMING_SNAKE_CASE__ = 32						,	SCREAMING_SNAKE_CASE__ = 32						,	SCREAMING_SNAKE_CASE__ = True						,	**SCREAMING_SNAKE_CASE__						,	):






					"""simple docstring"""

					super().__init__(**SCREAMING_SNAKE_CASE__      )
					_snake_case					:							Optional[int]					     =   prompt_types
					_snake_case					:							Union[str, Any]					     =   prompt_length
					_snake_case					:							Optional[Any]					     =   segment_types
					_snake_case					:							int					     =   hidden_size
					_snake_case					:							Dict					     =   num_attention_heads
					_snake_case					:							int					     =   dim_head
					_snake_case					:							Union[str, Any]					     =   dim_ff
					_snake_case					:							Tuple					     =   num_hidden_layers
					_snake_case					:							Dict					     =   position_bias_num_buckets
					_snake_case					:							Optional[int]					     =   position_bias_max_distance
					_snake_case					:							Dict					     =   dropout_p
					_snake_case					:							int					     =   eps
					_snake_case					:							List[Any]					     =   use_cache
					_snake_case					:							Optional[Any]					     =   vocab_size
					_snake_case					:							int					     =   init_std










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_			      =  logging.get_logger(__name__)

UpperCAmelCase_			      =  {
    '''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 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

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







				def __init__(				self						,	SCREAMING_SNAKE_CASE__=9_61_03						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__="gelu_new"						,	SCREAMING_SNAKE_CASE__=10_24						,	SCREAMING_SNAKE_CASE__=0.1						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.02						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=0						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=1						,	SCREAMING_SNAKE_CASE__="block_sparse"						,	SCREAMING_SNAKE_CASE__=64						,	SCREAMING_SNAKE_CASE__=3						,	SCREAMING_SNAKE_CASE__=False						,	**SCREAMING_SNAKE_CASE__						,	):






					"""simple docstring"""

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

					# extra config
					_snake_case					:							str					     =   attention_type
					_snake_case					:							Tuple					     =   block_size
					_snake_case					:							List[Any]					     =   num_random_blocks
					_snake_case					:							List[str]					     =   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 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				@property
				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

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

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






					"""simple docstring"""

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

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

						_snake_case					:							List[str]					     =   torch.cat(
						    [common_inputs["""decoder_attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )]						,	dim=1      )

						_snake_case					:							Dict					     =   []
						# If the number of encoder and decoder layers are present in the model configuration, both are considered
						_snake_case     , _snake_case					:							str					     =   self.num_layers
						_snake_case					:							Any					     =   min(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
						_snake_case					:							Any					     =   max(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ) - min_num_layers
						_snake_case					:							Union[str, Any]					     =   """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.
						_snake_case					:							List[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 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

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

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							int					     =   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":
						_snake_case					:							List[Any]					     =   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:
						_snake_case					:							Dict					     =   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 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							Union[str, Any]					     =   super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case					:							int					     =   super(SCREAMING_SNAKE_CASE__						,	self      )._flatten_past_key_values_(
						    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )





