






'''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			:    Optional[Any]					  =logging.get_logger(__name__)





def 				SCREAMING_SNAKE_CASE_ (UpperCamelCase   )   -> Optional[int]:
							lowerCamelCase__      :			List[str] 						= SwinConfig(
							    embed_dim=192       ,    depths=(2, 2, 18, 2)       ,    num_heads=(6, 12, 24, 48)       ,    window_size=12       ,    out_features=["""stage2""", """stage3""", """stage4"""]       ,    )

							lowerCamelCase__      :			List[Any] 						= DetaConfig(
							    backbone_config=UpperCamelCase       ,    num_queries=900       ,    encoder_ffn_dim=2048       ,    decoder_ffn_dim=2048       ,    num_feature_levels=5       ,    assign_first_stage=UpperCamelCase       ,    with_box_refine=UpperCamelCase       ,    two_stage=UpperCamelCase       ,    )

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

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

							return config





def 				SCREAMING_SNAKE_CASE_ (UpperCamelCase   )   -> Union[str, Any]:
							lowerCamelCase__      :			Tuple 						= []

							# 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 				SCREAMING_SNAKE_CASE_ (UpperCamelCase       ,    UpperCamelCase       ,    UpperCamelCase   )   -> Tuple:
							lowerCamelCase__      :			str 						= dct.pop(UpperCamelCase   )
							lowerCamelCase__      :			List[str] 						= val





def 				SCREAMING_SNAKE_CASE_ (UpperCamelCase       ,    UpperCamelCase   )   -> Tuple:
							lowerCamelCase__      :			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   )   ):
														lowerCamelCase__      :			Optional[int] 						= 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__      :			Tuple 						= state_dict.pop(f'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'''   )
																					lowerCamelCase__      :			List[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
																					lowerCamelCase__      :			List[Any] 						= in_proj_weight[:dim, :]
																					lowerCamelCase__      :			List[Any] 						= in_proj_bias[: dim]
																					lowerCamelCase__      :			Dict 						= in_proj_weight[
																					    dim : dim * 2, :
																					]
																					lowerCamelCase__      :			Any 						= in_proj_bias[
																					    dim : dim * 2
																					]
																					lowerCamelCase__      :			str 						= in_proj_weight[
																					    -dim :, :
																					]
																					lowerCamelCase__      :			str 						= in_proj_bias[-dim :]
																					# fmt: on





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





def 				SCREAMING_SNAKE_CASE_ ()   -> str:
							lowerCamelCase__      :			Dict 						= """http://images.cocodataset.org/val2017/000000039769.jpg"""
							lowerCamelCase__      :			List[Any] 						= Image.open(requests.get(UpperCamelCase       ,    stream=UpperCamelCase   ).raw   )

							return im





@torch.no_grad()
def 				SCREAMING_SNAKE_CASE_ (UpperCamelCase       ,    UpperCamelCase       ,    UpperCamelCase   )   -> Optional[int]:
							lowerCamelCase__      :			Optional[Any] 						= get_deta_config(UpperCamelCase   )

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

							lowerCamelCase__      :			Dict 						= torch.load(UpperCamelCase       ,    map_location="""cpu"""   )["""model"""]

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

							# rename keys
							lowerCamelCase__      :			List[Any] 						= create_rename_keys(UpperCamelCase   )
							for src, dest in rename_keys:
														rename_key(UpperCamelCase       ,    UpperCamelCase       ,    UpperCamelCase   )
							read_in_swin_q_k_v(UpperCamelCase       ,    config.backbone_config   )
							read_in_decoder_q_k_v(UpperCamelCase       ,    UpperCamelCase   )

							# 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__      :			Optional[int] 						= state_dict.pop(UpperCamelCase   )
																					lowerCamelCase__      :			str 						= val
														if "input_proj" in key:
																					lowerCamelCase__      :			Dict 						= state_dict.pop(UpperCamelCase   )
																					lowerCamelCase__      :			Dict 						= val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					lowerCamelCase__      :			Optional[int] 						= state_dict.pop(UpperCamelCase   )
																					lowerCamelCase__      :			Tuple 						= val

    # finally, create HuggingFace model and load state dict
							lowerCamelCase__      :			Tuple 						= DetaForObjectDetection(UpperCamelCase   )
							model.load_state_dict(UpperCamelCase   )
							model.eval()

							lowerCamelCase__      :			Tuple 						= """cuda""" if torch.cuda.is_available() else """cpu"""
							model.to(UpperCamelCase   )

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

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

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

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









'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A			:    Dict					  ={
    '''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
    '''processing_git''': ['''GitProcessor'''],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A			:    Union[str, Any]					  =[
			    '''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

			_A			:    Dict					  =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

