






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 						__UpperCAmelCase			(     a_):
							snake_case_				=							SwinConfig(
							    embed_dim=1_92							,     depths=(2, 2, 18, 2)							,     num_heads=(6, 12, 24, 48)							,     window_size=12							,     out_features=['stage2', 'stage3', 'stage4']							,     )

							snake_case_				=							DetaConfig(
							    backbone_config=a_							,     num_queries=9_00							,     encoder_ffn_dim=20_48							,     decoder_ffn_dim=20_48							,     num_feature_levels=5							,     assign_first_stage=a_							,     with_box_refine=a_							,     two_stage=a_							,     )

							# set labels
							snake_case_				=							'huggingface/label-files'
							if "o365" in model_name:
														snake_case_				=							3_66
														snake_case_				=							'object365-id2label.json'
							else:
														snake_case_				=							91
														snake_case_				=							'coco-detection-id2label.json'

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

							return config





def 						__UpperCAmelCase			(     a_):
							snake_case_				=							[]

							# 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 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							dct.pop(a_)
							snake_case_				=							val





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





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





def 						__UpperCAmelCase			(     ):
							snake_case_				=							'http://images.cocodataset.org/val2017/000000039769.jpg'
							snake_case_				=							Image.open(requests.get(a_							,     stream=a_).raw)

							return im





@torch.no_grad()
def 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							get_deta_config(a_)

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

							snake_case_				=							torch.load(a_							,     map_location='cpu')['model']

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

							# rename keys
							snake_case_				=							create_rename_keys(a_)
							for src, dest in rename_keys:
														rename_key(a_							,     a_							,     a_)
							read_in_swin_q_k_v(a_							,     config.backbone_config)
							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:
																					snake_case_				=							state_dict.pop(a_)
																					snake_case_				=							val
														if "input_proj" in key:
																					snake_case_				=							state_dict.pop(a_)
																					snake_case_				=							val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					snake_case_				=							state_dict.pop(a_)
																					snake_case_				=							val

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

							snake_case_				=							'cuda' if torch.cuda.is_available() else 'cpu'
							model.to(a_)

							# load image processor
							snake_case_				=							DetaImageProcessor(format='coco_detection')

							# verify our conversion on image
							snake_case_				=							prepare_img()
							snake_case_				=							processor(images=a_							,     return_tensors='pt')
							snake_case_				=							encoding['pixel_values']
							snake_case_				=							model(pixel_values.to(a_))

							# verify logits
							print('Logits:'							,     outputs.logits[0, :3, :3])
							print('Boxes:'							,     outputs.pred_boxes[0, :3, :3])
							if model_name == "deta-swin-large":
														snake_case_				=							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]])
														snake_case_				=							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":
														snake_case_				=							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]])
														snake_case_				=							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(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__":
	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)













import warnings

from ...utils import logging
from .image_processing_perceiver import PerceiverImageProcessor


lowercase  							=					logging.get_logger(__name__)




class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			*a       ,			**a					)       ->    None:
								warnings.warn(
								    'The class PerceiverFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
								    ' Please use PerceiverImageProcessor instead.'       ,			a       ,			)
								super().__init__(*a       ,			**a					)





