




import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


UpperCAmelCase_						={
    """iou_prediction_head.layers.0""": """iou_prediction_head.proj_in""",
    """iou_prediction_head.layers.1""": """iou_prediction_head.layers.0""",
    """iou_prediction_head.layers.2""": """iou_prediction_head.proj_out""",
    """mask_decoder.output_upscaling.0""": """mask_decoder.upscale_conv1""",
    """mask_decoder.output_upscaling.1""": """mask_decoder.upscale_layer_norm""",
    """mask_decoder.output_upscaling.3""": """mask_decoder.upscale_conv2""",
    """mask_downscaling.0""": """mask_embed.conv1""",
    """mask_downscaling.1""": """mask_embed.layer_norm1""",
    """mask_downscaling.3""": """mask_embed.conv2""",
    """mask_downscaling.4""": """mask_embed.layer_norm2""",
    """mask_downscaling.6""": """mask_embed.conv3""",
    """point_embeddings""": """point_embed""",
    """pe_layer.positional_encoding_gaussian_matrix""": """shared_embedding.positional_embedding""",
    """image_encoder""": """vision_encoder""",
    """neck.0""": """neck.conv1""",
    """neck.1""": """neck.layer_norm1""",
    """neck.2""": """neck.conv2""",
    """neck.3""": """neck.layer_norm2""",
    """patch_embed.proj""": """patch_embed.projection""",
    """.norm""": """.layer_norm""",
    """blocks""": """layers""",
}



def       UpperCAmelCase       (     _snake_case							):
							lowerCAmelCase   =		{}
							state_dict.pop('''pixel_mean'''						, _snake_case							)
							state_dict.pop('''pixel_std'''						, _snake_case							)

							lowerCAmelCase   =		R'''.*.output_hypernetworks_mlps.(\d+).layers.(\d+).*'''

							for key, value in state_dict.items():
														for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
																					if key_to_modify in key:
																												lowerCAmelCase   =		key.replace(_snake_case						, _snake_case							)

														if re.match(_snake_case						, _snake_case							):
																					lowerCAmelCase   =		int(re.match(_snake_case						, _snake_case							).group(2							)							)
																					if layer_nb == 0:
																												lowerCAmelCase   =		key.replace('''layers.0'''						, '''proj_in'''							)
																					elif layer_nb == 1:
																												lowerCAmelCase   =		key.replace('''layers.1'''						, '''layers.0'''							)
																					elif layer_nb == 2:
																												lowerCAmelCase   =		key.replace('''layers.2'''						, '''proj_out'''							)

														lowerCAmelCase   =		value

							lowerCAmelCase   =		model_state_dict[
							    '''prompt_encoder.shared_embedding.positional_embedding'''
							]

							return model_state_dict



def       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case						, _snake_case="ybelkada/segment-anything"							):
							lowerCAmelCase   =		hf_hub_download(_snake_case						, F"""checkpoints/{model_name}.pth"""							)

							if "sam_vit_b" in model_name:
														lowerCAmelCase   =		SamConfig()
							elif "sam_vit_l" in model_name:
														lowerCAmelCase   =		SamVisionConfig(
														    hidden_size=1024						, num_hidden_layers=24						, num_attention_heads=16						, global_attn_indexes=[5, 11, 17, 23]						, )

														lowerCAmelCase   =		SamConfig(
														    vision_config=_snake_case						, )
							elif "sam_vit_h" in model_name:
														lowerCAmelCase   =		SamVisionConfig(
														    hidden_size=1280						, num_hidden_layers=32						, num_attention_heads=16						, global_attn_indexes=[7, 15, 23, 31]						, )

														lowerCAmelCase   =		SamConfig(
														    vision_config=_snake_case						, )

							lowerCAmelCase   =		torch.load(_snake_case						, map_location='''cpu'''							)
							lowerCAmelCase   =		replace_keys(_snake_case							)

							lowerCAmelCase   =		SamImageProcessor()

							lowerCAmelCase   =		SamProcessor(image_processor=_snake_case							)
							lowerCAmelCase   =		SamModel(_snake_case							)

							hf_model.load_state_dict(_snake_case							)
							lowerCAmelCase   =		hf_model.to('''cuda'''							)

							lowerCAmelCase   =		'''https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png'''
							lowerCAmelCase   =		Image.open(requests.get(_snake_case						, stream=_snake_case							).raw							).convert('''RGB'''							)

							lowerCAmelCase   =		[[[400, 650]]]
							lowerCAmelCase   =		[[1]]

							lowerCAmelCase   =		processor(images=np.array(_snake_case							)						, return_tensors='''pt'''							).to('''cuda'''							)

							with torch.no_grad():
														lowerCAmelCase   =		hf_model(**_snake_case							)
							lowerCAmelCase   =		output.iou_scores.squeeze()

							if model_name == "sam_vit_h_4b8939":
														assert scores[-1].item() == 0.579890251159668

														lowerCAmelCase   =		processor(
														    images=np.array(_snake_case							)						, input_points=_snake_case						, input_labels=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9712603092193604

														lowerCAmelCase   =		((75, 275, 1725, 850),)

														lowerCAmelCase   =		processor(images=np.array(_snake_case							)						, input_boxes=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.8686015605926514

														# Test with 2 points and 1 image.
														lowerCAmelCase   =		[[[400, 650], [800, 650]]]
														lowerCAmelCase   =		[[1, 1]]

														lowerCAmelCase   =		processor(
														    images=np.array(_snake_case							)						, input_points=_snake_case						, input_labels=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9936047792434692


if __name__ == "__main__":
					UpperCAmelCase_						=argparse.ArgumentParser()
					UpperCAmelCase_						=["""sam_vit_b_01ec64""", """sam_vit_h_4b8939""", """sam_vit_l_0b3195"""]
					parser.add_argument(
					    """--model_name""",
					    default="""sam_vit_h_4b8939""",
					    choices=choices,
					    type=str,
					    help="""Path to hf config.json of model to convert""",
					)
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument(
					    """--push_to_hub""",
					    action="""store_true""",
					    help="""Whether to push the model and processor to the hub after converting""",
					)
					parser.add_argument(
					    """--model_hub_id""",
					    default="""ybelkada/segment-anything""",
					    choices=choices,
					    type=str,
					    help="""Path to hf config.json of model to convert""",
					)

					UpperCAmelCase_						=parser.parse_args()

					convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)









import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute



def       UpperCAmelCase       (     _snake_case = 3							):
							if isinstance(_snake_case						, _snake_case							):
														raise TypeError('''number of qubits must be a integer.'''							)
							if number_of_qubits <= 0:
														raise ValueError('''number of qubits must be > 0.'''							)
							if math.floor(_snake_case							) != number_of_qubits:
														raise ValueError('''number of qubits must be exact integer.'''							)
							if number_of_qubits > 10:
														raise ValueError('''number of qubits too large to simulate(>10).'''							)

							lowerCAmelCase   =		QuantumRegister(_snake_case						, '''qr'''							)
							lowerCAmelCase   =		ClassicalRegister(_snake_case						, '''cr'''							)

							lowerCAmelCase   =		QuantumCircuit(_snake_case						, _snake_case							)

							lowerCAmelCase   =		number_of_qubits

							for i in range(_snake_case							):
														quantum_circuit.h(number_of_qubits - i - 1							)
														counter -= 1
														for j in range(_snake_case							):
																					quantum_circuit.cp(np.pi / 2 ** (counter - j)						, _snake_case						, _snake_case							)

							for k in range(number_of_qubits // 2							):
														quantum_circuit.swap(_snake_case						, number_of_qubits - k - 1							)

							# measure all the qubits
							quantum_circuit.measure(_snake_case						, _snake_case							)
							# simulate with 10000 shots
							lowerCAmelCase   =		Aer.get_backend('''qasm_simulator'''							)
							lowerCAmelCase   =		execute(_snake_case						, _snake_case						, shots=10000							)

							return job.result().get_counts(_snake_case							)


if __name__ == "__main__":
		print(
		    F'''Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}'''
		)



