






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()
_UpperCAmelCase   				=    logging.get_logger(__name__)





def 	lowerCAmelCase_		(lowercase__						:       List[str]       )		->    Any:


				'''simple docstring'''




				lowerCAmelCase__      			=						SwinConfig(
				    embed_dim=1_92     ,					depths=(2, 2, 18, 2)     ,					num_heads=(6, 12, 24, 48)     ,					window_size=12     ,					out_features=['''stage2''', '''stage3''', '''stage4''']     ,					)

				lowerCAmelCase__      			=						DetaConfig(
				    backbone_config=lowercase__     ,					num_queries=9_00     ,					encoder_ffn_dim=20_48     ,					decoder_ffn_dim=20_48     ,					num_feature_levels=5     ,					assign_first_stage=lowercase__     ,					with_box_refine=lowercase__     ,					two_stage=lowercase__     ,					)

				# set labels
				lowerCAmelCase__      			=						'''huggingface/label-files'''
				if "o365" in model_name:
								lowerCAmelCase__      			=						3_66
								lowerCAmelCase__      			=						'''object365-id2label.json'''
				else:
								lowerCAmelCase__      			=						91
								lowerCAmelCase__      			=						'''coco-detection-id2label.json'''

				lowerCAmelCase__      			=						num_labels
				lowerCAmelCase__      			=						json.load(open(cached_download(hf_hub_url(lowercase__     ,					lowercase__     ,					repo_type='''dataset'''       )       )     ,					'''r'''       )       )
				lowerCAmelCase__      			=						{int(lowercase__       ): v for k, v in idalabel.items()}
				lowerCAmelCase__      			=						idalabel
				lowerCAmelCase__      			=						{v: k for k, v in idalabel.items()}

				return config





def 	lowerCAmelCase_		(lowercase__						:       Optional[Any]       )		->    Optional[Any]:


				'''simple docstring'''




				lowerCAmelCase__      			=						[]

				# 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_		(lowercase__						:       Any     ,					lowercase__						:       List[Any]     ,					lowercase__						:       List[Any]       )		->    List[Any]:


				'''simple docstring'''




				lowerCAmelCase__      			=						dct.pop(lowercase__       )
				lowerCAmelCase__      			=						val





def 	lowerCAmelCase_		(lowercase__						:       Any     ,					lowercase__						:       List[str]       )		->    Dict:


				'''simple docstring'''




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





def 	lowerCAmelCase_		(lowercase__						:       Optional[int]     ,					lowercase__						:       int       )		->    int:


				'''simple docstring'''




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





def 	lowerCAmelCase_		()		->    Dict:


				'''simple docstring'''




				lowerCAmelCase__      			=						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
				lowerCAmelCase__      			=						Image.open(requests.get(lowercase__     ,					stream=lowercase__       ).raw       )

				return im





@torch.no_grad()
def 	lowerCAmelCase_		(lowercase__						:       Dict     ,					lowercase__						:       List[str]     ,					lowercase__						:       List[str]       )		->    Optional[int]:


				'''simple docstring'''




				lowerCAmelCase__      			=						get_deta_config(lowercase__       )

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

				lowerCAmelCase__      			=						torch.load(lowercase__     ,					map_location='''cpu'''       )['''model''']

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

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

				# fix some prefixes
				for key in state_dict.copy().keys():
								if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
												lowerCAmelCase__      			=						state_dict.pop(lowercase__       )
												lowerCAmelCase__      			=						val
								if "input_proj" in key:
												lowerCAmelCase__      			=						state_dict.pop(lowercase__       )
												lowerCAmelCase__      			=						val
								if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
												lowerCAmelCase__      			=						state_dict.pop(lowercase__       )
												lowerCAmelCase__      			=						val

    # finally, create HuggingFace model and load state dict
				lowerCAmelCase__      			=						DetaForObjectDetection(lowercase__       )
				model.load_state_dict(lowercase__       )
				model.eval()

				lowerCAmelCase__      			=						'''cuda''' if torch.cuda.is_available() else '''cpu'''
				model.to(lowercase__       )

				# load image processor
				lowerCAmelCase__      			=						DetaImageProcessor(format='''coco_detection'''       )

				# verify our conversion on image
				lowerCAmelCase__      			=						prepare_img()
				lowerCAmelCase__      			=						processor(images=lowercase__     ,					return_tensors='''pt'''       )
				lowerCAmelCase__      			=						encoding['''pixel_values''']
				lowerCAmelCase__      			=						model(pixel_values.to(lowercase__       )       )

				# verify logits
				print('''Logits:'''     ,					outputs.logits[0, :3, :3]       )
				print('''Boxes:'''     ,					outputs.pred_boxes[0, :3, :3]       )
				if model_name == "deta-swin-large":
								lowerCAmelCase__      			=						torch.tensor(
								    [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]       )
								lowerCAmelCase__      			=						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":
								lowerCAmelCase__      			=						torch.tensor(
								    [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]       )
								lowerCAmelCase__      			=						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(lowercase__       )     ,					atol=1e-4       )
				assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,					expected_boxes.to(lowercase__       )     ,					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(lowercase__       ).mkdir(exist_ok=lowercase__       )
								model.save_pretrained(lowercase__       )
								processor.save_pretrained(lowercase__       )

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













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase			:		int   				=    {
    "configuration_git": ["GIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "GitConfig", "GitVisionConfig"],
    "processing_git": ["GitProcessor"],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Dict   				=    [
			    "GIT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "GitForCausalLM",
			    "GitModel",
			    "GitPreTrainedModel",
			    "GitVisionModel",
			]

if TYPE_CHECKING:
			from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
			from .processing_git import GitProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_git import (
						    GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    GitForCausalLM,
						    GitModel,
						    GitPreTrainedModel,
						    GitVisionModel,
						)

else:
			import sys

			_UpperCAmelCase			:		Optional[int]   				=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





