




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__				:      List[Any]	   = logging.get_logger(__name__)

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					int:
     a     =				SwinConfig(
         embed_dim=1_92		, depths=(2, 2, 18, 2)		, num_heads=(6, 12, 24, 48)		, window_size=12		, out_features=["stage2", "stage3", "stage4"]		, )

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

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

     a     =				num_labels
     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  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					Optional[int]:
     a     =				[]

     # 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  SCREAMING_SNAKE_CASE							(       __UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase)      ->					int:
     a     =				dct.pop(__UpperCamelCase)
     a     =				val

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

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase		, __UpperCamelCase)      ->					Union[str, Any]:
     # transformer decoder self-attention layers
     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  SCREAMING_SNAKE_CASE							(       )      ->					List[Any]:
     a     =				"http://images.cocodataset.org/val2017/000000039769.jpg"
     a     =				Image.open(requests.get(__UpperCamelCase		, stream=__UpperCamelCase).raw)

     return im

@torch.no_grad()
def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase)      ->					Union[str, Any]:
     a     =				get_deta_config(__UpperCamelCase)

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

     a     =				torch.load(__UpperCamelCase		, map_location="cpu")["model"]

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

     # rename keys
     a     =				create_rename_keys(__UpperCamelCase)
     for src, dest in rename_keys:
          rename_key(__UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase)
     read_in_swin_q_k_v(__UpperCamelCase		, config.backbone_config)
     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
     print("Logits:"		, outputs.logits[0, :3, :3])
     print("Boxes:"		, outputs.pred_boxes[0, :3, :3])
     if model_name == "deta-swin-large":
          a     =				torch.tensor(
              [[-7.6_308, -2.8_485, -5.3_737], [-7.2_037, -4.5_505, -4.8_027], [-7.2_943, -4.2_611, -4.6_617]])
          a     =				torch.tensor([[0.4_987, 0.4_969, 0.9_999], [0.2_549, 0.5_498, 0.4_805], [0.5_498, 0.2_757, 0.0_569]])
     elif model_name == "deta-swin-large-o365":
          a     =				torch.tensor(
              [[-8.0_122, -3.5_720, -4.9_717], [-8.1_547, -3.6_886, -4.6_389], [-7.6_610, -3.6_194, -5.0_134]])
          a     =				torch.tensor([[0.2_523, 0.5_549, 0.4_881], [0.7_715, 0.4_149, 0.4_601], [0.5_503, 0.2_753, 0.0_575]])
     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__":
   lowercase__				:      List[Any]	   = 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__				:      Tuple	   = parser.parse_args()
   convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







lowercase__				:      str	   = "\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

lowercase__				:      Any	   = [{"type": "code", "content": INSTALL_CONTENT}]
lowercase__				:      Any	   = {
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}

