




"""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()
__A   :  Tuple					=      logging.get_logger(__name__)

def 						snake_case__       (					_lowerCamelCase				)			->List[Any]:






		"""simple docstring"""


		__lowercase				:		Optional[Any]												=				SwinConfig(
		    embed_dim=1_92,  depths=(2, 2, 18, 2),  num_heads=(6, 12, 24, 48),  window_size=12,  out_features=["stage2", "stage3", "stage4"],  )

		__lowercase				:		int												=				DetaConfig(
		    backbone_config=_lowerCamelCase,  num_queries=9_00,  encoder_ffn_dim=20_48,  decoder_ffn_dim=20_48,  num_feature_levels=5,  assign_first_stage=_lowerCamelCase,  with_box_refine=_lowerCamelCase,  two_stage=_lowerCamelCase,  )

		# set labels
		__lowercase				:		str												=				"huggingface/label-files"
		if "o365" in model_name:
				__lowercase				:		Optional[int]												=				3_66
				__lowercase				:		Optional[int]												=				"object365-id2label.json"
		else:
				__lowercase				:		Any												=				91
				__lowercase				:		Any												=				"coco-detection-id2label.json"

		__lowercase				:		List[str]												=				num_labels
		__lowercase				:		str												=				json.load(open(cached_download(hf_hub_url(_lowerCamelCase,  _lowerCamelCase,  repo_type="dataset"				)				),  "r"				)				)
		__lowercase				:		Tuple												=				{int(_lowerCamelCase				): v for k, v in idalabel.items()}
		__lowercase				:		List[str]												=				idalabel
		__lowercase				:		str												=				{v: k for k, v in idalabel.items()}

		return config

def 						snake_case__       (					_lowerCamelCase				)			->List[str]:






		"""simple docstring"""


		__lowercase				:		int												=				[]

		# 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 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase				)			->List[str]:






		"""simple docstring"""


		__lowercase				:		Union[str, Any]												=				dct.pop(_lowerCamelCase				)
		__lowercase				:		Optional[int]												=				val

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->Union[str, Any]:






		"""simple docstring"""


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

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->List[str]:






		"""simple docstring"""


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

def 						snake_case__       (					)			->Optional[Any]:






		"""simple docstring"""


		__lowercase				:		Tuple												=				"http://images.cocodataset.org/val2017/000000039769.jpg"
		__lowercase				:		str												=				Image.open(requests.get(_lowerCamelCase,  stream=_lowerCamelCase				).raw				)

		return im

@torch.no_grad()
def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase				)			->Dict:






		"""simple docstring"""


		__lowercase				:		List[str]												=				get_deta_config(_lowerCamelCase				)

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

		__lowercase				:		List[Any]												=				torch.load(_lowerCamelCase,  map_location="cpu"				)["model"]

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

		# rename keys
		__lowercase				:		Union[str, Any]												=				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:
						__lowercase				:		Tuple												=				state_dict.pop(_lowerCamelCase				)
						__lowercase				:		int												=				val
				if "input_proj" in key:
						__lowercase				:		List[str]												=				state_dict.pop(_lowerCamelCase				)
						__lowercase				:		Optional[int]												=				val
				if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
						__lowercase				:		Union[str, Any]												=				state_dict.pop(_lowerCamelCase				)
						__lowercase				:		str												=				val

    # finally, create HuggingFace model and load state dict
		__lowercase				:		int												=				DetaForObjectDetection(_lowerCamelCase				)
		model.load_state_dict(_lowerCamelCase				)
		model.eval()

		__lowercase				:		str												=				"cuda" if torch.cuda.is_available() else "cpu"
		model.to(_lowerCamelCase				)

		# load image processor
		__lowercase				:		str												=				DetaImageProcessor(format="coco_detection"				)

		# verify our conversion on image
		__lowercase				:		List[str]												=				prepare_img()
		__lowercase				:		Any												=				processor(images=_lowerCamelCase,  return_tensors="pt"				)
		__lowercase				:		Optional[int]												=				encoding["pixel_values"]
		__lowercase				:		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":
				__lowercase				:		Dict												=				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]]				)
				__lowercase				:		Optional[Any]												=				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":
				__lowercase				:		Union[str, Any]												=				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]]				)
				__lowercase				:		Dict												=				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   :  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   :  str					=      parser.parse_args()
						convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






"""simple docstring"""







from __future__ import annotations

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase = None				)			->list[list[str]]:






		"""simple docstring"""


		__lowercase				:		List[Any]												=				word_bank or []
		# create a table
		__lowercase				:		int												=				len(_lowerCamelCase				) + 1

		__lowercase				:		list[list[list[str]]]												=				[]
		for _ in range(_lowerCamelCase				):
				table.append([]				)
		# seed value
		__lowercase				:		Any												=				[[]]  # because empty string has empty combination

		# iterate through the indices
		for i in range(_lowerCamelCase				):
				# condition
				if table[i] != []:
						for word in word_bank:
								# slice condition
								if target[i : i + len(_lowerCamelCase				)] == word:
										__lowercase				:		list[list[str]]												=				[
										    [word, *way] for way in table[i]
										]
										# adds the word to every combination the current position holds
										# now,push that combination to the table[i+len(word)]
										table[i + len(_lowerCamelCase				)] += new_combinations

    # combinations are in reverse order so reverse for better output
		for combination in table[len(_lowerCamelCase				)]:
				combination.reverse()

		return table[len(_lowerCamelCase				)]


if __name__ == "__main__":
						print(all_construct('jwajalapa', ['jwa', 'j', 'w', 'a', 'la', 'lapa']))
						print(all_construct('rajamati', ['s', 'raj', 'amat', 'raja', 'ma', 'i', 't']))
						print(
						    all_construct(
						        'hexagonosaurus',
						        ['h', 'ex', 'hex', 'ag', 'ago', 'ru', 'auru', 'rus', 'go', 'no', 'o', 's'],
						    )
						)
