

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()
_UpperCamelCase			       =			logging.get_logger(__name__)
def 						UpperCamelCase_(			)       -> Union[str, Any]:
 UpperCAmelCase__							=				DetaConfig(
     num_queries=9_00  ,    encoder_ffn_dim=20_48  ,    decoder_ffn_dim=20_48  ,    num_feature_levels=5  ,    assign_first_stage=snake_case__  ,    with_box_refine=snake_case__  ,    two_stage=snake_case__  ,    )

 # set labels
 UpperCAmelCase__							=				91
 UpperCAmelCase__							=				'huggingface/label-files'
 UpperCAmelCase__							=				'coco-detection-id2label.json'
 UpperCAmelCase__							=				json.load(open(cached_download(hf_hub_url(snake_case__  ,    snake_case__  ,    repo_type='dataset'   )   )  ,    'r'   )   )
 UpperCAmelCase__							=				{int(snake_case__   ): v for k, v in idalabel.items()}
 UpperCAmelCase__							=				idalabel
 UpperCAmelCase__							=				{v: k for k, v in idalabel.items()}

 return config
def 						UpperCamelCase_(			snake_case__:  Optional[int]   )       -> Tuple:
 UpperCAmelCase__							=				[]

 # 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 						UpperCamelCase_(			snake_case__:  List[str]  ,    snake_case__:  List[Any]  ,    snake_case__:  Any   )       -> Optional[int]:
 UpperCAmelCase__							=				dct.pop(snake_case__   )
 UpperCAmelCase__							=				val
def 						UpperCamelCase_(			snake_case__:  int  ,    snake_case__:  str   )       -> Tuple:
 # transformer decoder self-attention layers
 UpperCAmelCase__							=				config.d_model
 for i in range(config.decoder_layers   ):
  # read in weights + bias of input projection layer of self-attention
  UpperCAmelCase__							=				state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_weight"   )
  UpperCAmelCase__							=				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
  UpperCAmelCase__							=				in_proj_weight[:hidden_size, :]
  UpperCAmelCase__							=				in_proj_bias[:hidden_size]
  UpperCAmelCase__							=				in_proj_weight[
      hidden_size : hidden_size * 2, :
  ]
  UpperCAmelCase__							=				in_proj_bias[hidden_size : hidden_size * 2]
  UpperCAmelCase__							=				in_proj_weight[-hidden_size:, :]
  UpperCAmelCase__							=				in_proj_bias[-hidden_size:]
def 						UpperCamelCase_(			)       -> str:
 UpperCAmelCase__							=				'http://images.cocodataset.org/val2017/000000039769.jpg'
 UpperCAmelCase__							=				Image.open(requests.get(snake_case__  ,    stream=snake_case__   ).raw   )

 return im
@torch.no_grad()
def 						UpperCamelCase_(			snake_case__:  Union[str, Any]  ,    snake_case__:  Tuple  ,    snake_case__:  Dict   )       -> List[Any]:
 UpperCAmelCase__							=				get_deta_config()

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

 # rename keys
 UpperCAmelCase__							=				create_rename_keys(snake_case__   )
 for src, dest in rename_keys:
  rename_key(snake_case__  ,    snake_case__  ,    snake_case__   )
 read_in_decoder_q_k_v(snake_case__  ,    snake_case__   )

 # fix some prefixes
 for key in state_dict.copy().keys():
  if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
   UpperCAmelCase__							=				state_dict.pop(snake_case__   )
   UpperCAmelCase__							=				val
  if "input_proj" in key:
   UpperCAmelCase__							=				state_dict.pop(snake_case__   )
   UpperCAmelCase__							=				val
  if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
   UpperCAmelCase__							=				state_dict.pop(snake_case__   )
   UpperCAmelCase__							=				val

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

 UpperCAmelCase__							=				'cuda' if torch.cuda.is_available() else 'cpu'
 model.to(snake_case__   )

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

 # verify our conversion on image
 UpperCAmelCase__							=				prepare_img()
 UpperCAmelCase__							=				processor(images=snake_case__  ,    return_tensors='pt'   )
 UpperCAmelCase__							=				encoding['pixel_values']
 UpperCAmelCase__							=				model(pixel_values.to(snake_case__   )   )

 # verify logits
 if model_name == "deta-resnet-50":
  UpperCAmelCase__							=				torch.tensor(
      [[-7.3_9_7_8, -2.5_4_0_6, -4.1_6_6_8], [-8.2_6_8_4, -3.9_9_3_3, -3.8_0_9_6], [-7.0_5_1_5, -3.7_9_7_3, -5.8_5_1_6]]   )
  UpperCAmelCase__							=				torch.tensor([[0.5_0_4_3, 0.4_9_7_3, 0.9_9_9_8], [0.2_5_4_2, 0.5_4_8_9, 0.4_7_4_8], [0.5_4_9_0, 0.2_7_6_5, 0.0_5_7_0]]   )
 elif model_name == "deta-resnet-50-24-epochs":
  UpperCAmelCase__							=				torch.tensor(
      [[-7.1_6_8_8, -2.4_8_5_7, -4.8_6_6_9], [-7.8_6_3_0, -3.8_1_5_4, -4.2_6_7_4], [-7.2_7_3_0, -4.1_8_6_5, -5.5_3_2_3]]   )
  UpperCAmelCase__							=				torch.tensor([[0.5_0_2_1, 0.4_9_7_1, 0.9_9_9_4], [0.2_5_4_6, 0.5_4_8_6, 0.4_7_3_1], [0.1_6_8_6, 0.1_9_8_6, 0.2_1_4_2]]   )

 assert torch.allclose(outputs.logits[0, :3, :3]  ,    expected_logits.to(snake_case__   )  ,    atol=1e-4   )
 assert torch.allclose(outputs.pred_boxes[0, :3, :3]  ,    expected_boxes.to(snake_case__   )  ,    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(snake_case__   ).mkdir(exist_ok=snake_case__   )
  model.save_pretrained(snake_case__   )
  processor.save_pretrained(snake_case__   )

 # 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			       =			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.'''
 )
 _UpperCamelCase			       =			parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






import unittest

from transformers import load_tool
from transformers.tools.agent_types import AGENT_TYPE_MAPPING

from .test_tools_common import ToolTesterMixin, output_types



class     lowercase						(       unittest.TestCase ,				_UpperCamelCase					):



 '''simple docstring'''


 def   UpperCamelCase__							(self ) ->					List[Any]:






  """simple docstring"""





  UpperCAmelCase__							=				load_tool('translation' )
  self.tool.setup()
  UpperCAmelCase__							=				load_tool('translation'       ,       remote=__a )




 def   UpperCamelCase__							(self ) ->					Optional[int]:






  """simple docstring"""





  UpperCAmelCase__							=				self.tool('Hey, what\'s up?'       ,       src_lang='English'       ,       tgt_lang='French' )
  self.assertEqual(__a       ,       '- Hé, comment ça va?' )




 def   UpperCamelCase__							(self ) ->					Any:






  """simple docstring"""





  UpperCAmelCase__							=				self.remote_tool('Hey, what\'s up?'       ,       src_lang='English'       ,       tgt_lang='French' )
  self.assertEqual(__a       ,       '- Hé, comment ça va?' )




 def   UpperCamelCase__							(self ) ->					Optional[int]:






  """simple docstring"""





  UpperCAmelCase__							=				self.tool(text='Hey, what\'s up?'       ,       src_lang='English'       ,       tgt_lang='French' )
  self.assertEqual(__a       ,       '- Hé, comment ça va?' )




 def   UpperCamelCase__							(self ) ->					Optional[Any]:






  """simple docstring"""





  UpperCAmelCase__							=				self.remote_tool(text='Hey, what\'s up?'       ,       src_lang='English'       ,       tgt_lang='French' )
  self.assertEqual(__a       ,       '- Hé, comment ça va?' )




 def   UpperCamelCase__							(self ) ->					Any:






  """simple docstring"""





  UpperCAmelCase__							=				['Hey, what\'s up?', 'English', 'Spanish']
  UpperCAmelCase__							=				self.tool(*__a )

  # There is a single output
  if len(self.tool.outputs ) == 1:
   UpperCAmelCase__							=				[outputs]

  self.assertListEqual(output_types(__a )       ,       self.tool.outputs )




 def   UpperCamelCase__							(self ) ->					Optional[int]:






  """simple docstring"""





  UpperCAmelCase__							=				['Hey, what\'s up?', 'English', 'Spanish']
  UpperCAmelCase__							=				self.tool(*__a )

  if not isinstance(__a       ,       __a ):
   UpperCAmelCase__							=				[outputs]

  self.assertEqual(len(__a )       ,       len(self.tool.outputs ) )

  for output, output_type in zip(__a       ,       self.tool.outputs ):
   UpperCAmelCase__							=				AGENT_TYPE_MAPPING[output_type]
   self.assertTrue(isinstance(__a       ,       __a ) )




 def   UpperCamelCase__							(self ) ->					Dict:






  """simple docstring"""





  UpperCAmelCase__							=				['Hey, what\'s up?', 'English', 'Spanish']

  UpperCAmelCase__							=				[]

  for _input, input_type in zip(__a       ,       self.tool.inputs ):
   if isinstance(__a       ,       __a ):
    _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] )
   else:
    _inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) )

        # Should not raise an error
  UpperCAmelCase__							=				self.tool(*__a )

  if not isinstance(__a       ,       __a ):
   UpperCAmelCase__							=				[outputs]

  self.assertEqual(len(__a )       ,       len(self.tool.outputs ) )



