





'''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
from transformers.utils import logging


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




def  __a			(  )   ->List[str]:



	"""simple docstring"""







	A					=   DetaConfig(
	    num_queries=900							,      encoder_ffn_dim=2048							,      decoder_ffn_dim=2048							,      num_feature_levels=5							,      assign_first_stage=UpperCAmelCase							,      with_box_refine=UpperCAmelCase							,      two_stage=UpperCAmelCase							,      )

	# set labels
	A					=   91
	A					=   """huggingface/label-files"""
	A					=   """coco-detection-id2label.json"""
	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     )   ->Optional[int]:



	"""simple docstring"""







	A					=   []

	# 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  __a			(  UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase     )   ->Optional[int]:



	"""simple docstring"""







	A					=   dct.pop(UpperCAmelCase     )
	A					=   val




def  __a			(  UpperCAmelCase							,      UpperCAmelCase     )   ->int:



	"""simple docstring"""







	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			(  )   ->Union[str, Any]:



	"""simple docstring"""







	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     )   ->Optional[Any]:



	"""simple docstring"""







	A					=   get_deta_config()

	# load original state dict
	if model_name == "deta-resnet-50":
		A					=   """adet_checkpoint0011.pth"""
	elif model_name == "deta-resnet-50-24-epochs":
		A					=   """adet_2x_checkpoint0023.pth"""
	else:
		raise ValueError(f"""Model name {model_name} not supported"""     )
	A					=   hf_hub_download(repo_id="""nielsr/deta-checkpoints"""							,      filename=UpperCAmelCase     )
	A					=   torch.load(UpperCAmelCase							,      map_location="""cpu"""     )["""model"""]

	# rename keys
	A					=   create_rename_keys(UpperCAmelCase     )
	for src, dest in rename_keys:
		rename_key(UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase     )
	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
	if model_name == "deta-resnet-50":
		A					=   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					=   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					=   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					=   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(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__":
				_lowerCamelCase					:						Union[str, 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.'
				)
				_lowerCamelCase					:						List[Any]					     =							parser.parse_args()
				convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








'''simple docstring'''


from math import pi




def  __a			(  UpperCAmelCase     )   ->float:



	"""simple docstring"""







	return degree / (180 / pi)


if __name__ == "__main__":
				from doctest import testmod

				testmod()

