





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DeformableDetrConfig, DeformableDetrForObjectDetection, DeformableDetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
snake_case__      :							List[Any]									=  logging.get_logger(__name__)



def _a       (			lowerCamelCase:     Tuple				)			->		Any:







      '''simple docstring'''






      if "backbone.0.body" in orig_key:
            __A      =       orig_key.replace('''backbone.0.body'''      ,       '''backbone.conv_encoder.model'''				)
      if "transformer" in orig_key:
            __A      =       orig_key.replace('''transformer.'''      ,       ''''''				)
      if "norm1" in orig_key:
            if "encoder" in orig_key:
                  __A      =       orig_key.replace('''norm1'''      ,       '''self_attn_layer_norm'''				)
            else:
                  __A      =       orig_key.replace('''norm1'''      ,       '''encoder_attn_layer_norm'''				)
      if "norm2" in orig_key:
            if "encoder" in orig_key:
                  __A      =       orig_key.replace('''norm2'''      ,       '''final_layer_norm'''				)
            else:
                  __A      =       orig_key.replace('''norm2'''      ,       '''self_attn_layer_norm'''				)
      if "norm3" in orig_key:
            __A      =       orig_key.replace('''norm3'''      ,       '''final_layer_norm'''				)
      if "linear1" in orig_key:
            __A      =       orig_key.replace('''linear1'''      ,       '''fc1'''				)
      if "linear2" in orig_key:
            __A      =       orig_key.replace('''linear2'''      ,       '''fc2'''				)
      if "query_embed" in orig_key:
            __A      =       orig_key.replace('''query_embed'''      ,       '''query_position_embeddings'''				)
      if "cross_attn" in orig_key:
            __A      =       orig_key.replace('''cross_attn'''      ,       '''encoder_attn'''				)

      return orig_key



def _a       (			lowerCamelCase:     List[str]				)			->		Any:







      '''simple docstring'''






      for i in range(6				):
            # read in weights + bias of input projection layer of self-attention
            __A      =       state_dict.pop(F"""decoder.layers.{i}.self_attn.in_proj_weight"""				)
            __A      =       state_dict.pop(F"""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[:2_56, :]
            __A      =       in_proj_bias[:2_56]
            __A      =       in_proj_weight[2_56:5_12, :]
            __A      =       in_proj_bias[2_56:5_12]
            __A      =       in_proj_weight[-2_56:, :]
            __A      =       in_proj_bias[-2_56:]



def _a       (			)			->		Optional[Any]:







      '''simple docstring'''






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

      return im



@torch.no_grad()
def _a       (			lowerCamelCase:     Tuple      ,       lowerCamelCase:     str      ,       lowerCamelCase:     List[Any]      ,       lowerCamelCase:     Any      ,       lowerCamelCase:     int      ,       lowerCamelCase:     int      ,       lowerCamelCase:     Tuple      ,       )			->		Tuple:







      '''simple docstring'''






      __A      =       DeformableDetrConfig()
      # set config attributes
      if single_scale:
            __A      =       1
      __A      =       dilation
      __A      =       with_box_refine
      __A      =       two_stage
      # set labels
      __A      =       91
      __A      =       '''huggingface/label-files'''
      __A      =       '''coco-detection-id2label.json'''
      __A      =       json.load(open(cached_download(hf_hub_url(lowerCamelCase      ,       lowerCamelCase      ,       repo_type='''dataset'''				)				)      ,       '''r'''				)				)
      __A      =       {int(lowerCamelCase				): v for k, v in idalabel.items()}
      __A      =       idalabel
      __A      =       {v: k for k, v in idalabel.items()}

      # load image processor
      __A      =       DeformableDetrImageProcessor(format='''coco_detection'''				)

      # prepare image
      __A      =       prepare_img()
      __A      =       image_processor(images=lowerCamelCase      ,       return_tensors='''pt'''				)
      __A      =       encoding['''pixel_values''']

      logger.info('''Converting model...'''				)

      # load original state dict
      __A      =       torch.load(lowerCamelCase      ,       map_location='''cpu'''				)['''model''']
      # rename keys
      for key in state_dict.copy().keys():
            __A      =       state_dict.pop(lowerCamelCase				)
            __A      =       val
      # query, key and value matrices need special treatment
      read_in_q_k_v(lowerCamelCase				)
      # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
      __A      =       '''model.'''
      for key in state_dict.copy().keys():
            if not key.startswith('''class_embed'''				) and not key.startswith('''bbox_embed'''				):
                  __A      =       state_dict.pop(lowerCamelCase				)
                  __A      =       val
    # finally, create HuggingFace model and load state dict
      __A      =       DeformableDetrForObjectDetection(lowerCamelCase				)
      model.load_state_dict(lowerCamelCase				)
      model.eval()

      __A      =       '''cuda''' if torch.cuda.is_available() else '''cpu'''
      model.to(lowerCamelCase				)
      # verify our conversion
      __A      =       model(pixel_values.to(lowerCamelCase				)				)

      __A      =       torch.tensor(
          [[-9.6_645, -4.3_449, -5.8_705], [-9.7_035, -3.8_504, -5.0_724], [-10.5_634, -5.3_379, -7.5_116]]				)
      __A      =       torch.tensor([[0.8_693, 0.2_289, 0.2_492], [0.3_150, 0.5_489, 0.5_845], [0.5_563, 0.7_580, 0.8_518]]				)

      if single_scale:
            __A      =       torch.tensor(
                [[-9.9_051, -4.2_541, -6.4_852], [-9.6_947, -4.0_854, -6.8_033], [-10.0_665, -5.8_470, -7.7_003]]				)
            __A      =       torch.tensor([[0.7_292, 0.4_991, 0.5_532], [0.7_959, 0.2_426, 0.4_236], [0.7_582, 0.3_518, 0.4_451]]				)

      if single_scale and dilation:
            __A      =       torch.tensor(
                [[-8.9_652, -4.1_074, -5.6_635], [-9.0_596, -4.9_447, -6.6_075], [-10.1_178, -4.5_275, -6.2_671]]				)
            __A      =       torch.tensor([[0.7_665, 0.4_130, 0.4_769], [0.8_364, 0.1_841, 0.3_391], [0.6_261, 0.3_895, 0.7_978]]				)

      if with_box_refine:
            __A      =       torch.tensor(
                [[-8.8_895, -5.4_187, -6.8_153], [-8.4_706, -6.1_668, -7.6_184], [-9.0_042, -5.5_359, -6.9_141]]				)
            __A      =       torch.tensor([[0.7_828, 0.2_208, 0.4_323], [0.0_892, 0.5_996, 0.1_319], [0.5_524, 0.6_389, 0.8_914]]				)

      if with_box_refine and two_stage:
            __A      =       torch.tensor(
                [[-6.7_108, -4.3_213, -6.3_777], [-8.9_014, -6.1_799, -6.7_240], [-6.9_315, -4.4_735, -6.2_298]]				)
            __A      =       torch.tensor([[0.2_583, 0.5_499, 0.4_683], [0.7_652, 0.9_068, 0.4_882], [0.5_490, 0.2_763, 0.0_564]]				)

      print('''Logits:'''      ,       outputs.logits[0, :3, :3]				)

      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!'''				)

      # Save model and image processor
      logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""				)
      Path(lowerCamelCase				).mkdir(exist_ok=lowerCamelCase				)
      model.save_pretrained(lowerCamelCase				)
      image_processor.save_pretrained(lowerCamelCase				)

      # Push to hub
      if push_to_hub:
            __A      =       '''deformable-detr'''
            model_name += "-single-scale" if single_scale else ""
            model_name += "-dc5" if dilation else ""
            model_name += "-with-box-refine" if with_box_refine else ""
            model_name += "-two-stage" if two_stage else ""
            print('''Pushing model to hub...'''				)
            model.push_to_hub(repo_path_or_name=lowerCamelCase      ,       organization='''nielsr'''      ,       commit_message='''Add model'''				)


if __name__ == "__main__":
       snake_case__      :							Optional[Any]									=  argparse.ArgumentParser()

       parser.add_argument(
           '--checkpoint_path',
           type=str,
           default='/home/niels/checkpoints/deformable_detr/r50_deformable_detr-checkpoint.pth',
           help='Path to Pytorch checkpoint (.pth file) you\'d like to convert.',
       )
       parser.add_argument('--single_scale', action='store_true', help='Whether to set config.num_features_levels = 1.')
       parser.add_argument('--dilation', action='store_true', help='Whether to set config.dilation=True.')
       parser.add_argument('--with_box_refine', action='store_true', help='Whether to set config.with_box_refine=True.')
       parser.add_argument('--two_stage', action='store_true', help='Whether to set config.two_stage=True.')
       parser.add_argument(
           '--pytorch_dump_folder_path',
           default=None,
           type=str,
           required=True,
           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.'
       )
       snake_case__      :							int									=  parser.parse_args()
       convert_deformable_detr_checkpoint(
           args.checkpoint_path,
           args.single_scale,
           args.dilation,
           args.with_box_refine,
           args.two_stage,
           args.pytorch_dump_folder_path,
           args.push_to_hub,
       )












import unittest
from timeit import timeit



def _a       (			lowerCamelCase:     int      ,       lowerCamelCase:     int				)			->		int:







      '''simple docstring'''






      __A      =       first_num if first_num >= second_num else second_num
      __A      =       max_num
      while (common_mult % first_num > 0) or (common_mult % second_num > 0):
            common_mult += max_num
      return common_mult



def _a       (			lowerCamelCase:     int      ,       lowerCamelCase:     int				)			->		int:







      '''simple docstring'''






      return b if a == 0 else greatest_common_divisor(b % a      ,       lowerCamelCase				)



def _a       (			lowerCamelCase:     int      ,       lowerCamelCase:     int				)			->		int:







      '''simple docstring'''






      return first_num // greatest_common_divisor(lowerCamelCase      ,       lowerCamelCase				) * second_num



def _a       (			)			->		Tuple:







      '''simple docstring'''






      __A      =       (
          '''from __main__ import least_common_multiple_slow, least_common_multiple_fast'''
      )
      print(
          '''least_common_multiple_slow():'''      ,       timeit('''least_common_multiple_slow(1000, 999)'''      ,       setup=lowerCamelCase				)      ,       )
      print(
          '''least_common_multiple_fast():'''      ,       timeit('''least_common_multiple_fast(1000, 999)'''      ,       setup=lowerCamelCase				)      ,       )





class A_      (    unittest.TestCase     ):
   lowerCAmelCase__       =				(
       (10, 20),
       (13, 15),
       (4, 31),
       (10, 42),
       (43, 34),
       (5, 12),
       (12, 25),
       (10, 25),
       (6, 9),
   )
   lowerCAmelCase__       =				(20, 195, 124, 210, 1462, 60, 300, 50, 18)




   def _lowerCAmelCase   (self			:List[str]				)->      Union[str, Any]:
         for i, (first_num, second_num) in enumerate(self.test_inputs				):
               __A      =       least_common_multiple_slow(_UpperCamelCase					,     _UpperCamelCase				)
               __A      =       least_common_multiple_fast(_UpperCamelCase					,     _UpperCamelCase				)
               with self.subTest(i=_UpperCamelCase				):
                     self.assertEqual(_UpperCamelCase					,     self.expected_results[i]				)
                     self.assertEqual(_UpperCamelCase					,     self.expected_results[i]				)


if __name__ == "__main__":
       benchmark()
       unittest.main()





