


"""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, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
__lowercase    =				logging.get_logger(__name__)


def 					lowercase      (    A_	)->				str:
  '''simple docstring'''







  a						:		List[Any]											=      SwinConfig(
      embed_dim=192  ,       depths=(2, 2, 18, 2)  ,       num_heads=(6, 12, 24, 48)  ,       window_size=12  ,       out_features=["stage2", "stage3", "stage4"]  ,       )

  a						:		Union[str, Any]											=      DetaConfig(
      backbone_config=A_  ,       num_queries=900  ,       encoder_ffn_dim=2_048  ,       decoder_ffn_dim=2_048  ,       num_feature_levels=5  ,       assign_first_stage=A_  ,       with_box_refine=A_  ,       two_stage=A_  ,       )

  # set labels
  a						:		Union[str, Any]											=      "huggingface/label-files"
  if "o365" in model_name:
    a						:		Any											=      366
    a						:		Union[str, Any]											=      "object365-id2label.json"
  else:
    a						:		Any											=      91
    a						:		Optional[Any]											=      "coco-detection-id2label.json"

  a						:		Optional[Any]											=      num_labels
  a						:		int											=      json.load(open(cached_download(hf_hub_url(A_  ,       A_  ,       repo_type="dataset"	)	)  ,       "r"	)	)
  a						:		Union[str, Any]											=      {int(A_	): v for k, v in idalabel.items()}
  a						:		Optional[Any]											=      idalabel
  a						:		str											=      {v: k for k, v in idalabel.items()}

  return config


def 					lowercase      (    A_	)->				str:
  '''simple docstring'''







  a						:		Union[str, Any]											=      []

  # stem
  # fmt: off
  rename_keys.append(("backbone.0.body.patch_embed.proj.weight", "model.backbone.model.embeddings.patch_embeddings.projection.weight")	)
  rename_keys.append(("backbone.0.body.patch_embed.proj.bias", "model.backbone.model.embeddings.patch_embeddings.projection.bias")	)
  rename_keys.append(("backbone.0.body.patch_embed.norm.weight", "model.backbone.model.embeddings.norm.weight")	)
  rename_keys.append(("backbone.0.body.patch_embed.norm.bias", "model.backbone.model.embeddings.norm.bias")	)
  # stages
  for i in range(len(config.backbone_config.depths	)	):
    for j in range(config.backbone_config.depths[i]	):
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm1.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm1.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm2.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm2.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias''')	)

    if i < 3:
      rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.reduction.weight''', F'''model.backbone.model.encoder.layers.{i}.downsample.reduction.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.norm.weight''', F'''model.backbone.model.encoder.layers.{i}.downsample.norm.weight''')	)
      rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.norm.bias''', F'''model.backbone.model.encoder.layers.{i}.downsample.norm.bias''')	)

  rename_keys.append(("backbone.0.body.norm1.weight", "model.backbone.model.hidden_states_norms.stage2.weight")	)
  rename_keys.append(("backbone.0.body.norm1.bias", "model.backbone.model.hidden_states_norms.stage2.bias")	)
  rename_keys.append(("backbone.0.body.norm2.weight", "model.backbone.model.hidden_states_norms.stage3.weight")	)
  rename_keys.append(("backbone.0.body.norm2.bias", "model.backbone.model.hidden_states_norms.stage3.bias")	)
  rename_keys.append(("backbone.0.body.norm3.weight", "model.backbone.model.hidden_states_norms.stage4.weight")	)
  rename_keys.append(("backbone.0.body.norm3.bias", "model.backbone.model.hidden_states_norms.stage4.bias")	)

  # 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 					lowercase      (    A_  ,       A_  ,       A_	)->				Any:
  '''simple docstring'''







  a						:		List[Any]											=      dct.pop(A_	)
  a						:		List[str]											=      val


def 					lowercase      (    A_  ,       A_	)->				Optional[int]:
  '''simple docstring'''







  a						:		Union[str, Any]											=      [int(backbone_config.embed_dim * 2**i	) for i in range(len(backbone_config.depths	)	)]
  for i in range(len(backbone_config.depths	)	):
    a						:		List[str]											=      num_features[i]
    for j in range(backbone_config.depths[i]	):
      # fmt: off
      # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
      a						:		Tuple											=      state_dict.pop(F'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'''	)
      a						:		str											=      state_dict.pop(F'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias'''	)
      # next, add query, keys and values (in that order) to the state dict
      a						:		Optional[Any]											=      in_proj_weight[:dim, :]
      a						:		int											=      in_proj_bias[: dim]
      a						:		int											=      in_proj_weight[
          dim : dim * 2, :
      ]
      a						:		Dict											=      in_proj_bias[
          dim : dim * 2
      ]
      a						:		int											=      in_proj_weight[
          -dim :, :
      ]
      a						:		Optional[int]											=      in_proj_bias[-dim :]
      # fmt: on


def 					lowercase      (    A_  ,       A_	)->				str:
  '''simple docstring'''







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


def 					lowercase      (    )->				Tuple:
  '''simple docstring'''







  a						:		int											=      "http://images.cocodataset.org/val2017/000000039769.jpg"
  a						:		Any											=      Image.open(requests.get(A_  ,       stream=A_	).raw	)

  return im


@torch.no_grad()
def 					lowercase      (    A_  ,       A_  ,       A_	)->				Tuple:
  '''simple docstring'''







  a						:		List[Any]											=      get_deta_config(A_	)

  # load original state dict
  if model_name == "deta-swin-large":
    a						:		int											=      hf_hub_download(repo_id="nielsr/deta-checkpoints"  ,       filename="adet_swin_ft.pth"	)
  elif model_name == "deta-swin-large-o365":
    a						:		Union[str, Any]											=      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'''	)

  a						:		Dict											=      torch.load(A_  ,       map_location="cpu"	)["model"]

  # original state dict
  for name, param in state_dict.items():
    print(A_  ,       param.shape	)

  # rename keys
  a						:		Dict											=      create_rename_keys(A_	)
  for src, dest in rename_keys:
    rename_key(A_  ,       A_  ,       A_	)
  read_in_swin_q_k_v(A_  ,       config.backbone_config	)
  read_in_decoder_q_k_v(A_  ,       A_	)

  # fix some prefixes
  for key in state_dict.copy().keys():
    if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
      a						:		Optional[Any]											=      state_dict.pop(A_	)
      a						:		Optional[int]											=      val
    if "input_proj" in key:
      a						:		Dict											=      state_dict.pop(A_	)
      a						:		List[str]											=      val
    if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
      a						:		Dict											=      state_dict.pop(A_	)
      a						:		Union[str, Any]											=      val

    # finally, create HuggingFace model and load state dict
  a						:		Union[str, Any]											=      DetaForObjectDetection(A_	)
  model.load_state_dict(A_	)
  model.eval()

  a						:		int											=      "cuda" if torch.cuda.is_available() else "cpu"
  model.to(A_	)

  # load image processor
  a						:		Any											=      DetaImageProcessor(format="coco_detection"	)

  # verify our conversion on image
  a						:		Dict											=      prepare_img()
  a						:		Tuple											=      processor(images=A_  ,       return_tensors="pt"	)
  a						:		str											=      encoding["pixel_values"]
  a						:		Optional[int]											=      model(pixel_values.to(A_	)	)

  # verify logits
  print("Logits:"  ,       outputs.logits[0, :3, :3]	)
  print("Boxes:"  ,       outputs.pred_boxes[0, :3, :3]	)
  if model_name == "deta-swin-large":
    a						:		Any											=      torch.tensor(
        [[-7.6_3_0_8, -2.8_4_8_5, -5.3_7_3_7], [-7.2_0_3_7, -4.5_5_0_5, -4.8_0_2_7], [-7.2_9_4_3, -4.2_6_1_1, -4.6_6_1_7]]	)
    a						:		int											=      torch.tensor([[0.4_9_8_7, 0.4_9_6_9, 0.9_9_9_9], [0.2_5_4_9, 0.5_4_9_8, 0.4_8_0_5], [0.5_4_9_8, 0.2_7_5_7, 0.0_5_6_9]]	)
  elif model_name == "deta-swin-large-o365":
    a						:		Tuple											=      torch.tensor(
        [[-8.0_1_2_2, -3.5_7_2_0, -4.9_7_1_7], [-8.1_5_4_7, -3.6_8_8_6, -4.6_3_8_9], [-7.6_6_1_0, -3.6_1_9_4, -5.0_1_3_4]]	)
    a						:		List[Any]											=      torch.tensor([[0.2_5_2_3, 0.5_5_4_9, 0.4_8_8_1], [0.7_7_1_5, 0.4_1_4_9, 0.4_6_0_1], [0.5_5_0_3, 0.2_7_5_3, 0.0_5_7_5]]	)
  assert torch.allclose(outputs.logits[0, :3, :3]  ,       expected_logits.to(A_	)  ,       atol=1e-4	)
  assert torch.allclose(outputs.pred_boxes[0, :3, :3]  ,       expected_boxes.to(A_	)  ,       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(A_	).mkdir(exist_ok=A_	)
    model.save_pretrained(A_	)
    processor.save_pretrained(A_	)

  # 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__":
 __lowercase    =				argparse.ArgumentParser()

 parser.add_argument(
     """--model_name""",
     type=str,
     default="""deta-swin-large""",
     choices=["""deta-swin-large""", """deta-swin-large-o365"""],
     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."""
 )
 __lowercase    =				parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










"""simple docstring"""







from math import ceil, sqrt


def 					lowercase      (    A_ = 1_000_000	)->				int:
  '''simple docstring'''







  a						:		Tuple											=      0

  for outer_width in range(3  ,       (limit // 4) + 2	):
    if outer_width**2 > limit:
      a						:		str											=      max(ceil(sqrt(outer_width**2 - limit	)	)  ,       1	)
    else:
      a						:		Tuple											=      1
    if (outer_width - hole_width_lower_bound) % 2:
      hole_width_lower_bound += 1

    answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

  return answer


if __name__ == "__main__":
 print(f'''{solution() = }''')






