






def 				lowerCamelCase__      (    __lowerCamelCase			:     list		):
  if any(not isinstance(__lowerCamelCase  ,		__lowerCamelCase		) or x < 0 for x in sequence		):
    raise TypeError("""Sequence must be list of non-negative integers"""		)
  for _ in range(len(__lowerCamelCase		)		):
    for i, (rod_upper, rod_lower) in enumerate(zip(__lowerCamelCase  ,		sequence[1:]		)		):
      if rod_upper > rod_lower:
        sequence[i] -= rod_upper - rod_lower
        sequence[i + 1] += rod_upper - rod_lower
  return sequence


if __name__ == "__main__":
       assert bead_sort([5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5]
       assert bead_sort([7, 9, 4, 3, 5]) == [3, 4, 5, 7, 9]










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






def 				lowerCamelCase__      (    __lowerCamelCase			:     str		):
  __UpperCAmelCase							:	Tuple           =  SwinConfig(
      embed_dim=192  ,		depths=(2, 2, 18, 2)  ,		num_heads=(6, 12, 24, 48)  ,		window_size=12  ,		out_features=["""stage2""", """stage3""", """stage4"""]  ,		)

  __UpperCAmelCase							:	Union[str, Any]           =  DetaConfig(
      backbone_config=__lowerCamelCase  ,		num_queries=900  ,		encoder_ffn_dim=2048  ,		decoder_ffn_dim=2048  ,		num_feature_levels=5  ,		assign_first_stage=__lowerCamelCase  ,		with_box_refine=__lowerCamelCase  ,		two_stage=__lowerCamelCase  ,		)

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

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

  return config






def 				lowerCamelCase__      (    __lowerCamelCase			:     Union[str, Any]		):
  __UpperCAmelCase							:	Dict           =  []

  # 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 				lowerCamelCase__      (    __lowerCamelCase			:     List[str]  ,		__lowerCamelCase			:     Optional[int]  ,		__lowerCamelCase			:     Union[str, Any]		):
  __UpperCAmelCase							:	Union[str, Any]           =  dct.pop(__lowerCamelCase		)
  __UpperCAmelCase							:	List[Any]           =  val






def 				lowerCamelCase__      (    __lowerCamelCase			:     Tuple  ,		__lowerCamelCase			:     Optional[Any]		):
  __UpperCAmelCase							:	List[Any]           =  [int(backbone_config.embed_dim * 2**i		) for i in range(len(backbone_config.depths		)		)]
  for i in range(len(backbone_config.depths		)		):
    __UpperCAmelCase							:	Any           =  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)
      __UpperCAmelCase							:	int           =  state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""		)
      __UpperCAmelCase							:	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
      __UpperCAmelCase							:	str           =  in_proj_weight[:dim, :]
      __UpperCAmelCase							:	Union[str, Any]           =  in_proj_bias[: dim]
      __UpperCAmelCase							:	List[str]           =  in_proj_weight[
          dim : dim * 2, :
      ]
      __UpperCAmelCase							:	Dict           =  in_proj_bias[
          dim : dim * 2
      ]
      __UpperCAmelCase							:	List[str]           =  in_proj_weight[
          -dim :, :
      ]
      __UpperCAmelCase							:	Optional[Any]           =  in_proj_bias[-dim :]
      # fmt: on






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






def 				lowerCamelCase__      (    ):
  __UpperCAmelCase							:	Tuple           =  """http://images.cocodataset.org/val2017/000000039769.jpg"""
  __UpperCAmelCase							:	Tuple           =  Image.open(requests.get(__lowerCamelCase  ,		stream=__lowerCamelCase		).raw		)

  return im






@torch.no_grad()
def 				lowerCamelCase__      (    __lowerCamelCase			:     str  ,		__lowerCamelCase			:     Union[str, Any]  ,		__lowerCamelCase			:     Optional[int]		):
  __UpperCAmelCase							:	Any           =  get_deta_config(__lowerCamelCase		)

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

  __UpperCAmelCase							:	int           =  torch.load(__lowerCamelCase  ,		map_location="""cpu"""		)["""model"""]

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

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

  # 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							:	str           =  state_dict.pop(__lowerCamelCase		)
      __UpperCAmelCase							:	Optional[Any]           =  val
    if "input_proj" in key:
      __UpperCAmelCase							:	Any           =  state_dict.pop(__lowerCamelCase		)
      __UpperCAmelCase							:	Union[str, Any]           =  val
    if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
      __UpperCAmelCase							:	Dict           =  state_dict.pop(__lowerCamelCase		)
      __UpperCAmelCase							:	Optional[int]           =  val

    # finally, create HuggingFace model and load state dict
  __UpperCAmelCase							:	Optional[Any]           =  DetaForObjectDetection(__lowerCamelCase		)
  model.load_state_dict(__lowerCamelCase		)
  model.eval()

  __UpperCAmelCase							:	Optional[int]           =  """cuda""" if torch.cuda.is_available() else """cpu"""
  model.to(__lowerCamelCase		)

  # load image processor
  __UpperCAmelCase							:	int           =  DetaImageProcessor(format="""coco_detection"""		)

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

  # verify logits
  print("""Logits:"""  ,		outputs.logits[0, :3, :3]		)
  print("""Boxes:"""  ,		outputs.pred_boxes[0, :3, :3]		)
  if model_name == "deta-swin-large":
    __UpperCAmelCase							:	List[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]]		)
    __UpperCAmelCase							:	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":
    __UpperCAmelCase							:	Optional[int]           =  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]]		)
    __UpperCAmelCase							:	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(__lowerCamelCase		)  ,		atol=1E-4		)
  assert torch.allclose(outputs.pred_boxes[0, :3, :3]  ,		expected_boxes.to(__lowerCamelCase		)  ,		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(__lowerCamelCase		).mkdir(exist_ok=__lowerCamelCase		)
    model.save_pretrained(__lowerCamelCase		)
    processor.save_pretrained(__lowerCamelCase		)

  # 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		:       List[str]			     = 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."
       )
       a		:       List[Any]			     = parser.parse_args()
       convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


