code: 
  
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  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()
  lowerCamelCase										=  logging.get_logger(__name__)
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      if "backbone.0.body" in orig_key:
          _lowercase     =	orig_key.replace('backbone.0.body',      'backbone.conv_encoder.model'      )
      if "transformer" in orig_key:
          _lowercase     =	orig_key.replace('transformer.',      ''      )
      if "norm1" in orig_key:
          if "encoder" in orig_key:
              _lowercase     =	orig_key.replace('norm1',      'self_attn_layer_norm'      )
          else:
              _lowercase     =	orig_key.replace('norm1',      'encoder_attn_layer_norm'      )
      if "norm2" in orig_key:
          if "encoder" in orig_key:
              _lowercase     =	orig_key.replace('norm2',      'final_layer_norm'      )
          else:
              _lowercase     =	orig_key.replace('norm2',      'self_attn_layer_norm'      )
      if "norm3" in orig_key:
          _lowercase     =	orig_key.replace('norm3',      'final_layer_norm'      )
      if "linear1" in orig_key:
          _lowercase     =	orig_key.replace('linear1',      'fc1'      )
      if "linear2" in orig_key:
          _lowercase     =	orig_key.replace('linear2',      'fc2'      )
      if "query_embed" in orig_key:
          _lowercase     =	orig_key.replace('query_embed',      'query_position_embeddings'      )
      if "cross_attn" in orig_key:
          _lowercase     =	orig_key.replace('cross_attn',      'encoder_attn'      )
  
      return orig_key
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      for i in range(6      ):
          # read in weights + bias of input projection layer of self-attention
          _lowercase     =	state_dict.pop(f'''decoder.layers.{i}.self_attn.in_proj_weight'''      )
          _lowercase     =	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
          _lowercase     =	in_proj_weight[:256, :]
          _lowercase     =	in_proj_bias[:256]
          _lowercase     =	in_proj_weight[256:512, :]
          _lowercase     =	in_proj_bias[256:512]
          _lowercase     =	in_proj_weight[-256:, :]
          _lowercase     =	in_proj_bias[-256:]
  def        UpperCAmelCase      (   ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	'http://images.cocodataset.org/val2017/000000039769.jpg'
      _lowercase     =	Image.open(requests.get(_lowercase,      stream=_lowercase      ).raw      )
  
      return im
  @torch.no_grad()
  def        UpperCAmelCase      (   _lowercase,      _lowercase,      _lowercase,      _lowercase,      _lowercase,      _lowercase,      _lowercase,      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	DeformableDetrConfig()
      # set config attributes
      if single_scale:
          _lowercase     =	1
      _lowercase     =	dilation
      _lowercase     =	with_box_refine
      _lowercase     =	two_stage
      # set labels
      _lowercase     =	91
      _lowercase     =	'huggingface/label-files'
      _lowercase     =	'coco-detection-id2label.json'
      _lowercase     =	json.load(open(cached_download(hf_hub_url(_lowercase,      _lowercase,      repo_type='dataset'      )      ),      'r'      )      )
      _lowercase     =	{int(_lowercase      ): v for k, v in idalabel.items()}
      _lowercase     =	idalabel
      _lowercase     =	{v: k for k, v in idalabel.items()}
  
      # load image processor
      _lowercase     =	DeformableDetrImageProcessor(format='coco_detection'      )
  
      # prepare image
      _lowercase     =	prepare_img()
      _lowercase     =	image_processor(images=_lowercase,      return_tensors='pt'      )
      _lowercase     =	encoding['pixel_values']
  
      logger.info('Converting model...'      )
  
      # load original state dict
      _lowercase     =	torch.load(_lowercase,      map_location='cpu'      )['model']
      # rename keys
      for key in state_dict.copy().keys():
          _lowercase     =	state_dict.pop(_lowercase      )
          _lowercase     =	val
      # query, key and value matrices need special treatment
      read_in_q_k_v(_lowercase      )
      # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
      _lowercase     =	'model.'
      for key in state_dict.copy().keys():
          if not key.startswith('class_embed'      ) and not key.startswith('bbox_embed'      ):
              _lowercase     =	state_dict.pop(_lowercase      )
              _lowercase     =	val
      # finally, create HuggingFace model and load state dict
      _lowercase     =	DeformableDetrForObjectDetection(_lowercase      )
      model.load_state_dict(_lowercase      )
      model.eval()
  
      _lowercase     =	'cuda' if torch.cuda.is_available() else 'cpu'
      model.to(_lowercase      )
      # verify our conversion
      _lowercase     =	model(pixel_values.to(_lowercase      )      )
  
      _lowercase     =	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]]      )
      _lowercase     =	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:
          _lowercase     =	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]]      )
          _lowercase     =	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:
          _lowercase     =	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]]      )
          _lowercase     =	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:
          _lowercase     =	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]]      )
          _lowercase     =	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:
          _lowercase     =	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]]      )
          _lowercase     =	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(_lowercase      ),      atol=1e-4      )
      assert torch.allclose(outputs.pred_boxes[0, :3, :3],      expected_boxes.to(_lowercase      ),      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(_lowercase      ).mkdir(exist_ok=_lowercase      )
      model.save_pretrained(_lowercase      )
      image_processor.save_pretrained(_lowercase      )
  
      # Push to hub
      if push_to_hub:
          _lowercase     =	'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=_lowercase,      organization='nielsr',      commit_message='Add model'      )
  
  
  if __name__ == "__main__":
     lowerCamelCase										=  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.'''
     )
     lowerCamelCase										=  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,
     )
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  def        UpperCAmelCase      (   _lowercase,      _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	[None] * (len(_lowercase      ) + len(_lowercase      ))
  
      _lowercase     =	0  # pointer to current index for left Half
      _lowercase     =	0  # pointer to current index for the right Half
      _lowercase     =	0  # pointer to current index for the sorted array Half
  
      while pointera < len(_lowercase      ) and pointera < len(_lowercase      ):
          if left_half[pointera] < right_half[pointera]:
              _lowercase     =	left_half[pointera]
              pointera += 1
              index += 1
          else:
              _lowercase     =	right_half[pointera]
              pointera += 1
              index += 1
      while pointera < len(_lowercase      ):
          _lowercase     =	left_half[pointera]
          pointera += 1
          index += 1
  
      while pointera < len(_lowercase      ):
          _lowercase     =	right_half[pointera]
          pointera += 1
          index += 1
  
      return sorted_array
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      if len(_lowercase      ) <= 1:
          return array
      # the actual formula to calculate the middle element = left + (right - left) // 2
      # this avoids integer overflow in case of large N
      _lowercase     =	0 + (len(_lowercase      ) - 0) // 2
  
      # Split the array into halves till the array length becomes equal to One
      # merge the arrays of single length returned by mergeSort function and
      # pass them into the merge arrays function which merges the array
      _lowercase     =	array[:middle]
      _lowercase     =	array[middle:]
  
      return merge(merge_sort(_lowercase      ),      merge_sort(_lowercase      )      )
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  