




'''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()
lowercase	:      Union[str, Any]       	=       logging.get_logger(__name__)




def 		a_( )				->Any:






       '''simple docstring'''




       lowercase  :		Dict						=      DetaConfig(
           num_queries=900   ,				encoder_ffn_dim=2048   ,				decoder_ffn_dim=2048   ,				num_feature_levels=5   ,				assign_first_stage=__a   ,				with_box_refine=__a   ,				two_stage=__a   ,				)

       # set labels
       lowercase  :		Dict						=      91
       lowercase  :		Dict						=      '''huggingface/label-files'''
       lowercase  :		List[str]						=      '''coco-detection-id2label.json'''
       lowercase  :		Tuple						=      json.load(open(cached_download(hf_hub_url(__a   ,				__a   ,				repo_type='''dataset'''      )      )   ,				'''r'''      )      )
       lowercase  :		int						=      {int(__a      ): v for k, v in idalabel.items()}
       lowercase  :		Union[str, Any]						=      idalabel
       lowercase  :		Any						=      {v: k for k, v in idalabel.items()}

       return config




def 		a_( lowerCamelCase      )				->Union[str, Any]:






       '''simple docstring'''




       lowercase  :		int						=      []

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






       '''simple docstring'''




       lowercase  :		Optional[Any]						=      dct.pop(__a      )
       lowercase  :		List[Any]						=      val




def 		a_( lowerCamelCase   ,				lowerCamelCase      )				->Dict:






       '''simple docstring'''




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




def 		a_( )				->int:






       '''simple docstring'''




       lowercase  :		Tuple						=      '''http://images.cocodataset.org/val2017/000000039769.jpg'''
       lowercase  :		Union[str, Any]						=      Image.open(requests.get(__a   ,				stream=__a      ).raw      )

       return im




@torch.no_grad()
def 		a_( lowerCamelCase   ,				lowerCamelCase   ,				lowerCamelCase      )				->Optional[Any]:






       '''simple docstring'''




       lowercase  :		str						=      get_deta_config()

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

       # rename keys
       lowercase  :		int						=      create_rename_keys(__a      )
       for src, dest in rename_keys:
              rename_key(__a   ,				__a   ,				__a      )
       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:
                     lowercase  :		str						=      state_dict.pop(__a      )
                     lowercase  :		List[str]						=      val
              if "input_proj" in key:
                     lowercase  :		Tuple						=      state_dict.pop(__a      )
                     lowercase  :		Tuple						=      val
              if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
                     lowercase  :		Dict						=      state_dict.pop(__a      )
                     lowercase  :		List[str]						=      val

    # finally, create HuggingFace model and load state dict
       lowercase  :		str						=      DetaForObjectDetection(__a      )
       model.load_state_dict(__a      )
       model.eval()

       lowercase  :		int						=      '''cuda''' if torch.cuda.is_available() else '''cpu'''
       model.to(__a      )

       # load image processor
       lowercase  :		Optional[Any]						=      DetaImageProcessor(format='''coco_detection'''      )

       # verify our conversion on image
       lowercase  :		Union[str, Any]						=      prepare_img()
       lowercase  :		Any						=      processor(images=__a   ,				return_tensors='''pt'''      )
       lowercase  :		List[Any]						=      encoding['''pixel_values''']
       lowercase  :		Dict						=      model(pixel_values.to(__a      )      )

       # verify logits
       if model_name == "deta-resnet-50":
              lowercase  :		Optional[int]						=      torch.tensor(
                  [[-7.39_78, -2.54_06, -4.16_68], [-8.26_84, -3.99_33, -3.80_96], [-7.05_15, -3.79_73, -5.85_16]]      )
              lowercase  :		Tuple						=      torch.tensor([[0.50_43, 0.49_73, 0.99_98], [0.25_42, 0.54_89, 0.47_48], [0.54_90, 0.27_65, 0.05_70]]      )
       elif model_name == "deta-resnet-50-24-epochs":
              lowercase  :		Any						=      torch.tensor(
                  [[-7.16_88, -2.48_57, -4.86_69], [-7.86_30, -3.81_54, -4.26_74], [-7.27_30, -4.18_65, -5.53_23]]      )
              lowercase  :		List[Any]						=      torch.tensor([[0.50_21, 0.49_71, 0.99_94], [0.25_46, 0.54_86, 0.47_31], [0.16_86, 0.19_86, 0.21_42]]      )

       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	:      List[str]       	=       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.'''
      )
      lowercase	:      Dict       	=       parser.parse_args()
      convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










'''simple docstring'''






import math
from timeit import timeit




def 		a_( lowerCamelCase      )				->int:






       '''simple docstring'''




       lowercase  :		Dict						=      0
       lowercase  :		Union[str, Any]						=      abs(lowerCamelCase      )
       while True:
              lowercase  :		List[Any]						=      n // 10
              digits += 1
              if n == 0:
                     break
       return digits




def 		a_( lowerCamelCase      )				->int:






       '''simple docstring'''




       return 1 if n == 0 else math.floor(math.log(abs(lowerCamelCase      )   ,				10      ) + 1      )




def 		a_( lowerCamelCase      )				->int:






       '''simple docstring'''




       return len(str(abs(lowerCamelCase      )      )      )




def 		a_( )				->None:






       '''simple docstring'''




       from collections.abc import Callable

       def benchmark_a_function(lowerCamelCase   ,				lowerCamelCase      ) -> None:
              lowercase  :		str						=      f"""{func.__name__}({value})"""
              lowercase  :		Optional[Any]						=      timeit(f"""__main__.{call}"""   ,				setup='''import __main__'''      )
              print(f"""{call}: {func(lowerCamelCase      )} -- {timing} seconds"""      )

       for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
              for func in (num_digits, num_digits_fast, num_digits_faster):
                     benchmark_a_function(lowerCamelCase   ,				lowerCamelCase      )
              print()


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      benchmark()




