from typing import Optional, Tuple

import flax.linen as nn
import jax
import jax.numpy as jnp
from configuration_hybrid_clip import HybridCLIPConfig
from flax.core.frozen_dict import FrozenDict

from transformers import FLAX_MODEL_MAPPING, FlaxCLIPVisionModel
from transformers.modeling_flax_utils import FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPOutput
from transformers.utils import logging


__lowerCAmelCase    :  Tuple										= logging.get_logger(__name__)
class 				lowerCamelCase			(							nn.Module					):
      __lowerCamelCase							=					42
      __lowerCamelCase							=					jnp.floataa






      def 			lowerCAmelCase_   (      self						)     ->				Optional[int]:


          '''simple docstring'''







          snake_case:						Tuple         =   self.config.text_config
          snake_case:						Optional[int]         =   self.config.vision_config

          snake_case:						str         =   self.config.projection_dim
          snake_case:						int         =   text_config.hidden_size
          snake_case:						Union[str, Any]         =   vision_config.hidden_size

          snake_case:						Optional[Any]         =   FLAX_MODEL_MAPPING[self.config.text_config.__class__].module_class
          snake_case:						Any         =   FLAX_MODEL_MAPPING.get(self.config.vision_config.__class__  ,		__lowerCamelCase						).module_class

          snake_case:						Optional[Any]         =   text_module(__lowerCamelCase  ,		dtype=self.dtype						)
          snake_case:						Optional[Any]         =   vision_module(__lowerCamelCase  ,		dtype=self.dtype						)

          snake_case:						int         =   nn.Dense(
              self.projection_dim  ,		dtype=self.dtype  ,		kernel_init=jax.nn.initializers.normal(0.02						)  ,		use_bias=__lowerCamelCase  ,		)
          snake_case:						int         =   nn.Dense(
              self.projection_dim  ,		dtype=self.dtype  ,		kernel_init=jax.nn.initializers.normal(0.02						)  ,		use_bias=__lowerCamelCase  ,		)
          snake_case:						Optional[Any]         =   self.param("""logit_scale"""  ,		jax.nn.initializers.ones  ,		[]						)






      def __call__(      self  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase = True  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		)     ->				Any:


          '''simple docstring'''







          snake_case:						int         =   return_dict if return_dict is not None else self.config.return_dict

          snake_case:						Tuple         =   self.vision_model(
              pixel_values=__lowerCamelCase  ,		deterministic=__lowerCamelCase  ,		output_attentions=__lowerCamelCase  ,		output_hidden_states=__lowerCamelCase  ,		return_dict=__lowerCamelCase  ,		)

          snake_case:						Optional[int]         =   self.text_model(
              input_ids=__lowerCamelCase  ,		attention_mask=__lowerCamelCase  ,		token_type_ids=__lowerCamelCase  ,		position_ids=__lowerCamelCase  ,		deterministic=__lowerCamelCase  ,		output_attentions=__lowerCamelCase  ,		output_hidden_states=__lowerCamelCase  ,		return_dict=__lowerCamelCase  ,		)

          snake_case:						Union[str, Any]         =   vision_outputs[1]
          snake_case:						Tuple         =   self.visual_projection(__lowerCamelCase						)

          snake_case:						List[Any]         =   text_outputs[1]
          snake_case:						Any         =   self.text_projection(__lowerCamelCase						)

          # normalized features
          snake_case:						int         =   image_embeds / jnp.linalg.norm(__lowerCamelCase  ,		axis=-1  ,		keepdims=__lowerCamelCase						)
          snake_case:						Dict         =   text_embeds / jnp.linalg.norm(__lowerCamelCase  ,		axis=-1  ,		keepdims=__lowerCamelCase						)

          # cosine similarity as logits
          snake_case:						Dict         =   jnp.exp(self.logit_scale						)
          snake_case:						Union[str, Any]         =   jnp.matmul(__lowerCamelCase  ,		image_embeds.T						) * logit_scale
          snake_case:						Dict         =   logits_per_text.T

          if not return_dict:
              return (logits_per_image, logits_per_text, text_embeds, image_embeds, text_outputs, vision_outputs)

          return FlaxCLIPOutput(
              logits_per_image=__lowerCamelCase  ,		logits_per_text=__lowerCamelCase  ,		text_embeds=__lowerCamelCase  ,		image_embeds=__lowerCamelCase  ,		text_model_output=__lowerCamelCase  ,		vision_model_output=__lowerCamelCase  ,		)





class 				lowerCamelCase			(							__snake_case					):
      __lowerCamelCase							=					HybridCLIPConfig
      __lowerCamelCase							=					FlaxHybridCLIPModule






      def __init__(      self  ,		__lowerCamelCase  ,		__lowerCamelCase = None  ,		__lowerCamelCase = 0  ,		__lowerCamelCase = jnp.floataa  ,		**__lowerCamelCase  ,		)     ->				int:


          '''simple docstring'''







          if input_shape is None:
              snake_case:						List[Any]         =   ((1, 1), (1, config.vision_config.image_size, config.vision_config.image_size, 3))

          snake_case:						str         =   self.module_class(config=__lowerCamelCase  ,		dtype=__lowerCamelCase  ,		**__lowerCamelCase						)
          super().__init__(__lowerCamelCase  ,		__lowerCamelCase  ,		input_shape=__lowerCamelCase  ,		seed=__lowerCamelCase  ,		dtype=__lowerCamelCase						)






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase = None						)     ->				FrozenDict:


          '''simple docstring'''







          snake_case:						str         =   jnp.zeros(input_shape[0]  ,		dtype="""i4"""						)
          snake_case:						List[Any]         =   jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__lowerCamelCase						).shape[-1]						)  ,		input_shape[0]						)
          snake_case:						List[Any]         =   jnp.ones_like(__lowerCamelCase						)
          snake_case:						Optional[Any]         =   jnp.ones_like(__lowerCamelCase						)

          snake_case:						Optional[int]         =   jax.random.normal(__lowerCamelCase  ,		input_shape[1]						)

          snake_case    , snake_case:						Any         =   jax.random.split(__lowerCamelCase						)
          snake_case:						int         =   {"""params""": params_rng, """dropout""": dropout_rng}

          return self.module.init(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)["params"]






      def __call__(      self  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		)     ->				str:


          '''simple docstring'''







          snake_case:						Dict         =   output_attentions if output_attentions is not None else self.config.output_attentions
          snake_case:						Optional[int]         =   (
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          snake_case:						List[str]         =   return_dict if return_dict is not None else self.config.return_dict

          if position_ids is None:
              snake_case:						List[Any]         =   jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__lowerCamelCase						).shape[-1]						)  ,		input_ids.shape						)

          if token_type_ids is None:
              snake_case:						Union[str, Any]         =   jnp.zeros_like(__lowerCamelCase						)

          if attention_mask is None:
              snake_case:						Any         =   jnp.ones_like(__lowerCamelCase						)

          # Handle any PRNG if needed
          snake_case:						Dict         =   {}
          if dropout_rng is not None:
              snake_case:						Optional[Any]         =   dropout_rng

          return self.module.apply(
              {"""params""": params or self.params}  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype=jnp.floataa						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		not train  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		rngs=__lowerCamelCase  ,		)






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase=None  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		__lowerCamelCase=False  ,		)     ->				Optional[Any]:


          '''simple docstring'''







          if position_ids is None:
              snake_case:						Any         =   jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__lowerCamelCase						).shape[-1]						)  ,		input_ids.shape						)

          if token_type_ids is None:
              snake_case:						Tuple         =   jnp.zeros_like(__lowerCamelCase						)

          if attention_mask is None:
              snake_case:						Tuple         =   jnp.ones_like(__lowerCamelCase						)

          # Handle any PRNG if needed
          snake_case:						Dict         =   {}
          if dropout_rng is not None:
              snake_case:						Optional[Any]         =   dropout_rng

          def _get_features(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						):
              snake_case:						Optional[int]         =   module.text_model(
                  input_ids=__lowerCamelCase  ,		attention_mask=__lowerCamelCase  ,		position_ids=__lowerCamelCase  ,		token_type_ids=__lowerCamelCase  ,		deterministic=__lowerCamelCase  ,		)
              snake_case:						int         =   text_outputs[1]
              snake_case:						Union[str, Any]         =   module.text_projection(__lowerCamelCase						)
              return text_features

          return self.module.apply(
              {"""params""": params or self.params}  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		jnp.array(__lowerCamelCase  ,		dtype="""i4"""						)  ,		not train  ,		method=_get_features  ,		rngs=__lowerCamelCase  ,		)






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		__lowerCamelCase=False						)     ->				Any:


          '''simple docstring'''







          snake_case:						Tuple         =   {}
          if dropout_rng is not None:
              snake_case:						Optional[int]         =   dropout_rng

          def _get_features(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						):
              snake_case:						Tuple         =   module.vision_model(pixel_values=__lowerCamelCase  ,		deterministic=__lowerCamelCase						)
              snake_case:						str         =   vision_outputs[1]  # pooled_output
              snake_case:						str         =   module.visual_projection(__lowerCamelCase						)
              return image_features

          return self.module.apply(
              {"""params""": params or self.params}  ,		jnp.array(__lowerCamelCase  ,		dtype=jnp.floataa						)  ,		not train  ,		method=_get_features  ,		rngs=__lowerCamelCase  ,		)






      @classmethod
      def 			lowerCAmelCase_   (      cls  ,		__lowerCamelCase = None  ,		__lowerCamelCase = None  ,		*__lowerCamelCase  ,		**__lowerCamelCase  ,		)     ->				FlaxPreTrainedModel:


          '''simple docstring'''







          snake_case:						Dict         =   {
              argument[len("""text_"""						) :]: value for argument, value in kwargs.items() if argument.startswith("""text_"""						)
          }

          snake_case:						Optional[Any]         =   {
              argument[len("""vision_"""						) :]: value for argument, value in kwargs.items() if argument.startswith("""vision_"""						)
          }

          # remove text, vision kwargs from kwargs
          for key in kwargs_text.keys():
              del kwargs["text_" + key]
          for key in kwargs_vision.keys():
              del kwargs["vision_" + key]

          # Load and initialize the text and vision model
          snake_case:						Union[str, Any]         =   kwargs_text.pop("""model"""  ,		__lowerCamelCase						)
          if text_model is None:
              assert (
                  text_model_name_or_path is not None
              ), "If `model` is not defined as an argument, a `text_model_name_or_path` has to be defined"
              from transformers import FlaxAutoModel

              if "config" not in kwargs_text:
                  from transformers import AutoConfig

                  snake_case:						Union[str, Any]         =   AutoConfig.from_pretrained(__lowerCamelCase						)
                  snake_case:						Optional[Any]         =   text_config

              snake_case:						Optional[Any]         =   FlaxAutoModel.from_pretrained(__lowerCamelCase  ,		*__lowerCamelCase  ,		**__lowerCamelCase						)

          snake_case:						str         =   kwargs_vision.pop("""model"""  ,		__lowerCamelCase						)
          if vision_model is None:
              assert (
                  vision_model_name_or_path is not None
              ), "If `model` is not defined as an argument, a `vision_model_name_or_path` has to be defined"
              from transformers import FlaxAutoModel

              if "config" not in kwargs_vision:
                  from transformers import AutoConfig

                  snake_case:						Dict         =   AutoConfig.from_pretrained(__lowerCamelCase						)
                  snake_case:						int         =   vision_config

              snake_case:						Optional[Any]         =   FlaxAutoModel.from_pretrained(__lowerCamelCase  ,		*__lowerCamelCase  ,		**__lowerCamelCase						)

          # instantiate config with corresponding kwargs
          snake_case:						List[Any]         =   kwargs.pop("""dtype"""  ,		jnp.floataa						)
          snake_case:						Optional[int]         =   HybridCLIPConfig.from_text_vision_configs(text_model.config  ,		vision_model.config  ,		**__lowerCamelCase						)

          # init model
          snake_case:						Dict         =   cls(__lowerCamelCase  ,		*__lowerCamelCase  ,		dtype=__lowerCamelCase  ,		**__lowerCamelCase						)

          if vision_config.model_type == "clip":
              snake_case:						Dict         =   vision_model.params["""vision_model"""]
              snake_case:						List[str]         =   vision_model.params["""visual_projection"""]["""kernel"""]
          else:
              snake_case:						Union[str, Any]         =   vision_model.params

          snake_case:						Tuple         =   text_model.params

          return model



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[int]										= logging.get_logger(__name__)

__lowerCAmelCase    :  Dict										= {
    '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 				lowerCamelCase			(							__snake_case					):
      __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  ,		__lowerCamelCase=9_61_03  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=16  ,		__lowerCamelCase=40_96  ,		__lowerCamelCase=16  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=True  ,		__lowerCamelCase=True  ,		__lowerCamelCase="gelu_new"  ,		__lowerCamelCase=10_24  ,		__lowerCamelCase=0.1  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=0.02  ,		__lowerCamelCase=2  ,		__lowerCamelCase=0.0  ,		__lowerCamelCase=True  ,		__lowerCamelCase=0  ,		__lowerCamelCase=2  ,		__lowerCamelCase=1  ,		__lowerCamelCase="block_sparse"  ,		__lowerCamelCase=64  ,		__lowerCamelCase=3  ,		__lowerCamelCase=False  ,		**__lowerCamelCase  ,		)     ->				Dict:


          '''simple docstring'''







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

          # extra config
          snake_case:						Union[str, Any]         =   attention_type
          snake_case:						Optional[int]         =   block_size
          snake_case:						Optional[int]         =   num_random_blocks
          snake_case:						List[Any]         =   use_bias

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





class 				lowerCamelCase			(							__snake_case					):






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


          '''simple docstring'''







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

              if self.use_past:
                  snake_case:						List[Any]         =   {0: """batch"""}
                  snake_case:						Optional[int]         =   {0: """batch""", 1: """past_decoder_sequence + sequence"""}
              else:
                  snake_case:						List[Any]         =   {0: """batch""", 1: """decoder_sequence"""}
                  snake_case:						Union[str, Any]         =   {0: """batch""", 1: """decoder_sequence"""}

              if self.use_past:
                  self.fill_with_past_key_values_(__lowerCamelCase  ,		direction="""inputs"""						)
          elif self.task == "causal-lm":
              # TODO: figure this case out.
              snake_case:						List[str]         =   OrderedDict(
                  [
                      ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
                      ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
                  ]						)
              if self.use_past:
                  snake_case    , snake_case:						str         =   self.num_layers
                  for i in range(__lowerCamelCase						):
                      snake_case:						Any         =   {0: """batch""", 2: """past_sequence + sequence"""}
                      snake_case:						str         =   {0: """batch""", 2: """past_sequence + sequence"""}
          else:
              snake_case:						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 			lowerCAmelCase_   (      self						)     ->				Mapping[str, Mapping[int, str]]:


          '''simple docstring'''







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






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						List[Any]         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)

          # Generate decoder inputs
          snake_case:						Any         =   seq_length if not self.use_past else 1
          snake_case:						List[str]         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)
          snake_case:						Dict         =   {F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
          snake_case:						List[str]         =   dict(**__lowerCamelCase  ,		**__lowerCamelCase						)

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

              snake_case:						Tuple         =   torch.cat(
                  [common_inputs["""decoder_attention_mask"""], torch.ones(__lowerCamelCase  ,		__lowerCamelCase						)]  ,		dim=1						)

              snake_case:						Tuple         =   []
              # If the number of encoder and decoder layers are present in the model configuration, both are considered
              snake_case    , snake_case:						Union[str, Any]         =   self.num_layers
              snake_case:						List[str]         =   min(__lowerCamelCase  ,		__lowerCamelCase						)
              snake_case:						List[str]         =   max(__lowerCamelCase  ,		__lowerCamelCase						) - min_num_layers
              snake_case:						Union[str, Any]         =   """encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

              for _ in range(__lowerCamelCase						):
                  common_inputs["past_key_values"].append(
                      (
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                          torch.zeros(__lowerCamelCase						),
                      )						)
              # TODO: test this.
              snake_case:						Dict         =   encoder_shape if remaining_side_name == """encoder""" else decoder_shape
              for _ in range(__lowerCamelCase  ,		__lowerCamelCase						):
                  common_inputs["past_key_values"].append((torch.zeros(__lowerCamelCase						), torch.zeros(__lowerCamelCase						))						)
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						Any         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)

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

              snake_case:						int         =   common_inputs["""attention_mask"""].dtype
              snake_case:						Union[str, Any]         =   torch.cat(
                  [common_inputs["""attention_mask"""], torch.ones(__lowerCamelCase  ,		__lowerCamelCase  ,		dtype=__lowerCamelCase						)]  ,		dim=1						)
              snake_case:						Dict         =   [
                  (torch.zeros(__lowerCamelCase						), torch.zeros(__lowerCamelCase						)) for _ in range(__lowerCamelCase						)
              ]
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          snake_case:						str         =   compute_effective_axis_dimension(
              __lowerCamelCase  ,		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:						str         =   tokenizer.num_special_tokens_to_add(__lowerCamelCase						)
          snake_case:						int         =   compute_effective_axis_dimension(
              __lowerCamelCase  ,		fixed_dimension=OnnxConfig.default_fixed_sequence  ,		num_token_to_add=__lowerCamelCase						)

          # Generate dummy inputs according to compute batch and sequence
          snake_case:						Dict         =   [""" """.join([tokenizer.unk_token]						) * seq_length] * batch_size
          snake_case:						Any         =   dict(tokenizer(__lowerCamelCase  ,		return_tensors=__lowerCamelCase						)						)
          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = -1  ,		__lowerCamelCase = False  ,		__lowerCamelCase = None  ,		)     ->				Mapping[str, Any]:


          '''simple docstring'''







          if self.task in ["default", "seq2seq-lm"]:
              snake_case:						Union[str, Any]         =   self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)

          elif self.task == "causal-lm":
              snake_case:						Union[str, Any]         =   self._generate_dummy_inputs_for_causal_lm(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)
          else:
              snake_case:						int         =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                  __lowerCamelCase  ,		batch_size=__lowerCamelCase  ,		seq_length=__lowerCamelCase  ,		is_pair=__lowerCamelCase  ,		framework=__lowerCamelCase						)

          return common_inputs






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)     ->				List[Any]:


          '''simple docstring'''







          if self.task in ["default", "seq2seq-lm"]:
              snake_case:						Optional[int]         =   super()._flatten_past_key_values_(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)
          else:
              snake_case:						List[str]         =   super(__lowerCamelCase  ,		self						)._flatten_past_key_values_(
                  __lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)


