


"""simple docstring"""


import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
from transformers.utils import logging


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






def      a__ (				__lowercase   )	->	List[str]:
				# initialize config
				if "resnet-50" in model_name:
								_A					  =			ResNetConfig.from_pretrained("microsoft/resnet-50"   )
				elif "resnet-101" in model_name:
								_A					  =			ResNetConfig.from_pretrained("microsoft/resnet-101"   )
				else:
								raise ValueError("Model name should include either resnet50 or resnet101"   )

				_A					  =			DetrConfig(use_timm_backbone=__lowercase     ,			backbone_config=__lowercase   )

				# set label attributes
				_A					  =			"panoptic" in model_name
				if is_panoptic:
								_A					  =			250
				else:
								_A					  =			91
								_A					  =			"huggingface/label-files"
								_A					  =			"coco-detection-id2label.json"
								_A					  =			json.load(open(hf_hub_download(__lowercase     ,			__lowercase     ,			repo_type="dataset"   )     ,			"r"   )   )
								_A					  =			{int(__lowercase   ): v for k, v in idalabel.items()}
								_A					  =			idalabel
								_A					  =			{v: k for k, v in idalabel.items()}

				return config, is_panoptic






def      a__ (				__lowercase   )	->	str:
				# here we list all keys to be renamed (original name on the left, our name on the right)
				_A					  =			[]

				# stem
				# fmt: off
				rename_keys.append(("backbone.0.body.conv1.weight", "backbone.conv_encoder.model.embedder.embedder.convolution.weight")   )
				rename_keys.append(("backbone.0.body.bn1.weight", "backbone.conv_encoder.model.embedder.embedder.normalization.weight")   )
				rename_keys.append(("backbone.0.body.bn1.bias", "backbone.conv_encoder.model.embedder.embedder.normalization.bias")   )
				rename_keys.append(("backbone.0.body.bn1.running_mean", "backbone.conv_encoder.model.embedder.embedder.normalization.running_mean")   )
				rename_keys.append(("backbone.0.body.bn1.running_var", "backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.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"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""",
																    )   )
    # fmt: on

				for i in range(config.encoder_layers   ):
								# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
								rename_keys.append(
								    (
								        f"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""",
								        f"""encoder.layers.{i}.self_attn.out_proj.weight""",
								    )   )
								rename_keys.append(
								    (f"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", f"""encoder.layers.{i}.self_attn.out_proj.bias""")   )
								rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""encoder.layers.{i}.fc1.weight""")   )
								rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""encoder.layers.{i}.fc1.bias""")   )
								rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""encoder.layers.{i}.fc2.weight""")   )
								rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""encoder.layers.{i}.fc2.bias""")   )
								rename_keys.append(
								    (f"""transformer.encoder.layers.{i}.norm1.weight""", f"""encoder.layers.{i}.self_attn_layer_norm.weight""")   )
								rename_keys.append(
								    (f"""transformer.encoder.layers.{i}.norm1.bias""", f"""encoder.layers.{i}.self_attn_layer_norm.bias""")   )
								rename_keys.append(
								    (f"""transformer.encoder.layers.{i}.norm2.weight""", f"""encoder.layers.{i}.final_layer_norm.weight""")   )
								rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""encoder.layers.{i}.final_layer_norm.bias""")   )
								# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
								rename_keys.append(
								    (
								        f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""",
								        f"""decoder.layers.{i}.self_attn.out_proj.weight""",
								    )   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""decoder.layers.{i}.self_attn.out_proj.bias""")   )
								rename_keys.append(
								    (
								        f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""",
								        f"""decoder.layers.{i}.encoder_attn.out_proj.weight""",
								    )   )
								rename_keys.append(
								    (
								        f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""",
								        f"""decoder.layers.{i}.encoder_attn.out_proj.bias""",
								    )   )
								rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""decoder.layers.{i}.fc1.weight""")   )
								rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""decoder.layers.{i}.fc1.bias""")   )
								rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""decoder.layers.{i}.fc2.weight""")   )
								rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""decoder.layers.{i}.fc2.bias""")   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.norm1.weight""", f"""decoder.layers.{i}.self_attn_layer_norm.weight""")   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.norm1.bias""", f"""decoder.layers.{i}.self_attn_layer_norm.bias""")   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.norm2.weight""", f"""decoder.layers.{i}.encoder_attn_layer_norm.weight""")   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.norm2.bias""", f"""decoder.layers.{i}.encoder_attn_layer_norm.bias""")   )
								rename_keys.append(
								    (f"""transformer.decoder.layers.{i}.norm3.weight""", f"""decoder.layers.{i}.final_layer_norm.weight""")   )
								rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""decoder.layers.{i}.final_layer_norm.bias""")   )

				# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
				rename_keys.extend(
				    [
				        ("input_proj.weight", "input_projection.weight"),
				        ("input_proj.bias", "input_projection.bias"),
				        ("query_embed.weight", "query_position_embeddings.weight"),
				        ("transformer.decoder.norm.weight", "decoder.layernorm.weight"),
				        ("transformer.decoder.norm.bias", "decoder.layernorm.bias"),
				        ("class_embed.weight", "class_labels_classifier.weight"),
				        ("class_embed.bias", "class_labels_classifier.bias"),
				        ("bbox_embed.layers.0.weight", "bbox_predictor.layers.0.weight"),
				        ("bbox_embed.layers.0.bias", "bbox_predictor.layers.0.bias"),
				        ("bbox_embed.layers.1.weight", "bbox_predictor.layers.1.weight"),
				        ("bbox_embed.layers.1.bias", "bbox_predictor.layers.1.bias"),
				        ("bbox_embed.layers.2.weight", "bbox_predictor.layers.2.weight"),
				        ("bbox_embed.layers.2.bias", "bbox_predictor.layers.2.bias"),
				    ]   )

				return rename_keys






def      a__ (				__lowercase     ,			__lowercase     ,			__lowercase   )	->	Tuple:
				_A					  =			state_dict.pop(__lowercase   )
				_A					  =			val






def      a__ (				__lowercase     ,			__lowercase=False   )	->	Optional[int]:
				_A					  =			""
				if is_panoptic:
								_A					  =			"detr."

				# first: transformer encoder
				for i in range(6   ):
								# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
								_A					  =			state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight"""   )
								_A					  =			state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias"""   )
								# next, add query, keys and values (in that order) to the state dict
								_A					  =			in_proj_weight[:256, :]
								_A					  =			in_proj_bias[:256]
								_A					  =			in_proj_weight[256:512, :]
								_A					  =			in_proj_bias[256:512]
								_A					  =			in_proj_weight[-256:, :]
								_A					  =			in_proj_bias[-256:]
				# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
				for i in range(6   ):
								# read in weights + bias of input projection layer of self-attention
								_A					  =			state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight"""   )
								_A					  =			state_dict.pop(f"""{prefix}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[:256, :]
								_A					  =			in_proj_bias[:256]
								_A					  =			in_proj_weight[256:512, :]
								_A					  =			in_proj_bias[256:512]
								_A					  =			in_proj_weight[-256:, :]
								_A					  =			in_proj_bias[-256:]
								# read in weights + bias of input projection layer of cross-attention
								_A					  =			state_dict.pop(
								    f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"""   )
								_A					  =			state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias"""   )
								# next, add query, keys and values (in that order) of cross-attention to the state dict
								_A					  =			in_proj_weight_cross_attn[:256, :]
								_A					  =			in_proj_bias_cross_attn[:256]
								_A					  =			in_proj_weight_cross_attn[256:512, :]
								_A					  =			in_proj_bias_cross_attn[256:512]
								_A					  =			in_proj_weight_cross_attn[-256:, :]
								_A					  =			in_proj_bias_cross_attn[-256:]






def      a__ (				)	->	Optional[Any]:
				_A					  =			"http://images.cocodataset.org/val2017/000000039769.jpg"
				_A					  =			Image.open(requests.get(__lowercase     ,			stream=__lowercase   ).raw   )

				return im






@torch.no_grad()
def      a__ (				__lowercase     ,			__lowercase=None     ,			__lowercase=False   )	->	List[str]:
				_A  ,		_A					  =			get_detr_config(__lowercase   )

				# load original model from torch hub
				_A					  =			{
				    "detr-resnet-50": "detr_resnet50",
				    "detr-resnet-101": "detr_resnet101",
				}
				logger.info(f"""Converting model {model_name}..."""   )
				_A					  =			torch.hub.load("facebookresearch/detr"     ,			model_name_to_original_name[model_name]     ,			pretrained=__lowercase   ).eval()
				_A					  =			detr.state_dict()
				# rename keys
				for src, dest in create_rename_keys(__lowercase   ):
								if is_panoptic:
												_A					  =			"detr." + src
								rename_key(__lowercase     ,			__lowercase     ,			__lowercase   )
				# query, key and value matrices need special treatment
				read_in_q_k_v(__lowercase     ,			is_panoptic=__lowercase   )
				# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
				_A					  =			"detr.model." if is_panoptic else "model."
				for key in state_dict.copy().keys():
								if is_panoptic:
												if (
												    key.startswith("detr"   )
												    and not key.startswith("class_labels_classifier"   )
												    and not key.startswith("bbox_predictor"   )
												):
																_A					  =			state_dict.pop(__lowercase   )
																_A					  =			val
												elif "class_labels_classifier" in key or "bbox_predictor" in key:
																_A					  =			state_dict.pop(__lowercase   )
																_A					  =			val
												elif key.startswith("bbox_attention"   ) or key.startswith("mask_head"   ):
																continue
												else:
																_A					  =			state_dict.pop(__lowercase   )
																_A					  =			val
								else:
												if not key.startswith("class_labels_classifier"   ) and not key.startswith("bbox_predictor"   ):
																_A					  =			state_dict.pop(__lowercase   )
																_A					  =			val

    # finally, create HuggingFace model and load state dict
				_A					  =			DetrForSegmentation(__lowercase   ) if is_panoptic else DetrForObjectDetection(__lowercase   )
				model.load_state_dict(__lowercase   )
				model.eval()

				# verify our conversion on an image
				_A					  =			"coco_panoptic" if is_panoptic else "coco_detection"
				_A					  =			DetrImageProcessor(format=__lowercase   )

				_A					  =			processor(images=prepare_img()     ,			return_tensors="pt"   )
				_A					  =			encoding["pixel_values"]

				_A					  =			detr(__lowercase   )
				_A					  =			model(__lowercase   )

				assert torch.allclose(outputs.logits     ,			original_outputs["pred_logits"]     ,			atol=1E-3   )
				assert torch.allclose(outputs.pred_boxes     ,			original_outputs["pred_boxes"]     ,			atol=1E-3   )
				if is_panoptic:
								assert torch.allclose(outputs.pred_masks     ,			original_outputs["pred_masks"]     ,			atol=1E-4   )
				print("Looks ok!"   )

				if pytorch_dump_folder_path is not None:
								# Save model and image processor
								logger.info(f"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""   )
								Path(__lowercase   ).mkdir(exist_ok=__lowercase   )
								model.save_pretrained(__lowercase   )
								processor.save_pretrained(__lowercase   )

				if push_to_hub:
								# Upload model and image processor to the hub
								logger.info("Uploading PyTorch model and image processor to the hub..."   )
								model.push_to_hub(f"""nielsr/{model_name}"""   )
								processor.push_to_hub(f"""nielsr/{model_name}"""   )


if __name__ == "__main__":
		a_       							=    argparse.ArgumentParser()

		parser.add_argument(
		    "--model_name",
		    default="detr-resnet-50",
		    type=str,
		    choices=["detr-resnet-50", "detr-resnet-101"],
		    help="Name of the DETR 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 to push the model to the hub or not.")
		a_       							=    parser.parse_args()
		convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



"""simple docstring"""


from __future__ import annotations






def      a__ (				__lowercase     ,			__lowercase   )	->	float:
				_A					  =			sorted(numsa + numsa   )
				_A  ,		_A					  =			divmod(len(__lowercase   )     ,			2   )
				if mod == 1:
								return all_numbers[div]
				else:
								return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		a_       							=    [float(x) for x in input("Enter the elements of first array: ").split()]
		a_       							=    [float(x) for x in input("Enter the elements of second array: ").split()]
		print(f'''The median of two arrays is: {median_of_two_arrays(array_a, array_a)}''')