





"""simple docstring"""




import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


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






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Dict					, _lowercase		:					Optional[Any]=False      )				->Union[str, Any]:






	'''simple docstring'''






	a   :	Any			=       []

	# fmt: off
	# stem:
	rename_keys.append(("cls_token", "vit.embeddings.cls_token")      )
	rename_keys.append(("pos_embed", "vit.embeddings.position_embeddings")      )

	rename_keys.append(("patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight")      )
	rename_keys.append(("patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias")      )

	# backbone
	rename_keys.append(("patch_embed.backbone.stem.conv.weight", "vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight")      )
	rename_keys.append(("patch_embed.backbone.stem.norm.weight", "vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight")      )
	rename_keys.append(("patch_embed.backbone.stem.norm.bias", "vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias")      )

	for stage_idx in range(len(config.backbone_config.depths      )      ):
		for layer_idx in range(config.backbone_config.depths[stage_idx]      ):
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight""")      )
			rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias""")      )

		rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight""")      )
		rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight""")      )
		rename_keys.append((F"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias""", F"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias""")      )

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

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

		# if just the base model, we should remove "vit" from all keys that start with "vit"
		a   :	str			=       [(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"),
		    ]      )
	# fmt: on

	return rename_keys






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					List[str]					, _lowercase		:					Union[str, Any]					, _lowercase		:					Any=False      )				->Dict:






	'''simple docstring'''






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






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Optional[Any]      )				->Tuple:






	'''simple docstring'''






	a   :	str			=       ["head.weight", "head.bias"]
	for k in ignore_keys:
		state_dict.pop(_lowerCAmelCase					, _lowerCAmelCase      )






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Union[str, Any]					, _lowercase		:					List[Any]					, _lowercase		:					List[Any]      )				->Any:






	'''simple docstring'''






	a   :	Any			=       dct.pop(_lowerCAmelCase      )
	a   :	Union[str, Any]			=       val






def    _SCREAMING_SNAKE_CASE	(			)				->Any:






	'''simple docstring'''






	a   :	Optional[int]			=       "http://images.cocodataset.org/val2017/000000039769.jpg"
	a   :	str			=       Image.open(requests.get(_lowerCAmelCase					, stream=_lowerCAmelCase      ).raw      )
	return im






@torch.no_grad()
def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Any					, _lowercase		:					Any					, _lowercase		:					List[str]=False      )				->List[str]:






	'''simple docstring'''






	a   :	Any			=       BitConfig(
	    global_padding="same"					, layer_type="bottleneck"					, depths=(3, 4, 9)					, out_features=["stage3"]					, embedding_dynamic_padding=_lowerCAmelCase					, )
	a   :	List[Any]			=       ViTHybridConfig(backbone_config=_lowerCAmelCase					, image_size=384					, num_labels=1000      )
	a   :	Tuple			=       False

	# load original model from timm
	a   :	int			=       timm.create_model(_lowerCAmelCase					, pretrained=_lowerCAmelCase      )
	timm_model.eval()

	# load state_dict of original model, remove and rename some keys
	a   :	Optional[Any]			=       timm_model.state_dict()
	if base_model:
		remove_classification_head_(_lowerCAmelCase      )
	a   :	Any			=       create_rename_keys(_lowerCAmelCase					, _lowerCAmelCase      )
	for src, dest in rename_keys:
		rename_key(_lowerCAmelCase					, _lowerCAmelCase					, _lowerCAmelCase      )
	read_in_q_k_v(_lowerCAmelCase					, _lowerCAmelCase					, _lowerCAmelCase      )

	a   :	Union[str, Any]			=       "huggingface/label-files"
	a   :	List[str]			=       "imagenet-1k-id2label.json"
	a   :	int			=       json.load(open(hf_hub_download(_lowerCAmelCase					, _lowerCAmelCase					, repo_type="dataset"      )					, "r"      )      )
	a   :	List[Any]			=       {int(_lowerCAmelCase      ): v for k, v in idalabel.items()}
	a   :	Tuple			=       idalabel
	a   :	Optional[Any]			=       {v: k for k, v in idalabel.items()}

	# load HuggingFace model
	if vit_name[-5:] == "in21k":
		a   :	Optional[int]			=       ViTHybridModel(_lowerCAmelCase      ).eval()
	else:
		a   :	Any			=       ViTHybridForImageClassification(_lowerCAmelCase      ).eval()
	model.load_state_dict(_lowerCAmelCase      )

	# create image processor
	a   :	Dict			=       create_transform(**resolve_data_config({}					, model=_lowerCAmelCase      )      )
	a   :	Union[str, Any]			=       transform.transforms

	a   :	List[Any]			=       {
	    "bilinear": PILImageResampling.BILINEAR,
	    "bicubic": PILImageResampling.BICUBIC,
	    "nearest": PILImageResampling.NEAREST,
	}

	a   :	Tuple			=       ViTHybridImageProcessor(
	    do_resize=_lowerCAmelCase					, size={"shortest_edge": timm_transforms[0].size}					, resample=pillow_resamplings[timm_transforms[0].interpolation.value]					, do_center_crop=_lowerCAmelCase					, crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]}					, do_normalize=_lowerCAmelCase					, image_mean=timm_transforms[-1].mean.tolist()					, image_std=timm_transforms[-1].std.tolist()					, )

	a   :	Tuple			=       prepare_img()
	a   :	Dict			=       transform(_lowerCAmelCase      ).unsqueeze(0      )
	a   :	Tuple			=       processor(_lowerCAmelCase					, return_tensors="pt"      ).pixel_values

	# verify pixel values
	assert torch.allclose(_lowerCAmelCase					, _lowerCAmelCase      )

	# verify logits
	with torch.no_grad():
		a   :	Optional[Any]			=       model(_lowerCAmelCase      )
		a   :	str			=       outputs.logits

	print("Predicted class:"					, logits.argmax(-1      ).item()      )
	if base_model:
		a   :	Union[str, Any]			=       timm_model.forward_features(_lowerCAmelCase      )
		assert timm_pooled_output.shape == outputs.pooler_output.shape
		assert torch.allclose(_lowerCAmelCase					, outputs.pooler_output					, atol=1E-3      )
	else:
		a   :	List[str]			=       timm_model(_lowerCAmelCase      )
		assert timm_logits.shape == outputs.logits.shape
		assert torch.allclose(_lowerCAmelCase					, outputs.logits					, atol=1E-3      )
	print("Looks ok!"      )

	if pytorch_dump_folder_path is not None:
		Path(_lowerCAmelCase      ).mkdir(exist_ok=_lowerCAmelCase      )
		print(F"""Saving model {vit_name} to {pytorch_dump_folder_path}"""      )
		model.save_pretrained(_lowerCAmelCase      )
		print(F"""Saving processor to {pytorch_dump_folder_path}"""      )
		processor.save_pretrained(_lowerCAmelCase      )

	if push_to_hub:
		print(F"""Pushing model and processor to the hub {vit_name}"""      )
		model.push_to_hub(F"""ybelkada/{vit_name}"""      )
		processor.push_to_hub(F"""ybelkada/{vit_name}"""      )


if __name__ == "__main__":
		a		:				int  			=    argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--vit_name''',
		    default='''vit_base_r50_s16_384''',
		    type=str,
		    help='''Name of the hybrid ViT timm model you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
		)
		parser.add_argument(
		    '''--push_to_hub''', action='''store_true''', help='''Whether to upload the model to the HuggingFace hub.'''
		)

		a		:				Union[str, Any]  			=    parser.parse_args()
		convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)









"""simple docstring"""




import qiskit






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int					, _lowercase		:					int      )				->qiskit.result.counts.Counts:






	'''simple docstring'''






	a   :	Union[str, Any]			=       qiskit.Aer.get_backend("aer_simulator"      )

	# Create a Quantum Circuit acting on the q register
	a   :	Optional[Any]			=       qiskit.QuantumCircuit(_lowercase					, _lowercase      )

	# Map the quantum measurement to the classical bits
	circuit.measure([0]					, [0]      )

	# Execute the circuit on the simulator
	a   :	Optional[int]			=       qiskit.execute(_lowercase					, _lowercase					, shots=1000      )

	# Return the histogram data of the results of the experiment.
	return job.result().get_counts(_lowercase      )


if __name__ == "__main__":
		print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')


