



"""simple docstring"""
from ...configuration_utils import PretrainedConfig


SCREAMING_SNAKE_CASE_				= {
    """google/tapas-base-finetuned-sqa""": (
        """https://huggingface.co/google/tapas-base-finetuned-sqa/resolve/main/config.json"""
    ),
    """google/tapas-base-finetuned-wtq""": (
        """https://huggingface.co/google/tapas-base-finetuned-wtq/resolve/main/config.json"""
    ),
    """google/tapas-base-finetuned-wikisql-supervised""": (
        """https://huggingface.co/google/tapas-base-finetuned-wikisql-supervised/resolve/main/config.json"""
    ),
    """google/tapas-base-finetuned-tabfact""": (
        """https://huggingface.co/google/tapas-base-finetuned-tabfact/resolve/main/config.json"""
    ),
}




class 			snake_case_						(						a_				):
							__lowerCAmelCase    					=					"tapas"






							def __init__(   self			,     a_=3_0_5_2_2			,     a_=7_6_8			,     a_=1_2			,     a_=1_2			,     a_=3_0_7_2			,     a_="gelu"			,     a_=0.1			,     a_=0.1			,     a_=1_0_2_4			,     a_=[3, 2_5_6, 2_5_6, 2, 2_5_6, 2_5_6, 1_0]			,     a_=0.02			,     a_=1e-12			,     a_=0			,     a_=10.0			,     a_=0			,     a_=1.0			,     a_=None			,     a_=1.0			,     a_=False			,     a_=None			,     a_=1.0			,     a_=1.0			,     a_=False			,     a_=False			,     a_="ratio"			,     a_=None			,     a_=None			,     a_=6_4			,     a_=3_2			,     a_=False			,     a_=True			,     a_=False			,     a_=False			,     a_=True			,     a_=False			,     a_=None			,     a_=None			,     **a_			,     ):
									super().__init__(pad_token_id=a_			,     **a_      )

									# BERT hyperparameters (with updated max_position_embeddings and type_vocab_sizes)
									a_     :      str 						=     vocab_size
									a_     :      Any 						=     hidden_size
									a_     :      List[str] 						=     num_hidden_layers
									a_     :      Any 						=     num_attention_heads
									a_     :      Tuple 						=     hidden_act
									a_     :      List[Any] 						=     intermediate_size
									a_     :      str 						=     hidden_dropout_prob
									a_     :      Optional[Any] 						=     attention_probs_dropout_prob
									a_     :      Optional[Any] 						=     max_position_embeddings
									a_     :      Optional[Any] 						=     type_vocab_sizes
									a_     :      Optional[Any] 						=     initializer_range
									a_     :      List[Any] 						=     layer_norm_eps

									# Fine-tuning task hyperparameters
									a_     :      int 						=     positive_label_weight
									a_     :      Union[str, Any] 						=     num_aggregation_labels
									a_     :      List[Any] 						=     aggregation_loss_weight
									a_     :      Union[str, Any] 						=     use_answer_as_supervision
									a_     :      Any 						=     answer_loss_importance
									a_     :      List[str] 						=     use_normalized_answer_loss
									a_     :      List[str] 						=     huber_loss_delta
									a_     :      Optional[int] 						=     temperature
									a_     :      List[Any] 						=     aggregation_temperature
									a_     :      int 						=     use_gumbel_for_cells
									a_     :      Tuple 						=     use_gumbel_for_aggregation
									a_     :      str 						=     average_approximation_function
									a_     :      Any 						=     cell_selection_preference
									a_     :      Optional[Any] 						=     answer_loss_cutoff
									a_     :      Union[str, Any] 						=     max_num_rows
									a_     :      str 						=     max_num_columns
									a_     :      Dict 						=     average_logits_per_cell
									a_     :      Tuple 						=     select_one_column
									a_     :      Any 						=     allow_empty_column_selection
									a_     :      Dict 						=     init_cell_selection_weights_to_zero
									a_     :      Optional[int] 						=     reset_position_index_per_cell
									a_     :      Optional[Any] 						=     disable_per_token_loss

									# Aggregation hyperparameters
									a_     :      Dict 						=     aggregation_labels
									a_     :      int 						=     no_aggregation_label_index

									if isinstance(self.aggregation_labels			,     a_      ):
											a_     :      List[Any] 						=     {int(a_      ): v for k, v in aggregation_labels.items()}




"""simple docstring"""
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


SCREAMING_SNAKE_CASE_				= logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_				= {
    """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json""",
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}




class 			snake_case_						(						a_				):
							__lowerCAmelCase    					=					"blenderbot-small"
							__lowerCAmelCase    					=					["past_key_values"]
							__lowerCAmelCase    					=					{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






							def __init__(   self			,     a_=5_0_2_6_5			,     a_=5_1_2			,     a_=8			,     a_=2_0_4_8			,     a_=1_6			,     a_=8			,     a_=2_0_4_8			,     a_=1_6			,     a_=0.0			,     a_=0.0			,     a_=True			,     a_=True			,     a_="gelu"			,     a_=5_1_2			,     a_=0.1			,     a_=0.0			,     a_=0.0			,     a_=0.02			,     a_=1			,     a_=False			,     a_=0			,     a_=1			,     a_=2			,     a_=2			,     **a_			,     ):
									a_     :      int 						=     vocab_size
									a_     :      Any 						=     max_position_embeddings
									a_     :      Optional[int] 						=     d_model
									a_     :      Tuple 						=     encoder_ffn_dim
									a_     :      List[Any] 						=     encoder_layers
									a_     :      Optional[int] 						=     encoder_attention_heads
									a_     :      Optional[int] 						=     decoder_ffn_dim
									a_     :      List[str] 						=     decoder_layers
									a_     :      Dict 						=     decoder_attention_heads
									a_     :      List[str] 						=     dropout
									a_     :      List[Any] 						=     attention_dropout
									a_     :      List[str] 						=     activation_dropout
									a_     :      Optional[Any] 						=     activation_function
									a_     :      List[Any] 						=     init_std
									a_     :      int 						=     encoder_layerdrop
									a_     :      Optional[int] 						=     decoder_layerdrop
									a_     :      List[str] 						=     use_cache
									a_     :      Optional[int] 						=     encoder_layers
									a_     :      Optional[int] 						=     scale_embedding  # scale factor will be sqrt(d_model) if True

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




class 			snake_case_						(						a_				):






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

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






							def snake_case_  (   self			,     a_			,     a_ = -1			,     a_ = -1			,     a_ = False			,     a_ = None			,     ):
									a_     :      List[str] 						=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    a_			,     a_			,     a_			,     a_			,     a_      )

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

											a_     :      Dict 						=     torch.cat(
											    [common_inputs["decoder_attention_mask"], torch.ones(a_			,     a_      )]			,     dim=1      )

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

											a_     :      str 						=     common_inputs["attention_mask"].dtype
											a_     :      Tuple 						=     torch.cat(
											    [common_inputs["attention_mask"], torch.ones(a_			,     a_			,     dtype=a_      )]			,     dim=1      )
											a_     :      Optional[int] 						=     [
											    (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			,     ):
									# 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
									a_     :      Optional[Any] 						=     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
									a_     :      Tuple 						=     tokenizer.num_special_tokens_to_add(a_      )
									a_     :      Union[str, Any] 						=     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
									a_     :      Union[str, Any] 						=     [" ".join([tokenizer.unk_token]      ) * seq_length] * batch_size
									a_     :      str 						=     dict(tokenizer(a_			,     return_tensors=a_      )      )
									return common_inputs






							def snake_case_  (   self			,     a_			,     a_ = -1			,     a_ = -1			,     a_ = False			,     a_ = None			,     ):
									if self.task in ["default", "seq2seq-lm"]:
											a_     :      List[str] 						=     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":
											a_     :      List[Any] 						=     self._generate_dummy_inputs_for_causal_lm(
											    a_			,     batch_size=a_			,     seq_length=a_			,     is_pair=a_			,     framework=a_      )
									else:
											a_     :      Union[str, Any] 						=     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_      ):
									if self.task in ["default", "seq2seq-lm"]:
											a_     :      Optional[int] 						=     super()._flatten_past_key_values_(a_			,     a_			,     a_			,     a_      )
									else:
											a_     :      int 						=     super(a_			,     self      )._flatten_past_key_values_(
											    a_			,     a_			,     a_			,     a_      )