




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()
lowerCamelCase__				:     Dict			       =							logging.get_logger(__name__)

def       UpperCAmelCase_							(   )      ->				str:
      SCREAMING_SNAKE_CASE_					=    DetaConfig(
          num_queries=9_00    ,    encoder_ffn_dim=20_48    ,    decoder_ffn_dim=20_48    ,    num_feature_levels=5    ,    assign_first_stage=__UpperCAmelCase    ,    with_box_refine=__UpperCAmelCase    ,    two_stage=__UpperCAmelCase    ,    )

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

      return config

def       UpperCAmelCase_							(   __UpperCAmelCase		:			int							)      ->				List[str]:
      SCREAMING_SNAKE_CASE_					=    []

      # 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_							(   __UpperCAmelCase		:			Tuple    ,    __UpperCAmelCase		:			Optional[Any]    ,    __UpperCAmelCase		:			int							)      ->				Dict:
      SCREAMING_SNAKE_CASE_					=    dct.pop(__UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_					=    val

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

def       UpperCAmelCase_							(   )      ->				List[str]:
      SCREAMING_SNAKE_CASE_					=    'http://images.cocodataset.org/val2017/000000039769.jpg'
      SCREAMING_SNAKE_CASE_					=    Image.open(requests.get(__UpperCAmelCase    ,    stream=__UpperCAmelCase							).raw							)

      return im

@torch.no_grad()
def       UpperCAmelCase_							(   __UpperCAmelCase		:			Dict    ,    __UpperCAmelCase		:			Optional[int]    ,    __UpperCAmelCase		:			Any							)      ->				Dict:
      SCREAMING_SNAKE_CASE_					=    get_deta_config()

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

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

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

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

      SCREAMING_SNAKE_CASE_					=    'cuda' if torch.cuda.is_available() else 'cpu'
      model.to(__UpperCAmelCase							)

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

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

      # verify logits
      if model_name == "deta-resnet-50":
            SCREAMING_SNAKE_CASE_					=    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]]							)
            SCREAMING_SNAKE_CASE_					=    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":
            SCREAMING_SNAKE_CASE_					=    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]]							)
            SCREAMING_SNAKE_CASE_					=    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(__UpperCAmelCase							)    ,    atol=1E-4							)
      assert torch.allclose(outputs.pred_boxes[0, :3, :3]    ,    expected_boxes.to(__UpperCAmelCase							)    ,    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(__UpperCAmelCase							).mkdir(exist_ok=__UpperCAmelCase							)
            model.save_pretrained(__UpperCAmelCase							)
            processor.save_pretrained(__UpperCAmelCase							)

      # 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__":
   lowerCamelCase__				:     Union[str, Any]			       =							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.'
   )
   lowerCamelCase__				:     Dict			       =							parser.parse_args()
   convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowerCamelCase__				:     int			       =							False





@nightly
@require_torch_gpu
class  lowerCamelCase_							(   unittest.TestCase      ):


 '''simple docstring'''







 def    lowerCAmelCase_						(							self						:	Optional[Any]		):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()



 def    lowerCAmelCase_						(							self						:	Optional[int]		):
       SCREAMING_SNAKE_CASE_					=    VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'		)
       # remove text_unet
       pipe.remove_unused_weights()
       pipe.to(_lowerCAmelCase		)
       pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

       SCREAMING_SNAKE_CASE_					=    load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'		)

       SCREAMING_SNAKE_CASE_					=    torch.manual_seed(0		)
       SCREAMING_SNAKE_CASE_					=    pipe(
           prompt='first prompt'       ,       image=_lowerCAmelCase       ,       text_to_image_strength=0.75       ,       generator=_lowerCAmelCase       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='numpy'       ,       ).images

       with tempfile.TemporaryDirectory() as tmpdirname:
             pipe.save_pretrained(_lowerCAmelCase		)
             SCREAMING_SNAKE_CASE_					=    VersatileDiffusionDualGuidedPipeline.from_pretrained(_lowerCAmelCase		)

       pipe.to(_lowerCAmelCase		)
       pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

       SCREAMING_SNAKE_CASE_					=    generator.manual_seed(0		)
       SCREAMING_SNAKE_CASE_					=    pipe(
           prompt='first prompt'       ,       image=_lowerCAmelCase       ,       text_to_image_strength=0.75       ,       generator=_lowerCAmelCase       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='numpy'       ,       ).images

       assert np.abs(image - new_image		).sum() < 1E-5, "Models don't have the same forward pass"




 def    lowerCAmelCase_						(							self						:	Any		):
       SCREAMING_SNAKE_CASE_					=    VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'		)
       pipe.remove_unused_weights()
       pipe.to(_lowerCAmelCase		)
       pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

       SCREAMING_SNAKE_CASE_					=    'cyberpunk 2077'
       SCREAMING_SNAKE_CASE_					=    load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'		)
       SCREAMING_SNAKE_CASE_					=    torch.manual_seed(0		)
       SCREAMING_SNAKE_CASE_					=    pipe(
           prompt=_lowerCAmelCase       ,       image=_lowerCAmelCase       ,       text_to_image_strength=0.75       ,       generator=_lowerCAmelCase       ,       guidance_scale=7.5       ,       num_inference_steps=50       ,       output_type='numpy'       ,       ).images

       SCREAMING_SNAKE_CASE_					=    image[0, 253:256, 253:256, -1]

       assert image.shape == (1, 512, 512, 3)
       SCREAMING_SNAKE_CASE_					=    np.array([0.0787, 0.0849, 0.0826, 0.0812, 0.0807, 0.0795, 0.0818, 0.0798, 0.0779]		)

       assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2