






"""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()
lowercase    			=       logging.get_logger(__name__)






def _lowerCAmelCase	(  __lowerCamelCase:List[str]   ):

						'''simple docstring'''






						__magic_name__            =     SwinConfig(
						    embed_dim=1_9_2 ,						depths=(2, 2, 1_8, 2) ,						num_heads=(6, 1_2, 2_4, 4_8) ,						window_size=1_2 ,						out_features=["stage2", "stage3", "stage4"] ,						)

						__magic_name__            =     DetaConfig(
						    backbone_config=__lowerCamelCase ,						num_queries=9_0_0 ,						encoder_ffn_dim=2_0_4_8 ,						decoder_ffn_dim=2_0_4_8 ,						num_feature_levels=5 ,						assign_first_stage=__lowerCamelCase ,						with_box_refine=__lowerCamelCase ,						two_stage=__lowerCamelCase ,						)

						# set labels
						__magic_name__            =     "huggingface/label-files"
						if "o365" in model_name:
												__magic_name__            =     3_6_6
												__magic_name__            =     "object365-id2label.json"
						else:
												__magic_name__            =     9_1
												__magic_name__            =     "coco-detection-id2label.json"

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

						return config






def _lowerCAmelCase	(  __lowerCamelCase:Union[str, Any]   ):

						'''simple docstring'''






						__magic_name__            =     []

						# 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 _lowerCAmelCase	(  __lowerCamelCase:Dict ,						__lowerCamelCase:int ,						__lowerCamelCase:str   ):

						'''simple docstring'''






						__magic_name__            =     dct.pop(__lowerCamelCase   )
						__magic_name__            =     val






def _lowerCAmelCase	(  __lowerCamelCase:Dict ,						__lowerCamelCase:str   ):

						'''simple docstring'''






						__magic_name__            =     [int(backbone_config.embed_dim * 2**i   ) for i in range(len(backbone_config.depths   )   )]
						for i in range(len(backbone_config.depths   )   ):
												__magic_name__            =     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)
																		__magic_name__            =     state_dict.pop(f'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'''   )
																		__magic_name__            =     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
																		__magic_name__            =     in_proj_weight[:dim, :]
																		__magic_name__            =     in_proj_bias[: dim]
																		__magic_name__            =     in_proj_weight[
																		    dim : dim * 2, :
																		]
																		__magic_name__            =     in_proj_bias[
																		    dim : dim * 2
																		]
																		__magic_name__            =     in_proj_weight[
																		    -dim :, :
																		]
																		__magic_name__            =     in_proj_bias[-dim :]
																		# fmt: on






def _lowerCAmelCase	(  __lowerCamelCase:List[Any] ,						__lowerCamelCase:str   ):

						'''simple docstring'''






						__magic_name__            =     config.d_model
						for i in range(config.decoder_layers   ):
												# read in weights + bias of input projection layer of self-attention
												__magic_name__            =     state_dict.pop(f'''transformer.decoder.layers.{i}.self_attn.in_proj_weight'''   )
												__magic_name__            =     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
												__magic_name__            =     in_proj_weight[:hidden_size, :]
												__magic_name__            =     in_proj_bias[:hidden_size]
												__magic_name__            =     in_proj_weight[
												    hidden_size : hidden_size * 2, :
												]
												__magic_name__            =     in_proj_bias[hidden_size : hidden_size * 2]
												__magic_name__            =     in_proj_weight[-hidden_size:, :]
												__magic_name__            =     in_proj_bias[-hidden_size:]






def _lowerCAmelCase	(  ):

						'''simple docstring'''






						__magic_name__            =     "http://images.cocodataset.org/val2017/000000039769.jpg"
						__magic_name__            =     Image.open(requests.get(__lowerCamelCase ,						stream=__lowerCamelCase   ).raw   )

						return im






@torch.no_grad()
def _lowerCAmelCase	(  __lowerCamelCase:List[str] ,						__lowerCamelCase:List[Any] ,						__lowerCamelCase:int   ):

						'''simple docstring'''






						__magic_name__            =     get_deta_config(__lowerCamelCase   )

						# load original state dict
						if model_name == "deta-swin-large":
												__magic_name__            =     hf_hub_download(repo_id="nielsr/deta-checkpoints" ,						filename="adet_swin_ft.pth"   )
						elif model_name == "deta-swin-large-o365":
												__magic_name__            =     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'''   )

						__magic_name__            =     torch.load(__lowerCamelCase ,						map_location="cpu"   )["model"]

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

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

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

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

						__magic_name__            =     "cuda" if torch.cuda.is_available() else "cpu"
						model.to(__lowerCamelCase   )

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

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

						# verify logits
						print("Logits:" ,						outputs.logits[0, :3, :3]   )
						print("Boxes:" ,						outputs.pred_boxes[0, :3, :3]   )
						if model_name == "deta-swin-large":
												__magic_name__            =     torch.tensor(
												    [[-7.6_3_0_8, -2.8_4_8_5, -5.3_7_3_7], [-7.2_0_3_7, -4.5_5_0_5, -4.8_0_2_7], [-7.2_9_4_3, -4.2_6_1_1, -4.6_6_1_7]]   )
												__magic_name__            =     torch.tensor([[0.4_9_8_7, 0.4_9_6_9, 0.9_9_9_9], [0.2_5_4_9, 0.5_4_9_8, 0.4_8_0_5], [0.5_4_9_8, 0.2_7_5_7, 0.0_5_6_9]]   )
						elif model_name == "deta-swin-large-o365":
												__magic_name__            =     torch.tensor(
												    [[-8.0_1_2_2, -3.5_7_2_0, -4.9_7_1_7], [-8.1_5_4_7, -3.6_8_8_6, -4.6_3_8_9], [-7.6_6_1_0, -3.6_1_9_4, -5.0_1_3_4]]   )
												__magic_name__            =     torch.tensor([[0.2_5_2_3, 0.5_5_4_9, 0.4_8_8_1], [0.7_7_1_5, 0.4_1_4_9, 0.4_6_0_1], [0.5_5_0_3, 0.2_7_5_3, 0.0_5_7_5]]   )
						assert torch.allclose(outputs.logits[0, :3, :3] ,						expected_logits.to(__lowerCamelCase   ) ,						atol=1E-4   )
						assert torch.allclose(outputs.pred_boxes[0, :3, :3] ,						expected_boxes.to(__lowerCamelCase   ) ,						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(__lowerCamelCase   ).mkdir(exist_ok=__lowerCamelCase   )
												model.save_pretrained(__lowerCamelCase   )
												processor.save_pretrained(__lowerCamelCase   )

						# 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__":
			lowercase    			=       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.'''
			)
			lowercase    			=       parser.parse_args()
			convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











"""simple docstring"""

def _lowerCAmelCase	(  __lowerCamelCase:list ,						__lowerCamelCase:list   ):

						'''simple docstring'''






						_validate_point(__lowerCamelCase   )
						_validate_point(__lowerCamelCase   )
						if len(__lowerCamelCase   ) != len(__lowerCamelCase   ):
												raise ValueError("Both points must be in the same n-dimensional space"   )

						return float(sum(abs(a - b   ) for a, b in zip(__lowerCamelCase ,						__lowerCamelCase   )   )   )






def _lowerCAmelCase	(  __lowerCamelCase:list[float]   ):

						'''simple docstring'''






						if point:
												if isinstance(__lowerCamelCase ,						__lowerCamelCase   ):
																		for item in point:
																								if not isinstance(__lowerCamelCase ,						(int, float)   ):
																														__magic_name__            =     (
																														    "Expected a list of numbers as input, found "
																														    f'''{type(__lowerCamelCase   ).__name__}'''
																														)
																														raise TypeError(__lowerCamelCase   )
												else:
																		__magic_name__            =     f'''Expected a list of numbers as input, found {type(__lowerCamelCase   ).__name__}'''
																		raise TypeError(__lowerCamelCase   )
						else:
												raise ValueError("Missing an input"   )






def _lowerCAmelCase	(  __lowerCamelCase:list ,						__lowerCamelCase:list   ):

						'''simple docstring'''






						_validate_point(__lowerCamelCase   )
						_validate_point(__lowerCamelCase   )
						if len(__lowerCamelCase   ) != len(__lowerCamelCase   ):
												raise ValueError("Both points must be in the same n-dimensional space"   )

						return float(sum(abs(x - y   ) for x, y in zip(__lowerCamelCase ,						__lowerCamelCase   )   )   )


if __name__ == "__main__":
			import doctest

			doctest.testmod()



