



'''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
from transformers.utils import logging


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





def 				_SCREAMING_SNAKE_CASE(					)		->Optional[Any]:






							'''simple docstring'''
							_lowercase							:		Union[str, Any]				=   DetaConfig(
							    num_queries=9_00 ,       encoder_ffn_dim=20_48 ,       decoder_ffn_dim=20_48 ,       num_feature_levels=5 ,       assign_first_stage=a__ ,       with_box_refine=a__ ,       two_stage=a__ ,       )

							# set labels
							_lowercase							:		Any				=   91
							_lowercase							:		Optional[Any]				=   '''huggingface/label-files'''
							_lowercase							:		Union[str, Any]				=   '''coco-detection-id2label.json'''
							_lowercase							:		str				=   json.load(open(cached_download(hf_hub_url(a__ ,       a__ ,       repo_type='''dataset'''  )  ) ,       '''r'''  )  )
							_lowercase							:		List[str]				=   {int(a__  ): v for k, v in idalabel.items()}
							_lowercase							:		List[str]				=   idalabel
							_lowercase							:		List[Any]				=   {v: k for k, v in idalabel.items()}

							return config





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Optional[int]  )		->Union[str, Any]:






							'''simple docstring'''
							_lowercase							:		Optional[Any]				=   []

							# stem
							# fmt: off
							rename_keys.append(('''backbone.0.body.conv1.weight''', '''model.backbone.model.embedder.embedder.convolution.weight''')  )
							rename_keys.append(('''backbone.0.body.bn1.weight''', '''model.backbone.model.embedder.embedder.normalization.weight''')  )
							rename_keys.append(('''backbone.0.body.bn1.bias''', '''model.backbone.model.embedder.embedder.normalization.bias''')  )
							rename_keys.append(('''backbone.0.body.bn1.running_mean''', '''model.backbone.model.embedder.embedder.normalization.running_mean''')  )
							rename_keys.append(('''backbone.0.body.bn1.running_var''', '''model.backbone.model.embedder.embedder.normalization.running_var''')  )
							# stages
							for stage_idx in range(len(config.backbone_config.depths  )  ):
														for layer_idx in range(config.backbone_config.depths[stage_idx]  ):
																					# shortcut
																					if layer_idx == 0:
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
																												    )  )
																					# 3 convs
																					for i in range(3  ):
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
																												    )  )
																												rename_keys.append(
																												    (
																												        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var",
																												        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
																												    )  )
    # 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(					snake_case_    :     str ,       snake_case_    :     str ,       snake_case_    :     List[str]  )		->List[str]:






							'''simple docstring'''
							_lowercase							:		Union[str, Any]				=   dct.pop(a__  )
							_lowercase							:		List[str]				=   val





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     int ,       snake_case_    :     Any  )		->List[Any]:






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





def 				_SCREAMING_SNAKE_CASE(					)		->Optional[Any]:






							'''simple docstring'''
							_lowercase							:		List[Any]				=   '''http://images.cocodataset.org/val2017/000000039769.jpg'''
							_lowercase							:		int				=   Image.open(requests.get(a__ ,       stream=a__  ).raw  )

							return im





@torch.no_grad()
def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Tuple ,       snake_case_    :     Dict ,       snake_case_    :     Optional[Any]  )		->int:






							'''simple docstring'''
							_lowercase							:		int				=   get_deta_config()

							# load original state dict
							if model_name == "deta-resnet-50":
														_lowercase							:		Dict				=   '''adet_checkpoint0011.pth'''
							elif model_name == "deta-resnet-50-24-epochs":
														_lowercase							:		Optional[int]				=   '''adet_2x_checkpoint0023.pth'''
							else:
														raise ValueError(F"Model name {model_name} not supported"  )
							_lowercase							:		Any				=   hf_hub_download(repo_id='''nielsr/deta-checkpoints''' ,       filename=a__  )
							_lowercase							:		Union[str, Any]				=   torch.load(a__ ,       map_location='''cpu'''  )['''model''']

							# rename keys
							_lowercase							:		int				=   create_rename_keys(a__  )
							for src, dest in rename_keys:
														rename_key(a__ ,       a__ ,       a__  )
							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:
																					_lowercase							:		str				=   state_dict.pop(a__  )
																					_lowercase							:		Tuple				=   val
														if "input_proj" in key:
																					_lowercase							:		List[Any]				=   state_dict.pop(a__  )
																					_lowercase							:		Dict				=   val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					_lowercase							:		List[Any]				=   state_dict.pop(a__  )
																					_lowercase							:		List[Any]				=   val

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

							_lowercase							:		Tuple				=   '''cuda''' if torch.cuda.is_available() else '''cpu'''
							model.to(a__  )

							# load image processor
							_lowercase							:		List[str]				=   DetaImageProcessor(format='''coco_detection'''  )

							# verify our conversion on image
							_lowercase							:		Optional[Any]				=   prepare_img()
							_lowercase							:		Union[str, Any]				=   processor(images=a__ ,       return_tensors='''pt'''  )
							_lowercase							:		int				=   encoding['''pixel_values''']
							_lowercase							:		List[str]				=   model(pixel_values.to(a__  )  )

							# verify logits
							if model_name == "deta-resnet-50":
														_lowercase							:		Optional[int]				=   torch.tensor(
														    [[-7.3_9_7_8, -2.5_4_0_6, -4.1_6_6_8], [-8.2_6_8_4, -3.9_9_3_3, -3.8_0_9_6], [-7.0_5_1_5, -3.7_9_7_3, -5.8_5_1_6]]  )
														_lowercase							:		Optional[Any]				=   torch.tensor([[0.5_0_4_3, 0.4_9_7_3, 0.9_9_9_8], [0.2_5_4_2, 0.5_4_8_9, 0.4_7_4_8], [0.5_4_9_0, 0.2_7_6_5, 0.0_5_7_0]]  )
							elif model_name == "deta-resnet-50-24-epochs":
														_lowercase							:		Optional[int]				=   torch.tensor(
														    [[-7.1_6_8_8, -2.4_8_5_7, -4.8_6_6_9], [-7.8_6_3_0, -3.8_1_5_4, -4.2_6_7_4], [-7.2_7_3_0, -4.1_8_6_5, -5.5_3_2_3]]  )
														_lowercase							:		List[Any]				=   torch.tensor([[0.5_0_2_1, 0.4_9_7_1, 0.9_9_9_4], [0.2_5_4_6, 0.5_4_8_6, 0.4_7_3_1], [0.1_6_8_6, 0.1_9_8_6, 0.2_1_4_2]]  )

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

						parser.add_argument(
						    '--model_name',
						    type=str,
						    default='deta-resnet-50',
						    choices=['deta-resnet-50', 'deta-resnet-50-24-epochs'],
						    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.'
						)
						lowerCamelCase__	  =		parser.parse_args()
						convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






"""simple docstring"""

import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


a__			:						Optional[int]							=			set()
a__			:						str							=			get_logger(__name__)





def 					__UpperCamelCase (     a__:			Optional[str] = None      )					->      Dict:




					"""simple docstring"""



					def decorator(a__:			Callable      ):
										global _emitted_deprecation_warnings

										if inspect.isclass(a__      ):
															__lowercase        =      deprecated_class_or_function.__init__
															__lowercase        =      deprecated_class_or_function.__name__
										else:
															__lowercase        =      deprecated_class_or_function
															__lowercase        =      deprecated_function.__name__
															# Support deprecating __init__ class method: class name instead
															__lowercase        =      name if name != '''__init__''' else deprecated_function.__qualname__.split('''.'''      )[-2]

										__lowercase        =      (
										    f'''{name} is deprecated and will be removed in the next major version of datasets.''' + f''' {help_message}'''
										    if help_message
										    else ''''''
										)

										@wraps(a__      )
										def wrapper(*a__:			int			,						**a__:			int      ):
															__lowercase        =      hash(a__      )
															if func_hash not in _emitted_deprecation_warnings:
																				warnings.warn(a__			,						category=a__			,						stacklevel=2      )
																				_emitted_deprecation_warnings.add(a__      )
															return deprecated_function(*a__			,						**a__      )

										__lowercase        =      '''deprecated'''

										if inspect.isclass(a__      ):
															__lowercase        =      wrapper
															return deprecated_class_or_function
										else:
															return wrapper

					return decorator


class       _snake_case  (    enum.EnumMeta							):







						def __getattribute__(cls  ,				UpperCAmelCase_				)      ->    int:
											__lowercase        =      super().__getattribute__(UpperCAmelCase_				)
											if isinstance(UpperCAmelCase_  ,				enum.Enum				) and obj._on_access:
																obj._on_access()
											return obj







						def __getitem__(cls  ,				UpperCAmelCase_				)      ->    Union[str, Any]:
											__lowercase        =      super().__getitem__(UpperCAmelCase_				)
											if member._on_access:
																member._on_access()
											return member







						def __call__(cls  ,				UpperCAmelCase_  ,				UpperCAmelCase_=None  ,				*, UpperCAmelCase_=None  ,				UpperCAmelCase_=None  ,				UpperCAmelCase_=None  ,				UpperCAmelCase_=1				)      ->    List[Any]:
											__lowercase        =      super().__call__(UpperCAmelCase_  ,				UpperCAmelCase_  ,				module=UpperCAmelCase_  ,				qualname=UpperCAmelCase_  ,				type=UpperCAmelCase_  ,				start=UpperCAmelCase_				)
											if isinstance(UpperCAmelCase_  ,				enum.Enum				) and obj._on_access:
																obj._on_access()
											return obj



class       _snake_case  (    enum.Enum    ,      metaclass=UpperCamelCase							):







						def __new__(cls  ,				UpperCAmelCase_				)      ->    Optional[int]:
											__lowercase        =      object.__new__(cls				)
											__lowercase        =      value
											__lowercase        =      member.deprecate
											return member







						@property
						def 							_UpperCamelCase     (self				)      ->    Dict:
											return ""







						def 							_UpperCamelCase     (self				)      ->    Optional[Any]:
											__lowercase        =      f''' {self.help_message}''' if self.help_message else ''''''
											warnings.warn(
											    f'''\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'''
											    + help_message  ,				UpperCAmelCase_  ,				stacklevel=3  ,				)


