code: 
  
  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
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  UpperCAmelCase_       :				Tuple		   =      logging.get_logger(__name__)
  def        __SCREAMING_SNAKE_CASE    (      )				->							Union[str, Any]:
  	__A   : Dict								= DetaConfig(
  	    num_queries=900 ,encoder_ffn_dim=2048 ,decoder_ffn_dim=2048 ,num_feature_levels=5 ,assign_first_stage=a__ ,with_box_refine=a__ ,two_stage=a__ ,)
  
  	# set labels
  	__A   : Dict								= 91
  	__A   : Union[str, Any]								= """huggingface/label-files"""
  	__A   : Any								= """coco-detection-id2label.json"""
  	__A   : Dict								= json.load(open(cached_download(hf_hub_url(a__ ,a__ ,repo_type="""dataset"""					)					) ,"""r"""					)					)
  	__A   : str								= {int(a__					): v for k, v in idalabel.items()}
  	__A   : Optional[int]								= idalabel
  	__A   : Union[str, Any]								= {v: k for k, v in idalabel.items()}
  
  	return config
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Dict					)				->							Dict:
  	__A   : str								= []
  
  	# stem
  	# fmt: off
  	rename_keys.append(("""backbone.0.body.conv1.weight""", """model.backbone.model.embedder.embedder.convolution.weight""")					)
  	rename_keys.append(("""backbone.0.body.bn1.weight""", """model.backbone.model.embedder.embedder.normalization.weight""")					)
  	rename_keys.append(("""backbone.0.body.bn1.bias""", """model.backbone.model.embedder.embedder.normalization.bias""")					)
  	rename_keys.append(("""backbone.0.body.bn1.running_mean""", """model.backbone.model.embedder.embedder.normalization.running_mean""")					)
  	rename_keys.append(("""backbone.0.body.bn1.running_var""", """model.backbone.model.embedder.embedder.normalization.running_var""")					)
  	# stages
  	for stage_idx in range(len(config.backbone_config.depths					)					):
  		for layer_idx in range(config.backbone_config.depths[stage_idx]					):
  			# shortcut
  			if layer_idx == 0:
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var""",
  				    )					)
  			# 3 convs
  			for i in range(3					):
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean""",
  				    )					)
  				rename_keys.append(
  				    (
  				        f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var""",
  				        f"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""",
  				    )					)
      # 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        __SCREAMING_SNAKE_CASE    (      a__						:      Optional[Any] ,a__						:      Optional[Any] ,a__						:      Any					)				->							List[str]:
  	__A   : Tuple								= dct.pop(a__					)
  	__A   : List[Any]								= val
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Optional[Any] ,a__						:      List[Any]					)				->							str:
  	# transformer decoder self-attention layers
  	__A   : Dict								= config.d_model
  	for i in range(config.decoder_layers					):
  		# read in weights + bias of input projection layer of self-attention
  		__A   : Optional[Any]								= state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""					)
  		__A   : str								= 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   : Optional[int]								= in_proj_weight[:hidden_size, :]
  		__A   : Optional[int]								= in_proj_bias[:hidden_size]
  		__A   : List[str]								= in_proj_weight[
  		    hidden_size : hidden_size * 2, :
  		]
  		__A   : List[Any]								= in_proj_bias[hidden_size : hidden_size * 2]
  		__A   : str								= in_proj_weight[-hidden_size:, :]
  		__A   : Union[str, Any]								= in_proj_bias[-hidden_size:]
  def        __SCREAMING_SNAKE_CASE    (      )				->							List[str]:
  	__A   : Union[str, Any]								= """http://images.cocodataset.org/val2017/000000039769.jpg"""
  	__A   : Optional[Any]								= Image.open(requests.get(a__ ,stream=a__					).raw					)
  
  	return im
  @torch.no_grad()
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      Optional[int] ,a__						:      List[str]					)				->							Dict:
  	__A   : int								= get_deta_config()
  
  	# load original state dict
  	if model_name == "deta-resnet-50":
  		__A   : Optional[Any]								= """adet_checkpoint0011.pth"""
  	elif model_name == "deta-resnet-50-24-epochs":
  		__A   : Union[str, Any]								= """adet_2x_checkpoint0023.pth"""
  	else:
  		raise ValueError(f"""Model name {model_name} not supported"""					)
  	__A   : Optional[int]								= hf_hub_download(repo_id="""nielsr/deta-checkpoints""" ,filename=a__					)
  	__A   : Any								= torch.load(a__ ,map_location="""cpu"""					)["""model"""]
  
  	# rename keys
  	__A   : str								= create_rename_keys(a__					)
  	for src, dest in rename_keys:
  		rename_key(a__ ,a__ ,a__					)
  	read_in_decoder_q_k_v(a__ ,a__					)
  
  	# 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   : Optional[Any]								= state_dict.pop(a__					)
  			__A   : Tuple								= val
  		if "input_proj" in key:
  			__A   : Optional[int]								= state_dict.pop(a__					)
  			__A   : Any								= val
  		if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
  			__A   : str								= state_dict.pop(a__					)
  			__A   : Any								= val
  
      # finally, create HuggingFace model and load state dict
  	__A   : Any								= DetaForObjectDetection(a__					)
  	model.load_state_dict(a__					)
  	model.eval()
  
  	__A   : int								= """cuda""" if torch.cuda.is_available() else """cpu"""
  	model.to(a__					)
  
  	# load image processor
  	__A   : int								= DetaImageProcessor(format="""coco_detection"""					)
  
  	# verify our conversion on image
  	__A   : Tuple								= prepare_img()
  	__A   : Any								= processor(images=a__ ,return_tensors="""pt"""					)
  	__A   : Any								= encoding["""pixel_values"""]
  	__A   : Optional[Any]								= model(pixel_values.to(a__					)					)
  
  	# verify logits
  	if model_name == "deta-resnet-50":
  		__A   : Dict								= torch.tensor(
  		    [[-7.3_978, -2.5_406, -4.1_668], [-8.2_684, -3.9_933, -3.8_096], [-7.0_515, -3.7_973, -5.8_516]]					)
  		__A   : Optional[int]								= torch.tensor([[0.5_043, 0.4_973, 0.9_998], [0.2_542, 0.5_489, 0.4_748], [0.5_490, 0.2_765, 0.0_570]]					)
  	elif model_name == "deta-resnet-50-24-epochs":
  		__A   : Tuple								= torch.tensor(
  		    [[-7.1_688, -2.4_857, -4.8_669], [-7.8_630, -3.8_154, -4.2_674], [-7.2_730, -4.1_865, -5.5_323]]					)
  		__A   : Union[str, Any]								= torch.tensor([[0.5_021, 0.4_971, 0.9_994], [0.2_546, 0.5_486, 0.4_731], [0.1_686, 0.1_986, 0.2_142]]					)
  
  	assert torch.allclose(outputs.logits[0, :3, :3] ,expected_logits.to(a__					) ,atol=1E-4					)
  	assert torch.allclose(outputs.pred_boxes[0, :3, :3] ,expected_boxes.to(a__					) ,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(a__					).mkdir(exist_ok=a__					)
  		model.save_pretrained(a__					)
  		processor.save_pretrained(a__					)
  
  	# 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__":
  			UpperCAmelCase_       :				Any		   =      argparse.ArgumentParser()
  
  			parser.add_argument(
  			    '''--model_name''',
  			    type=str,
  			    default='''deta-resnet-50''',
  			    choices=['''deta-resnet-50''', '''deta-resnet-50-24-epochs'''],
  			    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.'''
  			)
  			UpperCAmelCase_       :				Any		   =      parser.parse_args()
  			convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
  
  
  
  
  
  
style_context: 
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfigWithPast
  from ...utils import logging
  
  
  UpperCAmelCase_       :				int		   =      logging.get_logger(__name__)
  
  UpperCAmelCase_       :				Any		   =      {
      '''uclanlp/plbart-base''': '''https://huggingface.co/uclanlp/plbart-base/resolve/main/config.json''',
      # See all PLBART models at https://huggingface.co/models?filter=plbart
  }
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  	_lowercase		:      str    				=							'''plbart'''
  	_lowercase		:      str    				=							['''past_key_values''']
  	_lowercase		:      Any    				=							{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
  
  
  
  
  	def __init__(    self	:    List[Any]				,			__A	:    str=5_0005				,			__A	:    Union[str, Any]=1024				,			__A	:    int=6				,			__A	:    Dict=3072				,			__A	:    Union[str, Any]=12				,			__A	:    Tuple=6				,			__A	:    Tuple=3072				,			__A	:    Optional[int]=12				,			__A	:    int=0.0				,			__A	:    List[Any]=0.0				,			__A	:    Union[str, Any]=True				,			__A	:    Any=True				,			__A	:    Optional[int]="gelu"				,			__A	:    Optional[int]=768				,			__A	:    Any=0.1				,			__A	:    Union[str, Any]=0.1				,			__A	:    Union[str, Any]=0.0				,			__A	:    int=0.0_2				,			__A	:    Union[str, Any]=0.0				,			__A	:    Tuple=True				,			__A	:    List[str]=1				,			__A	:    str=0				,			__A	:    List[Any]=2				,			__A	:    Any=2				,			**__A	:    Union[str, Any]				,			):
  		__A   : List[Any]								= vocab_size
  		__A   : str								= max_position_embeddings
  		__A   : Union[str, Any]								= d_model
  		__A   : List[str]								= encoder_ffn_dim
  		__A   : Optional[Any]								= encoder_layers
  		__A   : Tuple								= encoder_attention_heads
  		__A   : List[Any]								= decoder_ffn_dim
  		__A   : Optional[int]								= decoder_layers
  		__A   : Any								= decoder_attention_heads
  		__A   : Optional[int]								= dropout
  		__A   : Any								= attention_dropout
  		__A   : Tuple								= activation_dropout
  		__A   : List[Any]								= activation_function
  		__A   : Tuple								= init_std
  		__A   : List[Any]								= encoder_layerdrop
  		__A   : str								= decoder_layerdrop
  		__A   : Union[str, Any]								= classifier_dropout
  		__A   : Optional[Any]								= use_cache
  		__A   : List[str]								= encoder_layers
  		__A   : Optional[int]								= scale_embedding  # scale factor will be sqrt(d_model) if True
  		super().__init__(
  		    pad_token_id=__A				,			bos_token_id=__A				,			eos_token_id=__A				,			is_encoder_decoder=__A				,			forced_eos_token_id=__A				,			**__A				,			)
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		return OrderedDict(
  		    [
  		        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
  		        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
  		    ]       )
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		if self.use_past:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""past_keys""", {0: """batch""", 2: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  		else:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  
  
  
  
  
  