





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


__lowerCAmelCase							:			Optional[Any]				=logging.get_logger(__name__)

__lowerCAmelCase							:			Any				={
    "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__       ):
 __lowercase     	=       """bigbird_pegasus"""
 __lowercase     	=       ["""past_key_values"""]
 __lowercase     	=       {
     """num_attention_heads""": """encoder_attention_heads""",
     """hidden_size""": """d_model""",
     """attention_probs_dropout_prob""": """attention_dropout""",
 }
 def __init__(       self   :int		, lowercase_   :int=9_61_03		, lowercase_   :int=40_96		, lowercase_   :Any=16		, lowercase_   :int=40_96		, lowercase_   :Dict=16		, lowercase_   :List[str]=16		, lowercase_   :Tuple=40_96		, lowercase_   :Tuple=16		, lowercase_   :Tuple=0.0		, lowercase_   :Optional[int]=0.0		, lowercase_   :Optional[int]=True		, lowercase_   :Tuple=True		, lowercase_   :Any="gelu_new"		, lowercase_   :Dict=10_24		, lowercase_   :Dict=0.1		, lowercase_   :Union[str, Any]=0.0		, lowercase_   :Dict=0.0		, lowercase_   :Optional[int]=0.0_2		, lowercase_   :Dict=2		, lowercase_   :Optional[Any]=0.0		, lowercase_   :int=True		, lowercase_   :Optional[int]=0		, lowercase_   :List[Any]=2		, lowercase_   :Optional[Any]=1		, lowercase_   :Optional[Any]="block_sparse"		, lowercase_   :List[Any]=64		, lowercase_   :str=3		, lowercase_   :int=False		, **lowercase_   :Any		, )->							Union[str, Any]:
     A__       =    vocab_size
     A__       =    max_position_embeddings
     A__       =    d_model
     A__       =    encoder_ffn_dim
     A__       =    encoder_layers
     A__       =    encoder_attention_heads
     A__       =    decoder_ffn_dim
     A__       =    decoder_layers
     A__       =    decoder_attention_heads
     A__       =    dropout
     A__       =    attention_dropout
     A__       =    activation_dropout
     A__       =    activation_function
     A__       =    init_std
     A__       =    encoder_layerdrop
     A__       =    decoder_layerdrop
     A__       =    classifier_dropout
     A__       =    use_cache
     A__       =    encoder_layers
     A__       =    scale_embedding  # scale factor will be sqrt(d_model) if True

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

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






class      UpperCAmelCase			( UpperCamelCase__       ):
 @property
 def   UpperCAmelCase_							(       self   :Optional[Any]							)->							Mapping[str, Mapping[int, str]]:
     if self.task in ["default", "seq2seq-lm"]:
         A__       =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]							)

         if self.use_past:
             A__       =    {0: "batch"}
             A__       =    {0: "batch", 1: "past_decoder_sequence + sequence"}
         else:
             A__       =    {0: "batch", 1: "decoder_sequence"}
             A__       =    {0: "batch", 1: "decoder_sequence"}

         if self.use_past:
             self.fill_with_past_key_values_(lowercase_		, direction="inputs"							)
     elif self.task == "causal-lm":
         # TODO: figure this case out.
         A__       =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ]							)
         if self.use_past:
             A__,			A__       =    self.num_layers
             for i in range(lowercase_							):
                 A__       =    {0: "batch", 2: "past_sequence + sequence"}
                 A__       =    {0: "batch", 2: "past_sequence + sequence"}
     else:
         A__       =    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   UpperCAmelCase_							(       self   :Optional[int]							)->							Mapping[str, Mapping[int, str]]:
     if self.task in ["default", "seq2seq-lm"]:
         A__       =    super().outputs
     else:
         A__       =    super(lowercase_		, self							).outputs
         if self.use_past:
             A__,			A__       =    self.num_layers
             for i in range(lowercase_							):
                 A__       =    {0: "batch", 2: "past_sequence + sequence"}
                 A__       =    {0: "batch", 2: "past_sequence + sequence"}
     return common_outputs
 def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :PreTrainedTokenizer		, lowercase_   :int = -1		, lowercase_   :int = -1		, lowercase_   :bool = False		, lowercase_   :Optional[TensorType] = None		, )->							Mapping[str, Any]:
     A__       =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_		, lowercase_		, lowercase_		, lowercase_		, lowercase_							)

     # Generate decoder inputs
     A__       =    seq_length if not self.use_past else 1
     A__       =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_		, lowercase_		, lowercase_		, lowercase_		, lowercase_							)
     A__       =    {F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
     A__       =    dict(**lowercase_		, **lowercase_							)

     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__       =    common_inputs["input_ids"].shape
         A__       =    common_inputs["decoder_input_ids"].shape[1]
         A__,			A__       =    self.num_attention_heads
         A__       =    (
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         A__       =    decoder_seq_length + 3
         A__       =    (
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )

         A__       =    torch.cat(
             [common_inputs["decoder_attention_mask"], torch.ones(lowercase_		, lowercase_							)]		, dim=1							)

         A__       =    []
         # If the number of encoder and decoder layers are present in the model configuration, both are considered
         A__,			A__       =    self.num_layers
         A__       =    min(lowercase_		, lowercase_							)
         A__       =    max(lowercase_		, lowercase_							) - min_num_layers
         A__       =    "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

         for _ in range(lowercase_							):
             common_inputs["past_key_values"].append(
                 (
                     torch.zeros(lowercase_							),
                     torch.zeros(lowercase_							),
                     torch.zeros(lowercase_							),
                     torch.zeros(lowercase_							),
                 )							)
         # TODO: test this.
         A__       =    encoder_shape if remaining_side_name == "encoder" else decoder_shape
         for _ in range(lowercase_		, lowercase_							):
             common_inputs["past_key_values"].append((torch.zeros(lowercase_							), torch.zeros(lowercase_							))							)
     return common_inputs
 def   UpperCAmelCase_							(       self   :Optional[Any]		, lowercase_   :PreTrainedTokenizer		, lowercase_   :int = -1		, lowercase_   :int = -1		, lowercase_   :bool = False		, lowercase_   :Optional[TensorType] = None		, )->							Mapping[str, Any]:
     A__       =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_		, lowercase_		, lowercase_		, lowercase_		, lowercase_							)

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

         A__       =    common_inputs["attention_mask"].dtype
         A__       =    torch.cat(
             [common_inputs["attention_mask"], torch.ones(lowercase_		, lowercase_		, dtype=lowercase_							)]		, dim=1							)
         A__       =    [
             (torch.zeros(lowercase_							), torch.zeros(lowercase_							)) for _ in range(lowercase_							)
         ]
     return common_inputs
 def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :PreTrainedTokenizer		, lowercase_   :int = -1		, lowercase_   :int = -1		, lowercase_   :bool = False		, lowercase_   :Optional[TensorType] = 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
     A__       =    compute_effective_axis_dimension(
         lowercase_		, 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__       =    tokenizer.num_special_tokens_to_add(lowercase_							)
     A__       =    compute_effective_axis_dimension(
         lowercase_		, fixed_dimension=OnnxConfig.default_fixed_sequence		, num_token_to_add=lowercase_							)

     # Generate dummy inputs according to compute batch and sequence
     A__       =    [" ".join([tokenizer.unk_token]							) * seq_length] * batch_size
     A__       =    dict(tokenizer(lowercase_		, return_tensors=lowercase_							)							)
     return common_inputs
 def   UpperCAmelCase_							(       self   :List[str]		, lowercase_   :PreTrainedTokenizer		, lowercase_   :int = -1		, lowercase_   :int = -1		, lowercase_   :bool = False		, lowercase_   :Optional[TensorType] = None		, )->							Mapping[str, Any]:
     if self.task in ["default", "seq2seq-lm"]:
         A__       =    self._generate_dummy_inputs_for_default_and_seqaseq_lm(
             lowercase_		, batch_size=lowercase_		, seq_length=lowercase_		, is_pair=lowercase_		, framework=lowercase_							)

     elif self.task == "causal-lm":
         A__       =    self._generate_dummy_inputs_for_causal_lm(
             lowercase_		, batch_size=lowercase_		, seq_length=lowercase_		, is_pair=lowercase_		, framework=lowercase_							)
     else:
         A__       =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             lowercase_		, batch_size=lowercase_		, seq_length=lowercase_		, is_pair=lowercase_		, framework=lowercase_							)

     return common_inputs



 def   UpperCAmelCase_							(       self   :Dict		, lowercase_   :List[str]		, lowercase_   :str		, lowercase_   :Optional[int]		, lowercase_   :List[str]							)->							List[str]:
     if self.task in ["default", "seq2seq-lm"]:
         A__       =    super()._flatten_past_key_values_(lowercase_		, lowercase_		, lowercase_		, lowercase_							)
     else:
         A__       =    super(lowercase_		, self							)._flatten_past_key_values_(
             lowercase_		, lowercase_		, lowercase_		, lowercase_							)










'''simple docstring'''

import warnings

from ...utils import logging
from .image_processing_vilt import ViltImageProcessor


__lowerCAmelCase							:			Dict				=logging.get_logger(__name__)






class      UpperCAmelCase			( UpperCamelCase__       ):
 def __init__(       self   :List[str]		, *lowercase_   :Dict		, **lowercase_   :int							)->							None:
     warnings.warn(
         "The class ViltFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
         " use ViltImageProcessor instead."		, lowercase_		, )
     super().__init__(*lowercase_		, **lowercase_							)



