




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




def       __magic_name__    (			):






			'''simple docstring'''







			a   =      DetaConfig(
			    num_queries=900,  encoder_ffn_dim=2048,  decoder_ffn_dim=2048,  num_feature_levels=5,  assign_first_stage=A,  with_box_refine=A,  two_stage=A,  )

			# set labels
			a   =      91
			a   =      "huggingface/label-files"
			a   =      "coco-detection-id2label.json"
			a   =      json.load(open(cached_download(hf_hub_url(A,  A,  repo_type="dataset"       )       ),  "r"       )       )
			a   =      {int(A       ): v for k, v in idalabel.items()}
			a   =      idalabel
			a   =      {v: k for k, v in idalabel.items()}

			return config




def       __magic_name__    (			A		: Union[str, Any]       ):






			'''simple docstring'''







			a   =      []

			# 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       __magic_name__    (			A		: Dict,  A		: List[Any],  A		: Optional[Any]       ):






			'''simple docstring'''







			a   =      dct.pop(A       )
			a   =      val




def       __magic_name__    (			A		: List[Any],  A		: List[str]       ):






			'''simple docstring'''







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




def       __magic_name__    (			):






			'''simple docstring'''







			a   =      "http://images.cocodataset.org/val2017/000000039769.jpg"
			a   =      Image.open(requests.get(A,  stream=A       ).raw       )

			return im




@torch.no_grad()
def       __magic_name__    (			A		: Union[str, Any],  A		: List[Any],  A		: Optional[int]       ):






			'''simple docstring'''







			a   =      get_deta_config()

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

			# rename keys
			a   =      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:
									a   =      state_dict.pop(A       )
									a   =      val
						if "input_proj" in key:
									a   =      state_dict.pop(A       )
									a   =      val
						if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
									a   =      state_dict.pop(A       )
									a   =      val

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

			a   =      "cuda" if torch.cuda.is_available() else "cpu"
			model.to(A       )

			# load image processor
			a   =      DetaImageProcessor(format="coco_detection"       )

			# verify our conversion on image
			a   =      prepare_img()
			a   =      processor(images=A,  return_tensors="pt"       )
			a   =      encoding["pixel_values"]
			a   =      model(pixel_values.to(A       )       )

			# verify logits
			if model_name == "deta-resnet-50":
						a   =      torch.tensor(
						    [[-7.39_78, -2.54_06, -4.16_68], [-8.26_84, -3.99_33, -3.80_96], [-7.05_15, -3.79_73, -5.85_16]]       )
						a   =      torch.tensor([[0.50_43, 0.49_73, 0.99_98], [0.25_42, 0.54_89, 0.47_48], [0.54_90, 0.27_65, 0.05_70]]       )
			elif model_name == "deta-resnet-50-24-epochs":
						a   =      torch.tensor(
						    [[-7.16_88, -2.48_57, -4.86_69], [-7.86_30, -3.81_54, -4.26_74], [-7.27_30, -4.18_65, -5.53_23]]       )
						a   =      torch.tensor([[0.50_21, 0.49_71, 0.99_94], [0.25_46, 0.54_86, 0.47_31], [0.16_86, 0.19_86, 0.21_42]]       )

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












import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
		import torch

		from transformers import CamembertModel




@require_torch
@require_sentencepiece
@require_tokenizers
class    snake_case__							(unittest.TestCase       ):
				"""simple docstring"""



				@slow
				def 							__UpperCAmelCase							(				self    :					Optional[Any]							) ->					List[str]:
							a   =      CamembertModel.from_pretrained("camembert-base"							)
							model.to(__lowerCamelCase							)

							a   =      torch.tensor(
							    [[5, 1_21, 11, 6_60, 16, 7_30, 2_55_43, 1_10, 83, 6]] ,				device=__lowerCamelCase ,				dtype=torch.long ,				)  # J'aime le camembert !
							with torch.no_grad():
										a   =      model(__lowerCamelCase							)["last_hidden_state"]
							a   =      torch.Size((1, 10, 7_68)							)
							self.assertEqual(output.shape ,				__lowerCamelCase							)
							# compare the actual values for a slice.
							a   =      torch.tensor(
							    [[[-0.0_254, 0.0_235, 0.1_027], [0.0_606, -0.1_811, -0.0_418], [-0.1_561, -0.1_127, 0.2_687]]] ,				device=__lowerCamelCase ,				dtype=torch.float ,				)
							# camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
							# camembert.eval()
							# expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

							self.assertTrue(torch.allclose(output[:, :3, :3] ,				__lowerCamelCase ,				atol=1e-4							)							)






