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

def 					SCREAMING_SNAKE_CASE  (   )			->							List[Any]:

				"""simple docstring"""







				A__	:						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=__UpperCamelCase				,    with_box_refine=__UpperCamelCase				,    two_stage=__UpperCamelCase				,    )

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

				return config

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Dict							)			->							str:

				"""simple docstring"""







				A__	:						Tuple								=				[]

				# 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  (   __UpperCamelCase			:    Any				,    __UpperCamelCase			:    Optional[int]				,    __UpperCamelCase			:    Union[str, Any]							)			->							str:

				"""simple docstring"""







				A__	:						int								=				dct.pop(__UpperCamelCase							)
				A__	:						Optional[int]								=				val

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Dict				,    __UpperCamelCase			:    List[str]							)			->							Dict:

				"""simple docstring"""







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

def 					SCREAMING_SNAKE_CASE  (   )			->							Tuple:

				"""simple docstring"""







				A__	:						str								=				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
				A__	:						Optional[Any]								=				Image.open(requests.get(__UpperCamelCase				,    stream=__UpperCamelCase							).raw							)

				return im

@torch.no_grad()
def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Any				,    __UpperCamelCase			:    int				,    __UpperCamelCase			:    List[Any]							)			->							Dict:

				"""simple docstring"""







				A__	:						List[Any]								=				get_deta_config()

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

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

    # finally, create HuggingFace model and load state dict
				A__	:						List[Any]								=				DetaForObjectDetection(__UpperCamelCase							)
				model.load_state_dict(__UpperCamelCase							)
				model.eval()

				A__	:						Dict								=				'''cuda''' if torch.cuda.is_available() else '''cpu'''
				model.to(__UpperCamelCase							)

				# load image processor
				A__	:						List[Any]								=				DetaImageProcessor(format='''coco_detection'''							)

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

				# verify logits
				if model_name == "deta-resnet-50":
								A__	:						Any								=				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]]							)
								A__	:						List[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":
								A__	:						Tuple								=				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]]							)
								A__	:						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(__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__":
					_SCREAMING_SNAKE_CASE     :   Tuple							 =      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.'
					)
					_SCREAMING_SNAKE_CASE     :   Optional[int]							 =      parser.parse_args()
					convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
					from PIL import Image







class 			UpperCamelCase__		(     unittest.TestCase,      SCREAMING_SNAKE_CASE_ ):







	'''simple docstring'''





	def 	__snake_case					(      self		):
					A__	:						Dict								=				load_tool('''image-question-answering'''		)
					self.tool.setup()
					A__	:						List[Any]								=				load_tool('''image-question-answering'''					,							remote=UpperCamelCase__		)





	def 	__snake_case					(      self		):
					A__	:						str								=				Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''		)		) / '''000000039769.png'''		)
					A__	:						List[str]								=				self.tool(UpperCamelCase__					,							'''How many cats are sleeping on the couch?'''		)
					self.assertEqual(UpperCamelCase__					,							'''2'''		)





	def 	__snake_case					(      self		):
					A__	:						Tuple								=				Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''		)		) / '''000000039769.png'''		)
					A__	:						Dict								=				self.remote_tool(UpperCamelCase__					,							'''How many cats are sleeping on the couch?'''		)
					self.assertEqual(UpperCamelCase__					,							'''2'''		)





	def 	__snake_case					(      self		):
					A__	:						Dict								=				Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''		)		) / '''000000039769.png'''		)
					A__	:						int								=				self.tool(image=UpperCamelCase__					,							question='''How many cats are sleeping on the couch?'''		)
					self.assertEqual(UpperCamelCase__					,							'''2'''		)





	def 	__snake_case					(      self		):
					A__	:						Tuple								=				Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''		)		) / '''000000039769.png'''		)
					A__	:						str								=				self.remote_tool(image=UpperCamelCase__					,							question='''How many cats are sleeping on the couch?'''		)
					self.assertEqual(UpperCamelCase__					,							'''2'''		)