




'''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()
UpperCAmelCase_							:	Optional[int]	     =		logging.get_logger(__name__)







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[int]						)-> int:




     '''simple docstring'''





     __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=_lowerCamelCase ,						num_queries=9_00 ,						encoder_ffn_dim=20_48 ,						decoder_ffn_dim=20_48 ,						num_feature_levels=5 ,						assign_first_stage=_lowerCamelCase ,						with_box_refine=_lowerCamelCase ,						two_stage=_lowerCamelCase ,						)

     # 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(_lowerCamelCase ,						_lowerCamelCase ,						repo_type='''dataset'''						)						) ,						'''r'''						)						)
     __snake_case            =	{int(_lowerCamelCase						): v for k, v in idalabel.items()}
     __snake_case            =	idalabel
     __snake_case            =	{v: k for k, v in idalabel.items()}

     return config







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[Any]						)-> Optional[Any]:




     '''simple docstring'''





     __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			(_lowerCamelCase				:  List[Any] ,						_lowerCamelCase				:  Dict ,						_lowerCamelCase				:  Any						)-> List[Any]:




     '''simple docstring'''





     __snake_case            =	dct.pop(_lowerCamelCase						)
     __snake_case            =	val







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[int] ,						_lowerCamelCase				:  Dict						)-> Union[str, Any]:




     '''simple docstring'''





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




     '''simple docstring'''





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




     '''simple docstring'''





     __snake_case            =	'''http://images.cocodataset.org/val2017/000000039769.jpg'''
     __snake_case            =	Image.open(requests.get(_lowerCamelCase ,						stream=_lowerCamelCase						).raw						)

     return im







@torch.no_grad()
def       _UpperCamelCase			(_lowerCamelCase				:  Optional[int] ,						_lowerCamelCase				:  List[str] ,						_lowerCamelCase				:  Union[str, Any]						)-> Optional[Any]:




     '''simple docstring'''





     __snake_case            =	get_deta_config(_lowerCamelCase						)

     # 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(_lowerCamelCase ,						map_location='''cpu'''						)['''model''']

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

     # rename keys
     __snake_case            =	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:
               __snake_case            =	state_dict.pop(_lowerCamelCase						)
               __snake_case            =	val
          if "input_proj" in key:
               __snake_case            =	state_dict.pop(_lowerCamelCase						)
               __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(_lowerCamelCase						)
               __snake_case            =	val

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

     __snake_case            =	'''cuda''' if torch.cuda.is_available() else '''cpu'''
     model.to(_lowerCamelCase						)

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

     # verify our conversion on image
     __snake_case            =	prepare_img()
     __snake_case            =	processor(images=_lowerCamelCase ,						return_tensors='''pt'''						)
     __snake_case            =	encoding['''pixel_values''']
     __snake_case            =	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":
          __snake_case            =	torch.tensor(
              [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]						)
          __snake_case            =	torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]						)
     elif model_name == "deta-swin-large-o365":
          __snake_case            =	torch.tensor(
              [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]						)
          __snake_case            =	torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]						)
     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__":
     UpperCAmelCase_							:	Optional[int]	     =		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.'''
     )
     UpperCAmelCase_							:	Optional[int]	     =		parser.parse_args()
     convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)












SCREAMING_SNAKE_CASE:     Optional[int]									= {str(digit): digit**5 for digit in range(1_0)}


def 					_a							(					lowerCAmelCase )->	int:
		return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCAmelCase ) )


def 					_a							(					)->	int:
		return sum(
		    number
		    for number in range(1000    ,						1000000 )
		    if number == digits_fifth_powers_sum(lowerCAmelCase ) )


if __name__ == "__main__":
						print(solution())