codingutf8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache orglicenseslicense2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license convert deta checkpoints from the original repository url https github comjozhang97detatreemaster import argparse import json from pathlib import path import requests import torch from huggingfacehub import cacheddownload hfhubdownload hfhuburl from pil import image from transformers import detaconfig detaforobjectdetection detaimageprocessor from transformers utils import logging logging setverbosityinfo logger logging getloggername def getdetaconfig config detaconfig numqueries900 encoderffndim2048 decoderffndim2048 numfeaturelevels5 assignfirststagetrue withboxrefinetrue twostagetrue set labels config numlabels 91 repoid huggingfacelabelfiles filename cocodetectionid2label json id2label json loadopencacheddownloadhfhuburlrepoid filename repotypedataset r id2label intk v for k v in id2label items config id2label id2label config label2id v k for k v in id2label items return config here we list all keys to be renamed original name on the left our name on the right def createrenamekeysconfig renamekeys stem fmt off renamekeys appendbackbone 0 body conv1 weight model backbone model embedder embedder convolution weight renamekeys appendbackbone 0 body bn1 weight model backbone model embedder embedder normalization weight renamekeys appendbackbone 0 body bn1 bias model backbone model embedder embedder normalization bias renamekeys appendbackbone 0 body bn1 runningmean model backbone model embedder embedder normalization runningmean renamekeys appendbackbone 0 body bn1 runningvar model backbone model embedder embedder normalization runningvar stages for stageidx in rangelenconfig backboneconfig depths for layeridx in rangeconfig backboneconfig depthsstageidx shortcut if layeridx 0 renamekeys append fbackbone 0 body layerstageidx 1 layeridx downsample 0 weight fmodel backbone model encoder stages stageidx layers layeridx shortcut convolution weight renamekeys append fbackbone 0 body layerstageidx 1 layeridx downsample 1 weight fmodel backbone model encoder stages stageidx layers layeridx shortcut normalization weight renamekeys append fbackbone 0 body layerstageidx 1 layeridx downsample 1 bias fmodel backbone model encoder stages stageidx layers layeridx shortcut normalization bias renamekeys append fbackbone 0 body layerstageidx 1 layeridx downsample 1 runningmean fmodel backbone model encoder stages stageidx layers layeridx shortcut normalization runningmean renamekeys append fbackbone 0 body layerstageidx 1 layeridx downsample 1 runningvar fmodel backbone model encoder stages stageidx layers layeridx shortcut normalization runningvar 3 convs for i in range3 renamekeys append fbackbone 0 body layerstageidx 1 layeridx convi1 weight fmodel backbone model encoder stages stageidx layers layeridx layer i convolution weight renamekeys append fbackbone 0 body layerstageidx 1 layeridx bni1 weight fmodel backbone model encoder stages stageidx layers layeridx layer i normalization weight renamekeys append fbackbone 0 body layerstageidx 1 layeridx bni1 bias fmodel backbone model encoder stages stageidx layers layeridx layer i normalization bias renamekeys append fbackbone 0 body layerstageidx 1 layeridx bni1 runningmean fmodel backbone model encoder stages stageidx layers layeridx layer i normalization runningmean renamekeys append fbackbone 0 body layerstageidx 1 layeridx bni1 runningvar fmodel backbone model encoder stages stageidx layers layeridx layer i normalization runningvar transformer encoder for i in rangeconfig encoderlayers renamekeys appendftransformer encoder layers i selfattn samplingoffsets weight fmodel encoder layers i selfattn samplingoffsets weight renamekeys appendftransformer encoder layers i selfattn samplingoffsets bias fmodel encoder layers i selfattn samplingoffsets bias renamekeys appendftransformer encoder layers i selfattn attentionweights weight fmodel encoder layers i selfattn attentionweights weight renamekeys appendftransformer encoder layers i selfattn attentionweights bias fmodel encoder layers i selfattn attentionweights bias renamekeys appendftransformer encoder layers i selfattn valueproj weight fmodel encoder layers i selfattn valueproj weight renamekeys appendftransformer encoder layers i selfattn valueproj bias fmodel encoder layers i selfattn valueproj bias renamekeys appendftransformer encoder layers i selfattn outputproj weight fmodel encoder layers i selfattn outputproj weight renamekeys appendftransformer encoder layers i selfattn outputproj bias fmodel encoder layers i selfattn outputproj bias renamekeys appendftransformer encoder layers i norm1 weight fmodel encoder layers i selfattnlayernorm weight renamekeys appendftransformer encoder layers i norm1 bias fmodel encoder layers i selfattnlayernorm bias renamekeys appendftransformer encoder layers i linear1 weight fmodel encoder layers i fc1 weight renamekeys appendftransformer encoder layers i linear1 bias fmodel encoder layers i fc1 bias renamekeys appendftransformer encoder layers i linear2 weight fmodel encoder layers i fc2 weight renamekeys appendftransformer encoder layers i linear2 bias fmodel encoder layers i fc2 bias renamekeys appendftransformer encoder layers i norm2 weight fmodel encoder layers i finallayernorm weight renamekeys appendftransformer encoder layers i norm2 bias fmodel encoder layers i finallayernorm bias transformer decoder for i in rangeconfig decoderlayers renamekeys appendftransformer decoder layers i crossattn samplingoffsets weight fmodel decoder layers i encoderattn samplingoffsets weight renamekeys appendftransformer decoder layers i crossattn samplingoffsets bias fmodel decoder layers i encoderattn samplingoffsets bias renamekeys appendftransformer decoder layers i crossattn attentionweights weight fmodel decoder layers i encoderattn attentionweights weight renamekeys appendftransformer decoder layers i crossattn attentionweights bias fmodel decoder layers i encoderattn attentionweights bias renamekeys appendftransformer decoder layers i crossattn valueproj weight fmodel decoder layers i encoderattn valueproj weight renamekeys appendftransformer decoder layers i crossattn valueproj bias fmodel decoder layers i encoderattn valueproj bias renamekeys appendftransformer decoder layers i crossattn outputproj weight fmodel decoder layers i encoderattn outputproj weight renamekeys appendftransformer decoder layers i crossattn outputproj bias fmodel decoder layers i encoderattn outputproj bias renamekeys appendftransformer decoder layers i norm1 weight fmodel decoder layers i encoderattnlayernorm weight renamekeys appendftransformer decoder layers i norm1 bias fmodel decoder layers i encoderattnlayernorm bias renamekeys appendftransformer decoder layers i selfattn outproj weight fmodel decoder layers i selfattn outproj weight renamekeys appendftransformer decoder layers i selfattn outproj bias fmodel decoder layers i selfattn outproj bias renamekeys appendftransformer decoder layers i norm2 weight fmodel decoder layers i selfattnlayernorm weight renamekeys appendftransformer decoder layers i norm2 bias fmodel decoder layers i selfattnlayernorm bias renamekeys appendftransformer decoder layers i linear1 weight fmodel decoder layers i fc1 weight renamekeys appendftransformer decoder layers i linear1 bias fmodel decoder layers i fc1 bias renamekeys appendftransformer decoder layers i linear2 weight fmodel decoder layers i fc2 weight renamekeys appendftransformer decoder layers i linear2 bias fmodel decoder layers i fc2 bias renamekeys appendftransformer decoder layers i norm3 weight fmodel decoder layers i finallayernorm weight renamekeys appendftransformer decoder layers i norm3 bias fmodel decoder layers i finallayernorm bias fmt on return renamekeys def renamekeydct old new val dct popold dctnew val def readindecoderqkvstatedict config transformer decoder selfattention layers hiddensize config dmodel for i in rangeconfig decoderlayers read in weights bias of input projection layer of selfattention inprojweight statedict popftransformer decoder layers i selfattn inprojweight inprojbias statedict popftransformer decoder layers i selfattn inprojbias next add query keys and values in that order to the state dict statedictfmodel decoder layers i selfattn qproj weight inprojweight hiddensize statedictfmodel decoder layers i selfattn qproj bias inprojbias hiddensize statedictfmodel decoder layers i selfattn kproj weight inprojweight hiddensize hiddensize 2 statedictfmodel decoder layers i selfattn kproj bias inprojbiashiddensize hiddensize 2 statedictfmodel decoder layers i selfattn vproj weight inprojweighthiddensize statedictfmodel decoder layers i selfattn vproj bias inprojbiashiddensize we will verify our results on an image of cute cats def prepareimg url http images cocodataset orgval2017000000039769 jpg im image openrequests geturl streamtrue raw return im torch nograd def convertdetacheckpointmodelname pytorchdumpfolderpath pushtohub load config config getdetaconfig load original state dict if modelname detaresnet50 filename adetcheckpoint0011 pth elif modelname detaresnet5024epochs filename adet2xcheckpoint0023 pth else raise valueerrorfmodel name modelname not supported checkpointpath hfhubdownloadrepoidnielsrdetacheckpoints filenamefilename statedict torch loadcheckpointpath maplocationcpumodel rename keys renamekeys createrenamekeysconfig for src dest in renamekeys renamekeystatedict src dest readindecoderqkvstatedict config fix some prefixes for key in statedict copy keys if transformer decoder classembed in key or transformer decoder bboxembed in key val statedict popkey statedictkey replacetransformer decoder model decoder val if inputproj in key val statedict popkey statedictmodel key val if levelembed in key or postrans in key or pixtrans in key or encoutput in key val statedict popkey statedictkey replacetransformer model val finally create huggingface model and load state dict model detaforobjectdetectionconfig model loadstatedictstatedict model eval device cuda if torch cuda isavailable else cpu model todevice load image processor processor detaimageprocessorformatcocodetection verify our conversion on image img prepareimg encoding processorimagesimg returntensorspt pixelvalues encodingpixelvalues outputs modelpixelvalues todevice verify logits if modelname detaresnet50 expectedlogits torch tensor 7 3978 2 5406 4 1668 8 2684 3 9933 3 8096 7 0515 3 7973 5 8516 expectedboxes torch tensor0 5043 0 4973 0 9998 0 2542 0 5489 0 4748 0 5490 0 2765 0 0570 elif modelname detaresnet5024epochs expectedlogits torch tensor 7 1688 2 4857 4 8669 7 8630 3 8154 4 2674 7 2730 4 1865 5 5323 expectedboxes torch tensor0 5021 0 4971 0 9994 0 2546 0 5486 0 4731 0 1686 0 1986 0 2142 assert torch allcloseoutputs logits0 3 3 expectedlogits todevice atol1e4 assert torch allcloseoutputs predboxes0 3 3 expectedboxes todevice atol1e4 printeverything ok if pytorchdumpfolderpath save model and processor logger infofsaving pytorch model and processor to pytorchdumpfolderpath pathpytorchdumpfolderpath mkdirexistoktrue model savepretrainedpytorchdumpfolderpath processor savepretrainedpytorchdumpfolderpath push to hub if pushtohub printpushing model and processor to hub model pushtohubfjozhang97modelname processor pushtohubfjozhang97modelname if name main parser argparse argumentparser parser addargument modelname typestr defaultdetaresnet50 choicesdetaresnet50 detaresnet5024epochs helpname of the model you d like to convert parser addargument pytorchdumpfolderpath defaultnone typestr helppath to the folder to output pytorch model parser addargument pushtohub actionstoretrue helpwhether or not to push the converted model to the hub args parser parseargs convertdetacheckpointargs modelname args pytorchdumpfolderpath args pushtohub coding utf 8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache org licenses license 2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license convert deta checkpoints from the original repository url https github com jozhang97 deta tree master set labels here we list all keys to be renamed original name on the left our name on the right stem fmt off stages shortcut 3 convs transformer encoder transformer decoder fmt on transformer decoder self attention layers read in weights bias of input projection layer of self attention next add query keys and values in that order to the state dict we will verify our results on an image of cute cats copy paste tweak model s weights to our deta structure load config load original state dict rename keys fix some prefixes finally create huggingface model and load state dict load image processor verify our conversion on image verify logits save model and processor push to hub
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()
logger = logging.get_logger(__name__)


def get_deta_config():
    config = DetaConfig(
        num_queries=900,
        encoder_ffn_dim=2048,
        decoder_ffn_dim=2048,
        num_feature_levels=5,
        assign_first_stage=True,
        with_box_refine=True,
        two_stage=True,
    )

    
    config.num_labels = 91
    repo_id = "huggingface/label-files"
    filename = "coco-detection-id2label.json"
    id2label = json.load(open(cached_download(hf_hub_url(repo_id, filename, repo_type="dataset")), "r"))
    id2label = {int(k): v for k, v in id2label.items()}
    config.id2label = id2label
    config.label2id = {v: k for k, v in id2label.items()}

    return config



def create_rename_keys(config):
    rename_keys = []

    
    
    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"))
    
    for stage_idx in range(len(config.backbone_config.depths)):
        for layer_idx in range(config.backbone_config.depths[stage_idx]):
            
            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",
                    )
                )
            
            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",
                    )
                )
    
    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"))

    
    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"))

    

    return rename_keys


def rename_key(dct, old, new):
    val = dct.pop(old)
    dct[new] = val


def read_in_decoder_q_k_v(state_dict, config):
    
    hidden_size = config.d_model
    for i in range(config.decoder_layers):
        
        in_proj_weight = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_weight")
        in_proj_bias = state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_bias")
        
        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.weight"] = in_proj_weight[:hidden_size, :]
        state_dict[f"model.decoder.layers.{i}.self_attn.q_proj.bias"] = in_proj_bias[:hidden_size]
        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.weight"] = in_proj_weight[
            hidden_size : hidden_size * 2, :
        ]
        state_dict[f"model.decoder.layers.{i}.self_attn.k_proj.bias"] = in_proj_bias[hidden_size : hidden_size * 2]
        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.weight"] = in_proj_weight[-hidden_size:, :]
        state_dict[f"model.decoder.layers.{i}.self_attn.v_proj.bias"] = in_proj_bias[-hidden_size:]



def prepare_img():
    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    im = Image.open(requests.get(url, stream=True).raw)

    return im


@torch.no_grad()
def convert_deta_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub):
    

    
    config = get_deta_config()

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

    
    rename_keys = create_rename_keys(config)
    for src, dest in rename_keys:
        rename_key(state_dict, src, dest)
    read_in_decoder_q_k_v(state_dict, config)

    
    for key in state_dict.copy().keys():
        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
            val = state_dict.pop(key)
            state_dict[key.replace("transformer.decoder", "model.decoder")] = val
        if "input_proj" in key:
            val = state_dict.pop(key)
            state_dict["model." + key] = val
        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
            val = state_dict.pop(key)
            state_dict[key.replace("transformer", "model")] = val

    
    model = DetaForObjectDetection(config)
    model.load_state_dict(state_dict)
    model.eval()

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

    
    processor = DetaImageProcessor(format="coco_detection")

    
    img = prepare_img()
    encoding = processor(images=img, return_tensors="pt")
    pixel_values = encoding["pixel_values"]
    outputs = model(pixel_values.to(device))

    
    if model_name == "deta-resnet-50":
        expected_logits = torch.tensor(
            [[-7.3978, -2.5406, -4.1668], [-8.2684, -3.9933, -3.8096], [-7.0515, -3.7973, -5.8516]]
        )
        expected_boxes = 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":
        expected_logits = torch.tensor(
            [[-7.1688, -2.4857, -4.8669], [-7.8630, -3.8154, -4.2674], [-7.2730, -4.1865, -5.5323]]
        )
        expected_boxes = 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(device), atol=1e-4)
    assert torch.allclose(outputs.pred_boxes[0, :3, :3], expected_boxes.to(device), atol=1e-4)
    print("Everything ok!")

    if pytorch_dump_folder_path:
        
        logger.info(f"Saving PyTorch model and processor to {pytorch_dump_folder_path}...")
        Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
        model.save_pretrained(pytorch_dump_folder_path)
        processor.save_pretrained(pytorch_dump_folder_path)

    
    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__":
    parser = 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."
    )
    args = parser.parse_args()
    convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)