
"""simple docstring"""





import qiskit
def 				A_  (__a					, __a					):

					'''simple docstring'''





					A_								=    qiskit.Aer.get_backend("aer_simulator"					)

					# Create a Quantum Circuit acting on the q register
					A_								=    qiskit.QuantumCircuit(UpperCamelCase_					, UpperCamelCase_					)

					# Apply X (NOT) Gate to Qubits 0 & 1
					circuit.x(0					)
					circuit.x(1					)

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

					# Execute the circuit on the qasm simulator
					A_								=    qiskit.execute(UpperCamelCase_					, UpperCamelCase_					, shots=1000					)

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


if __name__ == "__main__":
		UpperCamelCase_       :    int						      =			single_qubit_measure(2, 2)
		print(F"""Total count for various states are: {counts}""")








'''simple docstring'''
import argparse
import json
import re
from pathlib import Path

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

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE					:				List[Any]									=		logging.get_logger(__name__)







def       a_				(	UpperCamelCase_ ):
							A_			    =		MobileNetVaConfig(layer_norm_eps=0.001 )

							if "_quant" in model_name:
														raise ValueError("Quantized models are not supported." )

							A_			    =		re.match(R"^mobilenet_v1_([^_]*)_([^_]*)$"						,  UpperCamelCase_ )
							if matches:
														A_			    =		float(matches[1] )
														A_			    =		int(matches[2] )

							# The TensorFlow version of MobileNetV1 predicts 1001 classes instead of
							# the usual 1000. The first class (index 0) is "background".
							A_			    =		1_0_0_1
							A_			    =		"imagenet-1k-id2label.json"
							A_			    =		"huggingface/label-files"
							A_			    =		json.load(open(hf_hub_download(UpperCamelCase_						,  UpperCamelCase_						,  repo_type="dataset" )						,  "r" ) )
							A_			    =		{int(UpperCamelCase_ ) + 1: v for k, v in idalabel.items()}
							A_			    =		"background"
							A_			    =		idalabel
							A_			    =		{v: k for k, v in idalabel.items()}

							return config







def       a_				(	):
							A_			    =		"http://images.cocodataset.org/val2017/000000039769.jpg"
							A_			    =		Image.open(requests.get(UpperCamelCase_						,  stream=UpperCamelCase_ ).raw )
							return im







@torch.no_grad()
def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_=False ):
							A_			    =		get_mobilenet_va_config(UpperCamelCase_ )

							# Load 🤗 model
							A_			    =		MobileNetVaForImageClassification(UpperCamelCase_ ).eval()

							# Load weights from TensorFlow checkpoint
							load_tf_weights_in_mobilenet_va(UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ )

							# Check outputs on an image, prepared by MobileNetV1ImageProcessor
							A_			    =		MobileNetVaImageProcessor(
							    crop_size={"width": config.image_size, "height": config.image_size}						,  size={"shortest_edge": config.image_size + 3_2}						,  )
							A_			    =		image_processor(images=prepare_img()						,  return_tensors="pt" )
							A_			    =		model(**UpperCamelCase_ )
							A_			    =		outputs.logits

							assert logits.shape == (1, 1_0_0_1)

							if model_name == "mobilenet_v1_1.0_224":
														A_			    =		torch.tensor([-4.1739, -1.1233, 3.1205] )
							elif model_name == "mobilenet_v1_0.75_192":
														A_			    =		torch.tensor([-3.9440, -2.3141, -0.3333] )
							else:
														A_			    =		None

							if expected_logits is not None:
														assert torch.allclose(logits[0, :3]						,  UpperCamelCase_						,  atol=1e-4 )

							Path(UpperCamelCase_ ).mkdir(exist_ok=UpperCamelCase_ )
							print(f"Saving model {model_name} to {pytorch_dump_folder_path}" )
							model.save_pretrained(UpperCamelCase_ )
							print(f"Saving image processor to {pytorch_dump_folder_path}" )
							image_processor.save_pretrained(UpperCamelCase_ )

							if push_to_hub:
														print("Pushing to the hub..." )
														A_			    =		"google/" + model_name
														image_processor.push_to_hub(UpperCamelCase_ )
														model.push_to_hub(UpperCamelCase_ )


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE					:				int									=		argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '''--model_name''',
							    default='''mobilenet_v1_1.0_224''',
							    type=str,
							    help='''Name of the MobileNetV1 model you\'d like to convert. Should in the form \'mobilenet_v1_<depth>_<size>\'.''',
							)
							parser.add_argument(
							    '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).'''
							)
							parser.add_argument(
							    '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.'''
							)
							parser.add_argument(
							    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
							)

							__SCREAMING_SNAKE_CASE					:				Dict									=		parser.parse_args()
							convert_movilevit_checkpoint(
							    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
							)





