code: def convert_deta_checkpoint(
      model_name, pytorch_dump_folder_path, push_to_hub
  ):
      """
      Copy/paste/tweak model's weights to our DETA structure.
      """
  
      # load config
      config = get_deta_config(model_name)
  
      # load original state dict
      if model_name == "deta-swin-large":
          checkpoint_path = hf_hub_download(
              repo_id="nielsr/deta-checkpoints",
              filename="adet_swin_ft.pth",
          )
      elif model_name == "deta-swin-large-o365":
          checkpoint_path = hf_hub_download(
              repo_id="jozhang97/deta-swin-l-o365",
              filename="deta_swin_pt_o365.pth",
          )
      else:
          raise ValueError(f"Model name {model_name} not supported")
  
      state_dict = torch.load(checkpoint_path, map_location="cpu")[
          "model"
      ]
  
      # original state dict
      for name, param in state_dict.items():
          print(name, param.shape)
  
      # rename keys
      rename_keys = create_rename_keys(config)
      for src, dest in rename_keys:
          rename_key(state_dict, src, dest)
      read_in_swin_q_k_v(state_dict, config.backbone_config)
      read_in_decoder_q_k_v(state_dict, config)
  
      # fix some prefixes
      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
  
      # finally, create HuggingFace model and load state dict
      model = DetaForObjectDetection(config)
      model.load_state_dict(state_dict)
      model.eval()
  
      device = "cuda" if torch.cuda.is_available() else "cpu"
      model.to(device)
  
      # load image processor
      processor = DetaImageProcessor(format="coco_detection")
  
      # verify our conversion on image
      img = prepare_img()
      encoding = processor(images=img, return_tensors="pt")
      pixel_values = encoding["pixel_values"]
      outputs = model(pixel_values.to(device))
  
      # verify logits
      print("Logits:", outputs.logits[0, :3, :3])
      print("Boxes:", outputs.pred_boxes[0, :3, :3])
      if model_name == "deta-swin-large":
          expected_logits = torch.tensor(
              [
                  [-7.6308, -2.8485, -5.3737],
                  [-7.2037, -4.5505, -4.8027],
                  [-7.2943, -4.2611, -4.6617],
              ]
          )
          expected_boxes = torch.tensor(
              [
                  [0.4987, 0.4969, 0.9999],
                  [0.2549, 0.5498, 0.4805],
                  [0.5498, 0.2757, 0.0569],
              ]
          )
      elif model_name == "deta-swin-large-o365":
          expected_logits = torch.tensor(
              [
                  [-8.0122, -3.5720, -4.9717],
                  [-8.1547, -3.6886, -4.6389],
                  [-7.6610, -3.6194, -5.0134],
              ]
          )
          expected_boxes = torch.tensor(
              [
                  [0.2523, 0.5549, 0.4881],
                  [0.7715, 0.4149, 0.4601],
                  [0.5503, 0.2753, 0.0575],
              ]
          )
      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:
          # Save model and processor
          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)
  
      # 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}")
  
file_path: transformers/src/transformers/models/deta/convert_deta_swin_to_pytorch.py
imports: 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, SwinConfig
  from transformers.utils import logging
label_desc: Use image node_id 7 for calling a global function with example usage: convert_deta_checkpoint(model_name, pytorch_dump_folder_path, push_to_hub) without return types