





"""simple docstring"""
import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case     :		List[str]       						= logging.get_logger(__name__)






def 					A__				(			UpperCamelCase       ):
							A		=  SwinConfig(
							    embed_dim=192					,  depths=(2, 2, 18, 2)					,  num_heads=(6, 12, 24, 48)					,  window_size=12					,  out_features=["stage2", "stage3", "stage4"]					,  )

							A		=  DetaConfig(
							    backbone_config=UpperCamelCase					,  num_queries=900					,  encoder_ffn_dim=2_048					,  decoder_ffn_dim=2_048					,  num_feature_levels=5					,  assign_first_stage=UpperCamelCase					,  with_box_refine=UpperCamelCase					,  two_stage=UpperCamelCase					,  )

							# set labels
							A		=  "huggingface/label-files"
							if "o365" in model_name:
														A		=  366
														A		=  "object365-id2label.json"
							else:
														A		=  91
														A		=  "coco-detection-id2label.json"

							A		=  num_labels
							A		=  json.load(open(cached_download(hf_hub_url(UpperCamelCase					,  UpperCamelCase					,  repo_type="dataset"       )       )					,  "r"       )       )
							A		=  {int(UpperCamelCase       ): v for k, v in idalabel.items()}
							A		=  idalabel
							A		=  {v: k for k, v in idalabel.items()}

							return config






def 					A__				(			UpperCamelCase       ):
							A		=  []

							# stem
							# fmt: off
							rename_keys.append(("backbone.0.body.patch_embed.proj.weight", "model.backbone.model.embeddings.patch_embeddings.projection.weight")       )
							rename_keys.append(("backbone.0.body.patch_embed.proj.bias", "model.backbone.model.embeddings.patch_embeddings.projection.bias")       )
							rename_keys.append(("backbone.0.body.patch_embed.norm.weight", "model.backbone.model.embeddings.norm.weight")       )
							rename_keys.append(("backbone.0.body.patch_embed.norm.bias", "model.backbone.model.embeddings.norm.bias")       )
							# stages
							for i in range(len(config.backbone_config.depths       )       ):
														for j in range(config.backbone_config.depths[i]       ):
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.norm1.weight", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.norm1.bias", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.norm2.weight", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.norm2.bias", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias", F"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias")       )

														if i < 3:
																					rename_keys.append((F"backbone.0.body.layers.{i}.downsample.reduction.weight", F"model.backbone.model.encoder.layers.{i}.downsample.reduction.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.downsample.norm.weight", F"model.backbone.model.encoder.layers.{i}.downsample.norm.weight")       )
																					rename_keys.append((F"backbone.0.body.layers.{i}.downsample.norm.bias", F"model.backbone.model.encoder.layers.{i}.downsample.norm.bias")       )

							rename_keys.append(("backbone.0.body.norm1.weight", "model.backbone.model.hidden_states_norms.stage2.weight")       )
							rename_keys.append(("backbone.0.body.norm1.bias", "model.backbone.model.hidden_states_norms.stage2.bias")       )
							rename_keys.append(("backbone.0.body.norm2.weight", "model.backbone.model.hidden_states_norms.stage3.weight")       )
							rename_keys.append(("backbone.0.body.norm2.bias", "model.backbone.model.hidden_states_norms.stage3.bias")       )
							rename_keys.append(("backbone.0.body.norm3.weight", "model.backbone.model.hidden_states_norms.stage4.weight")       )
							rename_keys.append(("backbone.0.body.norm3.bias", "model.backbone.model.hidden_states_norms.stage4.bias")       )

							# transformer encoder
							for i in range(config.encoder_layers       ):
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", F"model.encoder.layers.{i}.self_attn.sampling_offsets.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", F"model.encoder.layers.{i}.self_attn.sampling_offsets.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", F"model.encoder.layers.{i}.self_attn.attention_weights.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", F"model.encoder.layers.{i}.self_attn.attention_weights.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.weight", F"model.encoder.layers.{i}.self_attn.value_proj.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.bias", F"model.encoder.layers.{i}.self_attn.value_proj.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.weight", F"model.encoder.layers.{i}.self_attn.output_proj.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.bias", F"model.encoder.layers.{i}.self_attn.output_proj.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.norm1.weight", F"model.encoder.layers.{i}.self_attn_layer_norm.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.norm1.bias", F"model.encoder.layers.{i}.self_attn_layer_norm.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.linear1.weight", F"model.encoder.layers.{i}.fc1.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.linear1.bias", F"model.encoder.layers.{i}.fc1.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.linear2.weight", F"model.encoder.layers.{i}.fc2.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.linear2.bias", F"model.encoder.layers.{i}.fc2.bias")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.norm2.weight", F"model.encoder.layers.{i}.final_layer_norm.weight")       )
														rename_keys.append((F"transformer.encoder.layers.{i}.norm2.bias", F"model.encoder.layers.{i}.final_layer_norm.bias")       )

							# transformer decoder
							for i in range(config.decoder_layers       ):
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", F"model.decoder.layers.{i}.encoder_attn.attention_weights.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", F"model.decoder.layers.{i}.encoder_attn.attention_weights.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", F"model.decoder.layers.{i}.encoder_attn.value_proj.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", F"model.decoder.layers.{i}.encoder_attn.value_proj.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", F"model.decoder.layers.{i}.encoder_attn.output_proj.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", F"model.decoder.layers.{i}.encoder_attn.output_proj.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm1.weight", F"model.decoder.layers.{i}.encoder_attn_layer_norm.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm1.bias", F"model.decoder.layers.{i}.encoder_attn_layer_norm.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.weight", F"model.decoder.layers.{i}.self_attn.out_proj.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.bias", F"model.decoder.layers.{i}.self_attn.out_proj.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm2.weight", F"model.decoder.layers.{i}.self_attn_layer_norm.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm2.bias", F"model.decoder.layers.{i}.self_attn_layer_norm.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.linear1.weight", F"model.decoder.layers.{i}.fc1.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.linear1.bias", F"model.decoder.layers.{i}.fc1.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.linear2.weight", F"model.decoder.layers.{i}.fc2.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.linear2.bias", F"model.decoder.layers.{i}.fc2.bias")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm3.weight", F"model.decoder.layers.{i}.final_layer_norm.weight")       )
														rename_keys.append((F"transformer.decoder.layers.{i}.norm3.bias", F"model.decoder.layers.{i}.final_layer_norm.bias")       )

							# fmt: on

							return rename_keys






def 					A__				(			UpperCamelCase					,  UpperCamelCase					,  UpperCamelCase       ):
							A		=  dct.pop(UpperCamelCase       )
							A		=  val






def 					A__				(			UpperCamelCase					,  UpperCamelCase       ):
							A		=  [int(backbone_config.embed_dim * 2**i       ) for i in range(len(backbone_config.depths       )       )]
							for i in range(len(backbone_config.depths       )       ):
														A		=  num_features[i]
														for j in range(backbone_config.depths[i]       ):
																					# fmt: off
																					# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
																					A		=  state_dict.pop(F"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"       )
																					A		=  state_dict.pop(F"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"       )
																					# next, add query, keys and values (in that order) to the state dict
																					A		=  in_proj_weight[:dim, :]
																					A		=  in_proj_bias[: dim]
																					A		=  in_proj_weight[
																					    dim : dim * 2, :
																					]
																					A		=  in_proj_bias[
																					    dim : dim * 2
																					]
																					A		=  in_proj_weight[
																					    -dim :, :
																					]
																					A		=  in_proj_bias[-dim :]
																					# fmt: on






def 					A__				(			UpperCamelCase					,  UpperCamelCase       ):
							# transformer decoder self-attention layers
							A		=  config.d_model
							for i in range(config.decoder_layers       ):
														# read in weights + bias of input projection layer of self-attention
														A		=  state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_weight"       )
														A		=  state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_bias"       )
														# next, add query, keys and values (in that order) to the state dict
														A		=  in_proj_weight[:hidden_size, :]
														A		=  in_proj_bias[:hidden_size]
														A		=  in_proj_weight[
														    hidden_size : hidden_size * 2, :
														]
														A		=  in_proj_bias[hidden_size : hidden_size * 2]
														A		=  in_proj_weight[-hidden_size:, :]
														A		=  in_proj_bias[-hidden_size:]






def 					A__				(			):
							A		=  "http://images.cocodataset.org/val2017/000000039769.jpg"
							A		=  Image.open(requests.get(UpperCamelCase					,  stream=UpperCamelCase       ).raw       )

							return im






@torch.no_grad()
def 					A__				(			UpperCamelCase					,  UpperCamelCase					,  UpperCamelCase       ):
							A		=  get_deta_config(UpperCamelCase       )

							# load original state dict
							if model_name == "deta-swin-large":
														A		=  hf_hub_download(repo_id="nielsr/deta-checkpoints"					,  filename="adet_swin_ft.pth"       )
							elif model_name == "deta-swin-large-o365":
														A		=  hf_hub_download(repo_id="jozhang97/deta-swin-l-o365"					,  filename="deta_swin_pt_o365.pth"       )
							else:
														raise ValueError(F"Model name {model_name} not supported"       )

							A		=  torch.load(UpperCamelCase					,  map_location="cpu"       )["model"]

							# original state dict
							for name, param in state_dict.items():
														print(UpperCamelCase					,  param.shape       )

							# rename keys
							A		=  create_rename_keys(UpperCamelCase       )
							for src, dest in rename_keys:
														rename_key(UpperCamelCase					,  UpperCamelCase					,  UpperCamelCase       )
							read_in_swin_q_k_v(UpperCamelCase					,  config.backbone_config       )
							read_in_decoder_q_k_v(UpperCamelCase					,  UpperCamelCase       )

							# fix some prefixes
							for key in state_dict.copy().keys():
														if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
																					A		=  state_dict.pop(UpperCamelCase       )
																					A		=  val
														if "input_proj" in key:
																					A		=  state_dict.pop(UpperCamelCase       )
																					A		=  val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					A		=  state_dict.pop(UpperCamelCase       )
																					A		=  val

    # finally, create HuggingFace model and load state dict
							A		=  DetaForObjectDetection(UpperCamelCase       )
							model.load_state_dict(UpperCamelCase       )
							model.eval()

							A		=  "cuda" if torch.cuda.is_available() else "cpu"
							model.to(UpperCamelCase       )

							# load image processor
							A		=  DetaImageProcessor(format="coco_detection"       )

							# verify our conversion on image
							A		=  prepare_img()
							A		=  processor(images=UpperCamelCase					,  return_tensors="pt"       )
							A		=  encoding["pixel_values"]
							A		=  model(pixel_values.to(UpperCamelCase       )       )

							# verify logits
							print("Logits:"					,  outputs.logits[0, :3, :3]       )
							print("Boxes:"					,  outputs.pred_boxes[0, :3, :3]       )
							if model_name == "deta-swin-large":
														A		=  torch.tensor(
														    [[-7.63_08, -2.84_85, -5.37_37], [-7.20_37, -4.55_05, -4.80_27], [-7.29_43, -4.26_11, -4.66_17]]       )
														A		=  torch.tensor([[0.49_87, 0.49_69, 0.99_99], [0.25_49, 0.54_98, 0.48_05], [0.54_98, 0.27_57, 0.05_69]]       )
							elif model_name == "deta-swin-large-o365":
														A		=  torch.tensor(
														    [[-8.01_22, -3.57_20, -4.97_17], [-8.15_47, -3.68_86, -4.63_89], [-7.66_10, -3.61_94, -5.01_34]]       )
														A		=  torch.tensor([[0.25_23, 0.55_49, 0.48_81], [0.77_15, 0.41_49, 0.46_01], [0.55_03, 0.27_53, 0.05_75]]       )
							assert torch.allclose(outputs.logits[0, :3, :3]					,  expected_logits.to(UpperCamelCase       )					,  atol=1E-4       )
							assert torch.allclose(outputs.pred_boxes[0, :3, :3]					,  expected_boxes.to(UpperCamelCase       )					,  atol=1E-4       )
							print("Everything ok!"       )

							if pytorch_dump_folder_path:
														# Save model and processor
														logger.info(F"Saving PyTorch model and processor to {pytorch_dump_folder_path}..."       )
														Path(UpperCamelCase       ).mkdir(exist_ok=UpperCamelCase       )
														model.save_pretrained(UpperCamelCase       )
														processor.save_pretrained(UpperCamelCase       )

							# Push to hub
							if push_to_hub:
														print("Pushing model and processor to hub..."       )
														model.push_to_hub(F"jozhang97/{model_name}"       )
														processor.push_to_hub(F"jozhang97/{model_name}"       )


if __name__ == "__main__":
		_snake_case     :		str       						= argparse.ArgumentParser()

		parser.add_argument(
		    '--model_name',
		    type=str,
		    default='deta-swin-large',
		    choices=['deta-swin-large', 'deta-swin-large-o365'],
		    help='Name of the model you\'d like to convert.',
		)
		parser.add_argument(
		    '--pytorch_dump_folder_path',
		    default=None,
		    type=str,
		    help='Path to the folder to output PyTorch model.',
		)
		parser.add_argument(
		    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
		)
		_snake_case     :		Tuple       						= parser.parse_args()
		convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









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


_snake_case     :		List[Any]       						= logging.get_logger(__name__)

_snake_case     :		int       						= {
    'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json',
    # See all Marian models at https://huggingface.co/models?filter=marian
}






class 					_UpperCAmelCase   (	lowercase_ ):
					UpperCamelCase      =							'''marian'''
					UpperCamelCase      =							['''past_key_values''']
					UpperCamelCase      =							{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


					def __init__(					self			:int     ,       __UpperCamelCase			:Any=5_81_01     ,       __UpperCamelCase			:int=None     ,       __UpperCamelCase			:Union[str, Any]=10_24     ,       __UpperCamelCase			:Union[str, Any]=12     ,       __UpperCamelCase			:str=40_96     ,       __UpperCamelCase			:int=16     ,       __UpperCamelCase			:int=12     ,       __UpperCamelCase			:Optional[Any]=40_96     ,       __UpperCamelCase			:Optional[Any]=16     ,       __UpperCamelCase			:Dict=0.0     ,       __UpperCamelCase			:Dict=0.0     ,       __UpperCamelCase			:str=True     ,       __UpperCamelCase			:Optional[int]=True     ,       __UpperCamelCase			:Any="gelu"     ,       __UpperCamelCase			:Any=10_24     ,       __UpperCamelCase			:List[Any]=0.1     ,       __UpperCamelCase			:Optional[Any]=0.0     ,       __UpperCamelCase			:Union[str, Any]=0.0     ,       __UpperCamelCase			:Tuple=0.02     ,       __UpperCamelCase			:List[str]=5_81_00     ,       __UpperCamelCase			:str=False     ,       __UpperCamelCase			:Optional[int]=5_81_00     ,       __UpperCamelCase			:List[Any]=0     ,       __UpperCamelCase			:List[str]=0     ,       __UpperCamelCase			:Dict=True     ,       **__UpperCamelCase			:Tuple     ,       ):
												A		=  vocab_size
												A		=  decoder_vocab_size or 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		=  use_cache
												A		=  encoder_layers
												A		=  scale_embedding  # scale factor will be sqrt(d_model) if True
												A		=  share_encoder_decoder_embeddings
												super().__init__(
												    pad_token_id=__UpperCamelCase     ,       eos_token_id=__UpperCamelCase     ,       is_encoder_decoder=__UpperCamelCase     ,       decoder_start_token_id=__UpperCamelCase     ,       forced_eos_token_id=__UpperCamelCase     ,       **__UpperCamelCase     ,       )







class 					_UpperCAmelCase   (	lowercase_ ):


					@property
					# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
					def 	lowerCamelCase       (					self			:List[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_(__UpperCamelCase     ,       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(__UpperCamelCase		):
																																	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
					# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
					def 	lowerCamelCase       (					self			:List[str]		):
												if self.task in ["default", "seq2seq-lm"]:
																			A		=  super().outputs
												else:
																			A		=  super(__UpperCamelCase     ,       self		).outputs
																			if self.use_past:
																										A,	A		=  self.num_layers
																										for i in range(__UpperCamelCase		):
																																	A		=  {0: "batch", 2: "past_sequence + sequence"}
																																	A		=  {0: "batch", 2: "past_sequence + sequence"}
												return common_outputs


					def 	lowerCamelCase       (					self			:Optional[int]     ,       __UpperCamelCase			:PreTrainedTokenizer     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:bool = False     ,       __UpperCamelCase			:Optional[TensorType] = None     ,       ):
												A		=  self._generate_dummy_inputs_for_encoder_and_decoder(
												    __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase		)

												# Generate decoder inputs
												A		=  seq_length if not self.use_past else 1
												A		=  self._generate_dummy_inputs_for_encoder_and_decoder(
												    __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase		)
												A		=  {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
												A		=  dict(**__UpperCamelCase     ,       **__UpperCamelCase		)

												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(__UpperCamelCase     ,       __UpperCamelCase		)]     ,       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(__UpperCamelCase     ,       __UpperCamelCase		)
																			A		=  max(__UpperCamelCase     ,       __UpperCamelCase		) - min_num_layers
																			A		=  "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

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


					def 	lowerCamelCase       (					self			:Optional[int]     ,       __UpperCamelCase			:PreTrainedTokenizer     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:bool = False     ,       __UpperCamelCase			:Optional[TensorType] = None     ,       ):
												A		=  self._generate_dummy_inputs_for_encoder_and_decoder(
												    __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase		)

												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(__UpperCamelCase     ,       __UpperCamelCase     ,       dtype=__UpperCamelCase		)]     ,       dim=1		)
																			A		=  [
																			    (torch.zeros(__UpperCamelCase		), torch.zeros(__UpperCamelCase		)) for _ in range(__UpperCamelCase		)
																			]
												return common_inputs


					def 	lowerCamelCase       (					self			:Tuple     ,       __UpperCamelCase			:PreTrainedTokenizer     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:bool = False     ,       __UpperCamelCase			:Optional[TensorType] = 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		=  compute_effective_axis_dimension(
												    __UpperCamelCase     ,       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(__UpperCamelCase		)
												A		=  compute_effective_axis_dimension(
												    __UpperCamelCase     ,       fixed_dimension=OnnxConfig.default_fixed_sequence     ,       num_token_to_add=__UpperCamelCase		)

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


					def 	lowerCamelCase       (					self			:List[Any]     ,       __UpperCamelCase			:PreTrainedTokenizer     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:int = -1     ,       __UpperCamelCase			:bool = False     ,       __UpperCamelCase			:Optional[TensorType] = None     ,       ):
												if self.task in ["default", "seq2seq-lm"]:
																			A		=  self._generate_dummy_inputs_for_default_and_seqaseq_lm(
																			    __UpperCamelCase     ,       batch_size=__UpperCamelCase     ,       seq_length=__UpperCamelCase     ,       is_pair=__UpperCamelCase     ,       framework=__UpperCamelCase		)

												else:
																			A		=  self._generate_dummy_inputs_for_causal_lm(
																			    __UpperCamelCase     ,       batch_size=__UpperCamelCase     ,       seq_length=__UpperCamelCase     ,       is_pair=__UpperCamelCase     ,       framework=__UpperCamelCase		)

												return common_inputs


					def 	lowerCamelCase       (					self			:List[Any]     ,       __UpperCamelCase			:Tuple     ,       __UpperCamelCase			:List[str]     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:str		):
												if self.task in ["default", "seq2seq-lm"]:
																			A		=  super()._flatten_past_key_values_(__UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase		)
												else:
																			A		=  super(__UpperCamelCase     ,       self		)._flatten_past_key_values_(
																			    __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase     ,       __UpperCamelCase		)


					@property
					def 	lowerCamelCase       (					self			:List[str]		):
												return 1e-4


