



import argparse
import json

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

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		Dict=False	):





			"""simple docstring"""




			UpperCamelCase         =					[]
			for i in range(config.num_hidden_layers	):
						# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
						rename_keys.append((f'module.blocks.{i}.norm1.weight', f'vit.encoder.layer.{i}.layernorm_before.weight')	)
						rename_keys.append((f'module.blocks.{i}.norm1.bias', f'vit.encoder.layer.{i}.layernorm_before.bias')	)
						rename_keys.append(
						    (f'module.blocks.{i}.attn.proj.weight', f'vit.encoder.layer.{i}.attention.output.dense.weight')	)
						rename_keys.append((f'module.blocks.{i}.attn.proj.bias', f'vit.encoder.layer.{i}.attention.output.dense.bias')	)
						rename_keys.append((f'module.blocks.{i}.norm2.weight', f'vit.encoder.layer.{i}.layernorm_after.weight')	)
						rename_keys.append((f'module.blocks.{i}.norm2.bias', f'vit.encoder.layer.{i}.layernorm_after.bias')	)
						rename_keys.append((f'module.blocks.{i}.mlp.fc1.weight', f'vit.encoder.layer.{i}.intermediate.dense.weight')	)
						rename_keys.append((f'module.blocks.{i}.mlp.fc1.bias', f'vit.encoder.layer.{i}.intermediate.dense.bias')	)
						rename_keys.append((f'module.blocks.{i}.mlp.fc2.weight', f'vit.encoder.layer.{i}.output.dense.weight')	)
						rename_keys.append((f'module.blocks.{i}.mlp.fc2.bias', f'vit.encoder.layer.{i}.output.dense.bias')	)

			# projection layer + position embeddings
			rename_keys.extend(
			    [
			        ("""module.cls_token""", """vit.embeddings.cls_token"""),
			        ("""module.patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""),
			        ("""module.patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""),
			        ("""module.pos_embed""", """vit.embeddings.position_embeddings"""),
			    ]	)

			if base_model:
						# layernorm + pooler
						rename_keys.extend(
						    [
						        ("""module.norm.weight""", """layernorm.weight"""),
						        ("""module.norm.bias""", """layernorm.bias"""),
						    ]	)

						# if just the base model, we should remove "vit" from all keys that start with "vit"
						UpperCamelCase         =					[(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""	) else pair for pair in rename_keys]
			else:
						# layernorm + classification head
						rename_keys.extend(
						    [
						        ("""norm.weight""", """vit.layernorm.weight"""),
						        ("""norm.bias""", """vit.layernorm.bias"""),
						        ("""head.weight""", """classifier.weight"""),
						        ("""head.bias""", """classifier.bias"""),
						    ]	)

			return rename_keys






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Union[str, Any]       ,  SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		List[str]=False	):





			"""simple docstring"""




			for i in range(config.num_hidden_layers	):
						if base_model:
									UpperCamelCase         =					""
						else:
									UpperCamelCase         =					"vit."
						# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
						UpperCamelCase         =					state_dict.pop(f'module.blocks.{i}.attn.qkv.weight'	)
						UpperCamelCase         =					state_dict.pop(f'module.blocks.{i}.attn.qkv.bias'	)
						# next, add query, keys and values (in that order) to the state dict
						UpperCamelCase         =					in_proj_weight[
						    : config.hidden_size, :
						]
						UpperCamelCase         =					in_proj_bias[: config.hidden_size]
						UpperCamelCase         =					in_proj_weight[
						    config.hidden_size : config.hidden_size * 2, :
						]
						UpperCamelCase         =					in_proj_bias[
						    config.hidden_size : config.hidden_size * 2
						]
						UpperCamelCase         =					in_proj_weight[
						    -config.hidden_size :, :
						]
						UpperCamelCase         =					in_proj_bias[-config.hidden_size :]






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]	):





			"""simple docstring"""




			UpperCamelCase         =					["head.weight", "head.bias"]
			for k in ignore_keys:
						state_dict.pop(_lowerCamelCase       ,  _lowerCamelCase	)






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str	):





			"""simple docstring"""




			UpperCamelCase         =					[
			    "module.fc.fc1.weight",
			    "module.fc.fc1.bias",
			    "module.fc.bn1.weight",
			    "module.fc.bn1.bias",
			    "module.fc.bn1.running_mean",
			    "module.fc.bn1.running_var",
			    "module.fc.bn1.num_batches_tracked",
			    "module.fc.fc2.weight",
			    "module.fc.fc2.bias",
			    "module.fc.bn2.weight",
			    "module.fc.bn2.bias",
			    "module.fc.bn2.running_mean",
			    "module.fc.bn2.running_var",
			    "module.fc.bn2.num_batches_tracked",
			    "module.fc.fc3.weight",
			    "module.fc.fc3.bias",
			]
			for k in ignore_keys:
						state_dict.pop(_lowerCamelCase       ,  _lowerCamelCase	)






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]       ,  SCREAMING_SNAKE_CASE_   :		List[str]       ,  SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					dct.pop(_lowerCamelCase	)
			UpperCamelCase         =					val






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]       ,  SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			UpperCamelCase         =					ViTMSNConfig()
			UpperCamelCase         =					1_000

			UpperCamelCase         =					"datasets/huggingface/label-files"
			UpperCamelCase         =					"imagenet-1k-id2label.json"
			UpperCamelCase         =					json.load(open(hf_hub_download(_lowerCamelCase       ,  _lowerCamelCase	)       ,  """r"""	)	)
			UpperCamelCase         =					{int(_lowerCamelCase	): v for k, v in idalabel.items()}
			UpperCamelCase         =					idalabel
			UpperCamelCase         =					{v: k for k, v in idalabel.items()}

			if "s16" in checkpoint_url:
						UpperCamelCase         =					384
						UpperCamelCase         =					1_536
						UpperCamelCase         =					6
			elif "l16" in checkpoint_url:
						UpperCamelCase         =					1_024
						UpperCamelCase         =					4_096
						UpperCamelCase         =					24
						UpperCamelCase         =					16
						UpperCamelCase         =					0.1
			elif "b4" in checkpoint_url:
						UpperCamelCase         =					4
			elif "l7" in checkpoint_url:
						UpperCamelCase         =					7
						UpperCamelCase         =					1_024
						UpperCamelCase         =					4_096
						UpperCamelCase         =					24
						UpperCamelCase         =					16
						UpperCamelCase         =					0.1

			UpperCamelCase         =					ViTMSNModel(_lowerCamelCase	)

			UpperCamelCase         =					torch.hub.load_state_dict_from_url(_lowerCamelCase       ,  map_location="""cpu"""	)["target_encoder"]

			UpperCamelCase         =					ViTImageProcessor(size=config.image_size	)

			remove_projection_head(_lowerCamelCase	)
			UpperCamelCase         =					create_rename_keys(_lowerCamelCase       ,  base_model=_lowerCamelCase	)

			for src, dest in rename_keys:
						rename_key(_lowerCamelCase       ,  _lowerCamelCase       ,  _lowerCamelCase	)
			read_in_q_k_v(_lowerCamelCase       ,  _lowerCamelCase       ,  base_model=_lowerCamelCase	)

			model.load_state_dict(_lowerCamelCase	)
			model.eval()

			UpperCamelCase         =					"http://images.cocodataset.org/val2017/000000039769.jpg"

			UpperCamelCase         =					Image.open(requests.get(_lowerCamelCase       ,  stream=_lowerCamelCase	).raw	)
			UpperCamelCase         =					ViTImageProcessor(
			    size=config.image_size       ,  image_mean=_lowerCamelCase       ,  image_std=_lowerCamelCase	)
			UpperCamelCase         =					image_processor(images=_lowerCamelCase       ,  return_tensors="""pt"""	)

			# forward pass
			torch.manual_seed(2	)
			UpperCamelCase         =					model(**_lowerCamelCase	)
			UpperCamelCase         =					outputs.last_hidden_state

			# The following Colab Notebook was used to generate these outputs:
			# https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
			if "s16" in checkpoint_url:
						UpperCamelCase         =					torch.tensor([[-1.0915, -1.4876, -1.1809]]	)
			elif "b16" in checkpoint_url:
						UpperCamelCase         =					torch.tensor([[14.2_889, -18.9_045, 11.7_281]]	)
			elif "l16" in checkpoint_url:
						UpperCamelCase         =					torch.tensor([[41.5_028, -22.8_681, 45.6_475]]	)
			elif "b4" in checkpoint_url:
						UpperCamelCase         =					torch.tensor([[-4.3868, 5.2932, -0.4137]]	)
			else:
						UpperCamelCase         =					torch.tensor([[-0.1792, -0.6465, 2.4263]]	)

			# verify logits
			assert torch.allclose(last_hidden_state[:, 0, :3]       ,  _lowerCamelCase       ,  atol=1e-4	)

			print(f'Saving model to {pytorch_dump_folder_path}'	)
			model.save_pretrained(_lowerCamelCase	)

			print(f'Saving image processor to {pytorch_dump_folder_path}'	)
			image_processor.save_pretrained(_lowerCamelCase	)


if __name__ == "__main__":
			__snake_case            =   argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--checkpoint_url",
			    default="https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar",
			    type=str,
			    help="URL of the checkpoint you'd like to convert.",
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
			)

			__snake_case            =   parser.parse_args()
			convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








import qiskit






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int = 2	):





			"""simple docstring"""




			UpperCamelCase         =					qubits

			# Using Aer's simulator
			UpperCamelCase         =					qiskit.Aer.get_backend("""aer_simulator"""	)

			# Creating a Quantum Circuit acting on the q register
			UpperCamelCase         =					qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE_       ,  SCREAMING_SNAKE_CASE_	)

			# Adding a H gate on qubit 0 (now q0 in superposition)
			circuit.h(0	)

			for i in range(1       ,  SCREAMING_SNAKE_CASE_	):
						# Adding CX (CNOT) gate
						circuit.cx(i - 1       ,  SCREAMING_SNAKE_CASE_	)

			# Mapping the quantum measurement to the classical bits
			circuit.measure(list(range(SCREAMING_SNAKE_CASE_	)	)       ,  list(range(SCREAMING_SNAKE_CASE_	)	)	)

			# Now measuring any one qubit would affect other qubits to collapse
			# their super position and have same state as the measured one.

			# Executing the circuit on the simulator
			UpperCamelCase         =					qiskit.execute(SCREAMING_SNAKE_CASE_       ,  SCREAMING_SNAKE_CASE_       ,  shots=1_000	)

			return job.result().get_counts(SCREAMING_SNAKE_CASE_	)


if __name__ == "__main__":
			print(F'''Total count for various states are: {quantum_entanglement(3)}''')




