





import argparse
import json
import os

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__lowercase													=			logging.get_logger(__name__)


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		int):



  '''simple docstring'''






  __lowerCAmelCase			=				ConvNextVaConfig()

  if "atto" in checkpoint_url:
    __lowerCAmelCase			=				[2, 2, 6, 2]
    __lowerCAmelCase			=				[40, 80, 1_60, 3_20]
  if "femto" in checkpoint_url:
    __lowerCAmelCase			=				[2, 2, 6, 2]
    __lowerCAmelCase			=				[48, 96, 1_92, 3_84]
  if "pico" in checkpoint_url:
    __lowerCAmelCase			=				[2, 2, 6, 2]
    __lowerCAmelCase			=				[64, 1_28, 2_56, 5_12]
  if "nano" in checkpoint_url:
    __lowerCAmelCase			=				[2, 2, 8, 2]
    __lowerCAmelCase			=				[80, 1_60, 3_20, 6_40]
  if "tiny" in checkpoint_url:
    __lowerCAmelCase			=				[3, 3, 9, 3]
    __lowerCAmelCase			=				[96, 1_92, 3_84, 7_68]
  if "base" in checkpoint_url:
    __lowerCAmelCase			=				[3, 3, 27, 3]
    __lowerCAmelCase			=				[1_28, 2_56, 5_12, 10_24]
  if "large" in checkpoint_url:
    __lowerCAmelCase			=				[3, 3, 27, 3]
    __lowerCAmelCase			=				[1_92, 3_84, 7_68, 15_36]
  if "huge" in checkpoint_url:
    __lowerCAmelCase			=				[3, 3, 27, 3]
    __lowerCAmelCase			=				[3_52, 7_04, 14_08, 28_16]

  __lowerCAmelCase			=				10_00
  __lowerCAmelCase			=				'''imagenet-1k-id2label.json'''
  __lowerCAmelCase			=				(1, 10_00)

  __lowerCAmelCase			=				'''huggingface/label-files'''
  __lowerCAmelCase			=				num_labels
  __lowerCAmelCase			=				json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ,							repo_type='''dataset''')     ,							'''r'''))
  __lowerCAmelCase			=				{int(SCREAMING_SNAKE_CASE__): v for k, v in idalabel.items()}

  __lowerCAmelCase			=				idalabel
  __lowerCAmelCase			=				{v: k for k, v in idalabel.items()}
  __lowerCAmelCase			=				hidden_sizes
  __lowerCAmelCase			=				depths

  return config, expected_shape


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		int):



  '''simple docstring'''






  if "downsample_layers.0.0" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.0.0'''     ,							'''embeddings.patch_embeddings''')
  if "downsample_layers.0.1" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.0.1'''     ,							'''embeddings.norm''')  # we rename to layernorm later on
  if "downsample_layers.1.0" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.1.0'''     ,							'''stages.1.downsampling_layer.0''')
  if "downsample_layers.1.1" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.1.1'''     ,							'''stages.1.downsampling_layer.1''')
  if "downsample_layers.2.0" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.2.0'''     ,							'''stages.2.downsampling_layer.0''')
  if "downsample_layers.2.1" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.2.1'''     ,							'''stages.2.downsampling_layer.1''')
  if "downsample_layers.3.0" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.3.0'''     ,							'''stages.3.downsampling_layer.0''')
  if "downsample_layers.3.1" in name:
    __lowerCAmelCase			=				name.replace('''downsample_layers.3.1'''     ,							'''stages.3.downsampling_layer.1''')
  if "stages" in name and "downsampling_layer" not in name:
    # stages.0.0. for instance should be renamed to stages.0.layers.0.
    __lowerCAmelCase			=				name[: len('''stages.0''')] + '''.layers''' + name[len('''stages.0''') :]
  if "gamma" in name:
    __lowerCAmelCase			=				name.replace('''gamma'''     ,							'''weight''')
  if "beta" in name:
    __lowerCAmelCase			=				name.replace('''beta'''     ,							'''bias''')
  if "stages" in name:
    __lowerCAmelCase			=				name.replace('''stages'''     ,							'''encoder.stages''')
  if "norm" in name:
    __lowerCAmelCase			=				name.replace('''norm'''     ,							'''layernorm''')
  if "head" in name:
    __lowerCAmelCase			=				name.replace('''head'''     ,							'''classifier''')

  return name


def 					__SCREAMING_SNAKE_CASE  (							):



  '''simple docstring'''






  __lowerCAmelCase			=				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
  __lowerCAmelCase			=				Image.open(requests.get(SCREAMING_SNAKE_CASE__     ,							stream=SCREAMING_SNAKE_CASE__).raw)
  return im


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		Optional[Any]):



  '''simple docstring'''






  if "224" in checkpoint_url:
    __lowerCAmelCase			=				2_24
    __lowerCAmelCase			=				2_24 / 2_56
  elif "384" in checkpoint_url:
    __lowerCAmelCase			=				3_84
    __lowerCAmelCase			=				None
  else:
    __lowerCAmelCase			=				5_12
    __lowerCAmelCase			=				None

  return ConvNextImageProcessor(
      size=SCREAMING_SNAKE_CASE__     ,							crop_pct=SCREAMING_SNAKE_CASE__     ,							image_mean=[0.485, 0.456, 0.406]     ,							image_std=[0.229, 0.224, 0.225]     ,							resample=PILImageResampling.BICUBIC     ,							)


@torch.no_grad()
def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		Tuple     ,							__lowercase:		List[str]     ,							__lowercase:		List[Any]     ,							__lowercase:		Union[str, Any]):



  '''simple docstring'''






  print('''Downloading original model from checkpoint...''')
  # define ConvNeXTV2 configuration based on URL
  __lowerCAmelCase			=				get_convnextva_config(SCREAMING_SNAKE_CASE__)
  # load original state_dict from URL
  __lowerCAmelCase			=				torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__)['''model''']

  print('''Converting model parameters...''')
  # rename keys
  for key in state_dict.copy().keys():
    __lowerCAmelCase			=				state_dict.pop(SCREAMING_SNAKE_CASE__)
    __lowerCAmelCase			=				val
  # add prefix to all keys expect classifier head
  for key in state_dict.copy().keys():
    __lowerCAmelCase			=				state_dict.pop(SCREAMING_SNAKE_CASE__)
    if not key.startswith('''classifier'''):
      __lowerCAmelCase			=				'''convnextv2.''' + key
    __lowerCAmelCase			=				val

  # load HuggingFace model
  __lowerCAmelCase			=				ConvNextVaForImageClassification(SCREAMING_SNAKE_CASE__)
  model.load_state_dict(SCREAMING_SNAKE_CASE__)
  model.eval()

  # Check outputs on an image, prepared by ConvNextImageProcessor
  __lowerCAmelCase			=				convert_preprocessor(SCREAMING_SNAKE_CASE__)
  __lowerCAmelCase			=				preprocessor(images=prepare_img()     ,							return_tensors='''pt''')
  __lowerCAmelCase			=				model(**SCREAMING_SNAKE_CASE__).logits

  # note: the logits below were obtained without center cropping
  if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
    __lowerCAmelCase			=				torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309])
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
    __lowerCAmelCase			=				torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826])
  else:
    raise ValueError(F'''Unknown URL: {checkpoint_url}''')

  assert torch.allclose(logits[0, :5]     ,							SCREAMING_SNAKE_CASE__     ,							atol=1E-3)
  assert logits.shape == expected_shape
  print('''Model outputs match the original results!''')

  if save_model:
    print('''Saving model to local...''')
    # Create folder to save model
    if not os.path.isdir(SCREAMING_SNAKE_CASE__):
      os.mkdir(SCREAMING_SNAKE_CASE__)

    model.save_pretrained(SCREAMING_SNAKE_CASE__)
    preprocessor.save_pretrained(SCREAMING_SNAKE_CASE__)

  __lowerCAmelCase			=				'''convnextv2'''
  if "atto" in checkpoint_url:
    model_name += "-atto"
  if "femto" in checkpoint_url:
    model_name += "-femto"
  if "pico" in checkpoint_url:
    model_name += "-pico"
  if "nano" in checkpoint_url:
    model_name += "-nano"
  elif "tiny" in checkpoint_url:
    model_name += "-tiny"
  elif "base" in checkpoint_url:
    model_name += "-base"
  elif "large" in checkpoint_url:
    model_name += "-large"
  elif "huge" in checkpoint_url:
    model_name += "-huge"
  if "22k" in checkpoint_url and "1k" not in checkpoint_url:
    model_name += "-22k"
  elif "22k" in checkpoint_url and "1k" in checkpoint_url:
    model_name += "-22k-1k"
  elif "1k" in checkpoint_url:
    model_name += "-1k"
  if "224" in checkpoint_url:
    model_name += "-224"
  elif "384" in checkpoint_url:
    model_name += "-384"
  elif "512" in checkpoint_url:
    model_name += "-512"

  if push_to_hub:
    print(F'''Pushing {model_name} to the hub...''')
    model.push_to_hub(SCREAMING_SNAKE_CASE__)
    preprocessor.push_to_hub(SCREAMING_SNAKE_CASE__)


if __name__ == "__main__":
 __lowercase													=			argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     """--checkpoint_url""",
     default="""https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt""",
     type=str,
     help="""URL of the original ConvNeXTV2 checkpoint you'd like to convert.""",
 )
 parser.add_argument(
     """--pytorch_dump_folder_path""",
     default="""model""",
     type=str,
     help="""Path to the output PyTorch model directory.""",
 )
 parser.add_argument("""--save_model""", action="""store_true""", help="""Save model to local""")
 parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Push model and image preprocessor to the hub""")

 __lowercase													=			parser.parse_args()
 convert_convnextva_checkpoint(
     args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
 )







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


__lowercase													=			logging.get_logger(__name__)

__lowercase													=			{
    """facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json""",
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}

class   __snake_case				(			_a   ):






    '''simple docstring'''
    _lowerCAmelCase     =	"""blenderbot"""
    _lowerCAmelCase     =	["""past_key_values"""]
    _lowerCAmelCase     =	{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





    def __init__(   self						:		Any			,						snake_case						:		Union[str, Any]=8_008			,						snake_case						:		List[str]=128			,						snake_case						:		Tuple=2			,						snake_case						:		int=10_240			,						snake_case						:		Optional[int]=32			,						snake_case						:		Dict=24			,						snake_case						:		List[Any]=10_240			,						snake_case						:		Optional[int]=32			,						snake_case						:		List[str]=0.0			,						snake_case						:		Optional[int]=0.0			,						snake_case						:		Optional[Any]=True			,						snake_case						:		int=True			,						snake_case						:		List[str]="gelu"			,						snake_case						:		Any=2_560			,						snake_case						:		Optional[Any]=0.1			,						snake_case						:		Union[str, Any]=0.0			,						snake_case						:		List[Any]=0.0			,						snake_case						:		Dict=0.02			,						snake_case						:		int=1			,						snake_case						:		Dict=False			,						snake_case						:		List[str]=0			,						snake_case						:		Optional[Any]=1			,						snake_case						:		List[Any]=2			,						snake_case						:		List[str]=3			,						snake_case						:		List[str]=2			,						**snake_case						:		int			,						):

      """simple docstring"""





      __lowerCAmelCase			=				vocab_size
      __lowerCAmelCase			=				max_position_embeddings
      __lowerCAmelCase			=				d_model
      __lowerCAmelCase			=				encoder_ffn_dim
      __lowerCAmelCase			=				encoder_layers
      __lowerCAmelCase			=				encoder_attention_heads
      __lowerCAmelCase			=				decoder_ffn_dim
      __lowerCAmelCase			=				decoder_layers
      __lowerCAmelCase			=				decoder_attention_heads
      __lowerCAmelCase			=				dropout
      __lowerCAmelCase			=				attention_dropout
      __lowerCAmelCase			=				activation_dropout
      __lowerCAmelCase			=				activation_function
      __lowerCAmelCase			=				init_std
      __lowerCAmelCase			=				encoder_layerdrop
      __lowerCAmelCase			=				decoder_layerdrop
      __lowerCAmelCase			=				use_cache
      __lowerCAmelCase			=				encoder_layers
      __lowerCAmelCase			=				scale_embedding  # scale factor will be sqrt(d_model) if True

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


class   __snake_case				(			_a   ):






    '''simple docstring'''





    @property
    def 	A		(   self						:		int							):

      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
        __lowerCAmelCase			=				OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ]							)
        if self.use_past:
          __lowerCAmelCase			=				{0: '''batch'''}
          __lowerCAmelCase			=				{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
        else:
          __lowerCAmelCase			=				{0: '''batch''', 1: '''decoder_sequence'''}
          __lowerCAmelCase			=				{0: '''batch''', 1: '''decoder_sequence'''}
        if self.use_past:
          self.fill_with_past_key_values_(snake_case			,						direction='''inputs'''							)
      elif self.task == "causal-lm":
        __lowerCAmelCase			=				OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ]							)
        if self.use_past:
          __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_layers
          for i in range(snake_case							):
            __lowerCAmelCase			=				{0: '''batch''', 2: '''past_sequence + sequence'''}
            __lowerCAmelCase			=				{0: '''batch''', 2: '''past_sequence + sequence'''}
      else:
        __lowerCAmelCase			=				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
    # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
    def 	A		(   self						:		Optional[Any]							):

      """simple docstring"""





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





    def 	A		(   self						:		int			,						snake_case						:		PreTrainedTokenizer			,						snake_case						:		int = -1			,						snake_case						:		int = -1			,						snake_case						:		bool = False			,						snake_case						:		Optional[TensorType] = None			,						):

      """simple docstring"""





      __lowerCAmelCase			=				self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          snake_case			,						snake_case			,						snake_case			,						snake_case			,						snake_case							)
      # Generate decoder inputs
      __lowerCAmelCase			=				seq_length if not self.use_past else 1
      __lowerCAmelCase			=				self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          snake_case			,						snake_case			,						snake_case			,						snake_case			,						snake_case							)
      __lowerCAmelCase			=				{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
      __lowerCAmelCase			=				dict(**snake_case			,						**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
        __lowerCAmelCase	,						__lowerCAmelCase			=				common_inputs['''input_ids'''].shape
        __lowerCAmelCase			=				common_inputs['''decoder_input_ids'''].shape[1]
        __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_attention_heads
        __lowerCAmelCase			=				(
            batch,
            num_encoder_attention_heads,
            encoder_seq_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )
        __lowerCAmelCase			=				decoder_seq_length
        __lowerCAmelCase			=				(
            batch,
            num_decoder_attention_heads,
            decoder_past_length,
            self._config.hidden_size // num_decoder_attention_heads,
        )
        __lowerCAmelCase			=				torch.cat(
            [common_inputs['''decoder_attention_mask'''], torch.ones(snake_case			,						snake_case							)]			,						dim=1							)
        __lowerCAmelCase			=				[]
        __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_layers

        for _ in range(snake_case							):
          common_inputs["past_key_values"].append(
              (
                  torch.zeros(snake_case							),
                  torch.zeros(snake_case							),
                  torch.zeros(snake_case							),
                  torch.zeros(snake_case							),
              )							)
      return common_inputs





    def 	A		(   self						:		str			,						snake_case						:		PreTrainedTokenizer			,						snake_case						:		int = -1			,						snake_case						:		int = -1			,						snake_case						:		bool = False			,						snake_case						:		Optional[TensorType] = None			,						):

      """simple docstring"""





      __lowerCAmelCase			=				self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          snake_case			,						snake_case			,						snake_case			,						snake_case			,						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
        __lowerCAmelCase	,						__lowerCAmelCase			=				common_inputs['''input_ids'''].shape
        __lowerCAmelCase			=				seqlen
        __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_layers
        __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_attention_heads
        __lowerCAmelCase			=				(
            batch,
            num_encoder_attention_heads,
            past_key_values_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )
        __lowerCAmelCase			=				common_inputs['''attention_mask'''].dtype
        __lowerCAmelCase			=				torch.cat(
            [common_inputs['''attention_mask'''], torch.ones(snake_case			,						snake_case			,						dtype=snake_case							)]			,						dim=1							)
        __lowerCAmelCase			=				[
            (torch.zeros(snake_case							), torch.zeros(snake_case							)) for _ in range(snake_case							)
        ]
      return common_inputs





    def 	A		(   self						:		Optional[int]			,						snake_case						:		PreTrainedTokenizer			,						snake_case						:		int = -1			,						snake_case						:		int = -1			,						snake_case						:		bool = False			,						snake_case						:		Optional[TensorType] = None			,						):

      """simple docstring"""





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

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





    def 	A		(   self						:		str			,						snake_case						:		PreTrainedTokenizer			,						snake_case						:		int = -1			,						snake_case						:		int = -1			,						snake_case						:		bool = False			,						snake_case						:		Optional[TensorType] = None			,						):

      """simple docstring"""





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

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

      return common_inputs





    def 	A		(   self						:		Optional[Any]			,						snake_case						:		int			,						snake_case						:		str			,						snake_case						:		str			,						snake_case						:		List[str]							):

      """simple docstring"""





      if self.task in ["default", "seq2seq-lm"]:
        __lowerCAmelCase			=				super()._flatten_past_key_values_(snake_case			,						snake_case			,						snake_case			,						snake_case							)
      else:
        __lowerCAmelCase			=				super(snake_case			,						self							)._flatten_past_key_values_(
            snake_case			,						snake_case			,						snake_case			,						snake_case							)





    def 	A		(   self						:		List[Any]			,						snake_case						:		Mapping[str, Mapping[int, str]]			,						snake_case						:		str							):

      """simple docstring"""





      if direction not in ["inputs", "outputs"]:
        raise ValueError(f'''direction must either be "inputs" or "outputs", but {direction} was given'''							)

      __lowerCAmelCase			=				'''past_key_values''' if direction == '''inputs''' else '''present'''
      __lowerCAmelCase	,						__lowerCAmelCase			=				self.num_layers

      __lowerCAmelCase			=				'''past_encoder_sequence'''
      __lowerCAmelCase			=				'''past_decoder_sequence''' if direction == '''inputs''' else '''past_decoder_sequence + sequence'''

      for i in range(snake_case							):
        __lowerCAmelCase			=				{0: '''batch''', 2: decoder_sequence}
        __lowerCAmelCase			=				{0: '''batch''', 2: decoder_sequence}
        __lowerCAmelCase			=				{0: '''batch''', 2: encoder_sequence}
        __lowerCAmelCase			=				{0: '''batch''', 2: encoder_sequence}
