


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







def _UpperCamelCase			(	)				->						List[Any]:


      '''simple docstring'''



      UpperCamelCase__      =							DetaConfig(
          num_queries=900 ,     encoder_ffn_dim=2048 ,     decoder_ffn_dim=2048 ,     num_feature_levels=5 ,     assign_first_stage=_SCREAMING_SNAKE_CASE ,     with_box_refine=_SCREAMING_SNAKE_CASE ,     two_stage=_SCREAMING_SNAKE_CASE ,     )

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

      return config







def _UpperCamelCase			(	__A       )				->						int:


      '''simple docstring'''



      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			(	__A ,     __A ,     __A       )				->						str:


      '''simple docstring'''



      UpperCamelCase__      =							dct.pop(_SCREAMING_SNAKE_CASE       )
      UpperCamelCase__      =							val







def _UpperCamelCase			(	__A ,     __A       )				->						Any:


      '''simple docstring'''



      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			(	)				->						int:


      '''simple docstring'''



      UpperCamelCase__      =							"http://images.cocodataset.org/val2017/000000039769.jpg"
      UpperCamelCase__      =							Image.open(requests.get(_SCREAMING_SNAKE_CASE ,     stream=_SCREAMING_SNAKE_CASE       ).raw       )

      return im







@torch.no_grad()
def _UpperCamelCase			(	__A ,     __A ,     __A       )				->						int:


      '''simple docstring'''



      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=_SCREAMING_SNAKE_CASE       )
      UpperCamelCase__      =							torch.load(_SCREAMING_SNAKE_CASE ,     map_location="cpu"       )["model"]

      # rename keys
      UpperCamelCase__      =							create_rename_keys(_SCREAMING_SNAKE_CASE       )
      for src, dest in rename_keys:
            rename_key(_SCREAMING_SNAKE_CASE ,     _SCREAMING_SNAKE_CASE ,     _SCREAMING_SNAKE_CASE       )
      read_in_decoder_q_k_v(_SCREAMING_SNAKE_CASE ,     _SCREAMING_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(_SCREAMING_SNAKE_CASE       )
                  UpperCamelCase__      =							val
            if "input_proj" in key:
                  UpperCamelCase__      =							state_dict.pop(_SCREAMING_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(_SCREAMING_SNAKE_CASE       )
                  UpperCamelCase__      =							val

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

      UpperCamelCase__      =							"cuda" if torch.cuda.is_available() else "cpu"
      model.to(_SCREAMING_SNAKE_CASE       )

      # load image processor
      UpperCamelCase__      =							DetaImageProcessor(format="coco_detection"       )

      # verify our conversion on image
      UpperCamelCase__      =							prepare_img()
      UpperCamelCase__      =							processor(images=_SCREAMING_SNAKE_CASE ,     return_tensors="pt"       )
      UpperCamelCase__      =							encoding["pixel_values"]
      UpperCamelCase__      =							model(pixel_values.to(_SCREAMING_SNAKE_CASE       )       )

      # verify logits
      if model_name == "deta-resnet-50":
            UpperCamelCase__      =							torch.tensor(
                [[-7.3978, -2.5406, -4.1668], [-8.2684, -3.9933, -3.8096], [-7.0515, -3.7973, -5.8516]]       )
            UpperCamelCase__      =							torch.tensor([[0.5043, 0.4973, 0.9998], [0.2542, 0.5489, 0.4748], [0.5490, 0.2765, 0.0570]]       )
      elif model_name == "deta-resnet-50-24-epochs":
            UpperCamelCase__      =							torch.tensor(
                [[-7.1688, -2.4857, -4.8669], [-7.8630, -3.8154, -4.2674], [-7.2730, -4.1865, -5.5323]]       )
            UpperCamelCase__      =							torch.tensor([[0.5021, 0.4971, 0.9994], [0.2546, 0.5486, 0.4731], [0.1686, 0.1986, 0.2142]]       )

      assert torch.allclose(outputs.logits[0, :3, :3] ,     expected_logits.to(_SCREAMING_SNAKE_CASE       ) ,     atol=1E-4       )
      assert torch.allclose(outputs.pred_boxes[0, :3, :3] ,     expected_boxes.to(_SCREAMING_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(_SCREAMING_SNAKE_CASE       ).mkdir(exist_ok=_SCREAMING_SNAKE_CASE       )
            model.save_pretrained(_SCREAMING_SNAKE_CASE       )
            processor.save_pretrained(_SCREAMING_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__":
  a__    :   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.'
  )
  a__    :   Tuple								=			parser.parse_args()
  convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








from typing import Optional

from ..utils.logging import get_logger
from .audio_classificiation import AudioClassification
from .automatic_speech_recognition import AutomaticSpeechRecognition
from .base import TaskTemplate
from .image_classification import ImageClassification
from .language_modeling import LanguageModeling
from .question_answering import QuestionAnsweringExtractive
from .summarization import Summarization
from .text_classification import TextClassification


UpperCamelCase__	:   int								=     [
    "AutomaticSpeechRecognition",
    "AudioClassification",
    "ImageClassification",
    "LanguageModeling",
    "QuestionAnsweringExtractive",
    "Summarization",
    "TaskTemplate",
    "TextClassification",
]

UpperCamelCase__	:   Any								=     get_logger(__name__)


UpperCamelCase__	:   Union[str, Any]								=     {
    AutomaticSpeechRecognition.task: AutomaticSpeechRecognition,
    AudioClassification.task: AudioClassification,
    ImageClassification.task: ImageClassification,
    LanguageModeling.task: LanguageModeling,
    QuestionAnsweringExtractive.task: QuestionAnsweringExtractive,
    Summarization.task: Summarization,
    TextClassification.task: TextClassification,
}


def        _UpperCAmelCase							(	_SCREAMING_SNAKE_CASE       :		dict							):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_						=    task_template_dict.get('task'							)
    if task_name is None:
        logger.warning(f"""Couldn't find template for task '{task_name}'. Available templates: {list(_SCREAMING_SNAKE_CASE							)}"""							)
        return None
    SCREAMING_SNAKE_CASE_						=    NAMEaTEMPLATE.get(_SCREAMING_SNAKE_CASE							)
    return template.from_dict(_SCREAMING_SNAKE_CASE							)


