






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    UpperCamelCase__  (   )     ->		List[str]:







							"""simple docstring"""





							_a  :    Dict			=						DetaConfig(
							    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
							_a  :    Union[str, Any]			=						91
							_a  :    Union[str, Any]			=						'''huggingface/label-files'''
							_a  :    int			=						'''coco-detection-id2label.json'''
							_a  :    Tuple			=						json.load(open(cached_download(hf_hub_url(UpperCAmelCase    ,	UpperCAmelCase    ,	repo_type='''dataset'''     )     )    ,	'''r'''     )     )
							_a  :    List[str]			=						{int(UpperCAmelCase     ): v for k, v in idalabel.items()}
							_a  :    List[str]			=						idalabel
							_a  :    Any			=						{v: k for k, v in idalabel.items()}

							return config






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		Dict:







							"""simple docstring"""





							_a  :    Dict			=						[]

							# 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    UpperCamelCase__  (   UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )     ->		Optional[Any]:







							"""simple docstring"""





							_a  :    Optional[int]			=						dct.pop(UpperCAmelCase     )
							_a  :    str			=						val






def    UpperCamelCase__  (   UpperCAmelCase    ,	UpperCAmelCase     )     ->		Tuple:







							"""simple docstring"""





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






def    UpperCamelCase__  (   )     ->		str:







							"""simple docstring"""





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

							return im






@torch.no_grad()
def    UpperCamelCase__  (   UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )     ->		Tuple:







							"""simple docstring"""





							_a  :    Any			=						get_deta_config()

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

							# rename keys
							_a  :    Optional[Any]			=						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  :    Union[str, Any]			=						state_dict.pop(UpperCAmelCase     )
																					_a  :    Tuple			=						val
														if "input_proj" in key:
																					_a  :    int			=						state_dict.pop(UpperCAmelCase     )
																					_a  :    str			=						val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					_a  :    int			=						state_dict.pop(UpperCAmelCase     )
																					_a  :    int			=						val

    # finally, create HuggingFace model and load state dict
							_a  :    List[str]			=						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  :    int			=						DetaImageProcessor(format='''coco_detection'''     )

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

							# verify logits
							if model_name == "deta-resnet-50":
														_a  :    List[str]			=						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  :    Optional[int]			=						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  :    Dict			=						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  :    Optional[int]			=						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__":
						__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)







import numpy as np  # noqa: E402

from ...configuration_utils import ConfigMixin, register_to_config
from ...schedulers.scheduling_utils import SchedulerMixin


try:
						import librosa  # noqa: E402

						__lowerCamelCase						= True
						__lowerCamelCase						= ''
except Exception as e:
						__lowerCamelCase						= False
						__lowerCamelCase						= (
						    F'''Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it.'''
						)


from PIL import Image  # noqa: E402

class      UpperCamelCase_							(				UpperCamelCase ,       UpperCamelCase       ):
						lowercase									=  '''mel_config.json'''




						@register_to_config
						def __init__(    self		,	lowercase = 256		,	lowercase = 256		,	lowercase = 22_050		,	lowercase = 2_048		,	lowercase = 512		,	lowercase = 80		,	lowercase = 32		,	)			->						Optional[Any]:
													_a  :    Tuple			=						hop_length
													_a  :    Dict			=						sample_rate
													_a  :    Dict			=						n_fft
													_a  :    List[str]			=						top_db
													_a  :    Optional[int]			=						n_iter
													self.set_resolution(lowercase		,	lowercase       )
													_a  :    Optional[int]			=						None

													if not _librosa_can_be_imported:
																				raise ValueError(_import_error       )




						def      snake_case__(    self		,	lowercase		,	lowercase       )			->						Any:
													_a  :    Any			=						x_res
													_a  :    Optional[Any]			=						y_res
													_a  :    List[Any]			=						self.y_res
													_a  :    Tuple			=						self.x_res * self.hop_length - 1




						def      snake_case__(    self		,	lowercase = None		,	lowercase = None       )			->						Union[str, Any]:
													if audio_file is not None:
																				_a		,					_a  :    str			=						librosa.load(lowercase		,	mono=lowercase		,	sr=self.sr       )
													else:
																				_a  :    Any			=						raw_audio

													# Pad with silence if necessary.
													if len(self.audio       ) < self.x_res * self.hop_length:
																				_a  :    str			=						np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio       ),)       )]       )




						def      snake_case__(    self       )			->						int:
													return len(self.audio       ) // self.slice_size




						def      snake_case__(    self		,	lowercase = 0       )			->						np.ndarray:
													return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]




						def      snake_case__(    self       )			->						int:
													return self.sr




						def      snake_case__(    self		,	lowercase       )			->						Image.Image:
													_a  :    int			=						librosa.feature.melspectrogram(
													    y=self.get_audio_slice(lowercase       )		,	sr=self.sr		,	n_fft=self.n_fft		,	hop_length=self.hop_length		,	n_mels=self.n_mels       )
													_a  :    List[str]			=						librosa.power_to_db(lowercase		,	ref=np.max		,	top_db=self.top_db       )
													_a  :    List[str]			=						(((log_S + self.top_db) * 255 / self.top_db).clip(0		,	255       ) + 0.5).astype(np.uinta       )
													_a  :    Any			=						Image.fromarray(lowercase       )
													return image







						def      snake_case__(    self		,	lowercase       )			->						np.ndarray:
													_a  :    Any			=						np.frombuffer(image.tobytes()		,	dtype='''uint8'''       ).reshape((image.height, image.width)       )
													_a  :    Any			=						bytedata.astype('''float'''       ) * self.top_db / 255 - self.top_db
													_a  :    Dict			=						librosa.db_to_power(lowercase       )
													_a  :    List[str]			=						librosa.feature.inverse.mel_to_audio(
													    lowercase		,	sr=self.sr		,	n_fft=self.n_fft		,	hop_length=self.hop_length		,	n_iter=self.n_iter       )
													return audio