




'''simple docstring'''





import argparse
import json
from collections import OrderedDict
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
from transformers.utils import logging


logging.set_verbosity_info()
_SCREAMING_SNAKE_CASE							:     Any   	=				logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
_SCREAMING_SNAKE_CASE							:     Union[str, Any]   	=				[]
for i in range(6):
		# 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"),
    ]
)


def   UpperCamelCase_(			snake_case							: List[Any]							,       snake_case							: List[str]							,       snake_case							: Dict  ):

							'''simple docstring'''






							snake_case_			      =   state_dict.pop(snake_case  )
							snake_case_			      =   val


def   UpperCamelCase_(			snake_case							: Any  ):

							'''simple docstring'''






							snake_case_			      =   OrderedDict()
							for key, value in state_dict.items():
														if "backbone.0.body" in key:
																					snake_case_			      =   key.replace("backbone.0.body"							,       "backbone.conv_encoder.model"  )
																					snake_case_			      =   value
														else:
																					snake_case_			      =   value

							return new_state_dict


def   UpperCamelCase_(			snake_case							: Union[str, Any]							,       snake_case							: Dict=False  ):

							'''simple docstring'''






							snake_case_			      =   ""
							if is_panoptic:
														snake_case_			      =   "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)
														snake_case_			      =   state_dict.pop(f'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'  )
														snake_case_			      =   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
														snake_case_			      =   in_proj_weight[:2_5_6, :]
														snake_case_			      =   in_proj_bias[:2_5_6]
														snake_case_			      =   in_proj_weight[2_5_6:5_1_2, :]
														snake_case_			      =   in_proj_bias[2_5_6:5_1_2]
														snake_case_			      =   in_proj_weight[-2_5_6:, :]
														snake_case_			      =   in_proj_bias[-2_5_6:]
							# 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
														snake_case_			      =   state_dict.pop(f'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'  )
														snake_case_			      =   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
														snake_case_			      =   in_proj_weight[:2_5_6, :]
														snake_case_			      =   in_proj_bias[:2_5_6]
														snake_case_			      =   in_proj_weight[2_5_6:5_1_2, :]
														snake_case_			      =   in_proj_bias[2_5_6:5_1_2]
														snake_case_			      =   in_proj_weight[-2_5_6:, :]
														snake_case_			      =   in_proj_bias[-2_5_6:]
														# read in weights + bias of input projection layer of cross-attention
														snake_case_			      =   state_dict.pop(
														    f'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'  )
														snake_case_			      =   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
														snake_case_			      =   in_proj_weight_cross_attn[:2_5_6, :]
														snake_case_			      =   in_proj_bias_cross_attn[:2_5_6]
														snake_case_			      =   in_proj_weight_cross_attn[2_5_6:5_1_2, :]
														snake_case_			      =   in_proj_bias_cross_attn[2_5_6:5_1_2]
														snake_case_			      =   in_proj_weight_cross_attn[-2_5_6:, :]
														snake_case_			      =   in_proj_bias_cross_attn[-2_5_6:]


def   UpperCamelCase_(			):

							'''simple docstring'''






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

							return im


@torch.no_grad()
def   UpperCamelCase_(			snake_case							: List[Any]							,       snake_case							: Optional[Any]  ):

							'''simple docstring'''






							snake_case_			      =   DetrConfig()
							# set backbone and dilation attributes
							if "resnet101" in model_name:
														snake_case_			      =   "resnet101"
							if "dc5" in model_name:
														snake_case_			      =   True
							snake_case_			      =   "panoptic" in model_name
							if is_panoptic:
														snake_case_			      =   2_5_0
							else:
														snake_case_			      =   9_1
														snake_case_			      =   "huggingface/label-files"
														snake_case_			      =   "coco-detection-id2label.json"
														snake_case_			      =   json.load(open(hf_hub_download(snake_case							,       snake_case							,       repo_type="dataset"  )							,       "r"  )  )
														snake_case_			      =   {int(snake_case  ): v for k, v in idalabel.items()}
														snake_case_			      =   idalabel
														snake_case_			      =   {v: k for k, v in idalabel.items()}

							# load image processor
							snake_case_			      =   "coco_panoptic" if is_panoptic else "coco_detection"
							snake_case_			      =   DetrImageProcessor(format=snake_case  )

							# prepare image
							snake_case_			      =   prepare_img()
							snake_case_			      =   image_processor(images=snake_case							,       return_tensors="pt"  )
							snake_case_			      =   encoding["pixel_values"]

							logger.info(f'Converting model {model_name}...'  )

							# load original model from torch hub
							snake_case_			      =   torch.hub.load("facebookresearch/detr"							,       snake_case							,       pretrained=snake_case  ).eval()
							snake_case_			      =   detr.state_dict()
							# rename keys
							for src, dest in rename_keys:
														if is_panoptic:
																					snake_case_			      =   "detr." + src
														rename_key(snake_case							,       snake_case							,       snake_case  )
							snake_case_			      =   rename_backbone_keys(snake_case  )
							# query, key and value matrices need special treatment
							read_in_q_k_v(snake_case							,       is_panoptic=snake_case  )
							# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
							snake_case_			      =   "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"  )
																					):
																												snake_case_			      =   state_dict.pop(snake_case  )
																												snake_case_			      =   val
																					elif "class_labels_classifier" in key or "bbox_predictor" in key:
																												snake_case_			      =   state_dict.pop(snake_case  )
																												snake_case_			      =   val
																					elif key.startswith("bbox_attention"  ) or key.startswith("mask_head"  ):
																												continue
																					else:
																												snake_case_			      =   state_dict.pop(snake_case  )
																												snake_case_			      =   val
														else:
																					if not key.startswith("class_labels_classifier"  ) and not key.startswith("bbox_predictor"  ):
																												snake_case_			      =   state_dict.pop(snake_case  )
																												snake_case_			      =   val
    # finally, create HuggingFace model and load state dict
							snake_case_			      =   DetrForSegmentation(snake_case  ) if is_panoptic else DetrForObjectDetection(snake_case  )
							model.load_state_dict(snake_case  )
							model.eval()
							# verify our conversion
							snake_case_			      =   detr(snake_case  )
							snake_case_			      =   model(snake_case  )
							assert torch.allclose(outputs.logits							,       original_outputs["pred_logits"]							,       atol=1e-4  )
							assert torch.allclose(outputs.pred_boxes							,       original_outputs["pred_boxes"]							,       atol=1e-4  )
							if is_panoptic:
														assert torch.allclose(outputs.pred_masks							,       original_outputs["pred_masks"]							,       atol=1e-4  )

							# Save model and image processor
							logger.info(f'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'  )
							Path(snake_case  ).mkdir(exist_ok=snake_case  )
							model.save_pretrained(snake_case  )
							image_processor.save_pretrained(snake_case  )


if __name__ == "__main__":
		_SCREAMING_SNAKE_CASE							:     Tuple   	=				argparse.ArgumentParser()

		parser.add_argument(
		    "--model_name", default="detr_resnet50", type=str, 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."
		)
		_SCREAMING_SNAKE_CASE							:     Optional[int]   	=				parser.parse_args()
		convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)










'''simple docstring'''





import qiskit
from qiskit.providers import Backend


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: int  ):

							'''simple docstring'''






							snake_case_      ,   snake_case_			      =   bin(snake_case  )[2:], bin(snake_case  )[2:]  # Remove leading '0b'

							# Ensure that both strings are of the same length
							if len(snake_case  ) > len(snake_case  ):
														snake_case_			      =   y.zfill(len(snake_case  )  )
							else:
														snake_case_			      =   x.zfill(len(snake_case  )  )

							# We need (3 * number of bits in the larger number)+1 qBits
							# The second parameter is the number of classical registers, to measure the result
							snake_case_			      =   qiskit.QuantumCircuit((len(snake_case  ) * 3) + 1							,       len(snake_case  ) + 1  )

							# We are essentially "not-ing" the bits that are 1
							# Reversed because it's easier to perform ops on more significant bits
							for i in range(len(snake_case  )  ):
														if x[::-1][i] == "1":
																					circuit.x(snake_case  )
							for j in range(len(snake_case  )  ):
														if y[::-1][j] == "1":
																					circuit.x(len(snake_case  ) + j  )

							return circuit, x, y


def   UpperCamelCase_(			snake_case							: qiskit.QuantumCircuit							,       snake_case							: int							,       snake_case							: int							,       snake_case							: int							,       snake_case							: int							,       ):

							'''simple docstring'''






							circuit.ccx(snake_case							,       snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )
							circuit.ccx(snake_case							,       snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: int							,       snake_case							: Backend = qiskit.Aer.get_backend("aer_simulator"  )							,       ):

							'''simple docstring'''






							if vala < 0 or vala < 0:
														raise ValueError("Both Integers must be positive!"  )

							# Store the Integers
							snake_case_      ,   snake_case_      ,   snake_case_			      =   store_two_classics(snake_case							,       snake_case  )
							for i in range(len(snake_case  )  ):
														full_adder(snake_case							,       snake_case							,       len(snake_case  ) + i							,       len(snake_case  ) + len(snake_case  ) + i							,       len(snake_case  ) + len(snake_case  ) + i + 1  )
														circuit.barrier()  # Optional, just for aesthetics

							# Measure the resultant qBits
							for i in range(len(snake_case  ) + 1  ):
														circuit.measure([(len(snake_case  ) * 2) + i]							,       [i]  )

							snake_case_			      =   qiskit.execute(snake_case							,       snake_case							,       shots=1  ).result()

							# The result is in binary. Convert it back to int
							return int(list(res.get_counts()  )[0]							,       2  )


if __name__ == "__main__":
		import doctest

		doctest.testmod()




