



'''simple docstring'''
from collections import OrderedDict
from typing import List, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


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

snake_case_ :	Tuple         =  {
    'google/efficientnet-b7': 'https://huggingface.co/google/efficientnet-b7/resolve/main/config.json',
}






class 							lowercase__	(							lowercase   ):
	lowercase__  				=			"""efficientnet"""





	def __init__( self					:				Optional[Any] ,lowerCamelCase__					:				int = 3 ,lowerCamelCase__					:				int = 600 ,lowerCamelCase__					:				float = 2.0 ,lowerCamelCase__					:				float = 3.1 ,lowerCamelCase__					:				int = 8 ,lowerCamelCase__					:				List[int] = [3, 3, 5, 3, 5, 5, 3] ,lowerCamelCase__					:				List[int] = [32, 16, 24, 40, 80, 112, 192] ,lowerCamelCase__					:				List[int] = [16, 24, 40, 80, 112, 192, 320] ,lowerCamelCase__					:				List[int] = [] ,lowerCamelCase__					:				List[int] = [1, 2, 2, 2, 1, 2, 1] ,lowerCamelCase__					:				List[int] = [1, 2, 2, 3, 3, 4, 1] ,lowerCamelCase__					:				List[int] = [1, 6, 6, 6, 6, 6, 6] ,lowerCamelCase__					:				float = 0.2_5 ,lowerCamelCase__					:				str = "swish" ,lowerCamelCase__					:				int = 2560 ,lowerCamelCase__					:				str = "mean" ,lowerCamelCase__					:				float = 0.0_2 ,lowerCamelCase__					:				float = 0.0_0_1 ,lowerCamelCase__					:				float = 0.9_9 ,lowerCamelCase__					:				float = 0.5 ,lowerCamelCase__					:				float = 0.2 ,**lowerCamelCase__					:				List[str] ,):







							'''simple docstring'''
							super().__init__(**lowerCamelCase__ )

							_UpperCamelCase					:		Union[str, Any] 				=   num_channels
							_UpperCamelCase					:		str 				=   image_size
							_UpperCamelCase					:		List[Any] 				=   width_coefficient
							_UpperCamelCase					:		Optional[Any] 				=   depth_coefficient
							_UpperCamelCase					:		List[str] 				=   depth_divisor
							_UpperCamelCase					:		int 				=   kernel_sizes
							_UpperCamelCase					:		Tuple 				=   in_channels
							_UpperCamelCase					:		Optional[Any] 				=   out_channels
							_UpperCamelCase					:		Dict 				=   depthwise_padding
							_UpperCamelCase					:		List[Any] 				=   strides
							_UpperCamelCase					:		Tuple 				=   num_block_repeats
							_UpperCamelCase					:		Optional[int] 				=   expand_ratios
							_UpperCamelCase					:		Any 				=   squeeze_expansion_ratio
							_UpperCamelCase					:		Any 				=   hidden_act
							_UpperCamelCase					:		List[str] 				=   hidden_dim
							_UpperCamelCase					:		List[str] 				=   pooling_type
							_UpperCamelCase					:		Dict 				=   initializer_range
							_UpperCamelCase					:		List[str] 				=   batch_norm_eps
							_UpperCamelCase					:		List[str] 				=   batch_norm_momentum
							_UpperCamelCase					:		str 				=   dropout_rate
							_UpperCamelCase					:		int 				=   drop_connect_rate
							_UpperCamelCase					:		List[str] 				=   sum(lowerCamelCase__ ) * 4






class 							lowercase__	(							lowercase   ):
	lowercase__  				=			version.parse("""1.11"""   )





	@property
	def 	UpperCamelCase_  ( self					:				Optional[int] ):







							'''simple docstring'''
							return OrderedDict(
							    [
							        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
							    ] )





	@property
	def 	UpperCamelCase_  ( self					:				str ):







							'''simple docstring'''
							return 1E-5







import qiskit

def        a						(      _UpperCAmelCase							:					int ,   _UpperCAmelCase							:					int						):







		'''simple docstring'''





		__UpperCAmelCase    :     List[str]													=	qiskit.Aer.get_backend('''aer_simulator'''						)

		__UpperCAmelCase    :     Optional[Any]													=	qiskit.QuantumCircuit(4 ,   2						)
		# encode inputs in qubits 0 and 1
		if bita == 1:
				qc_ha.x(0						)
		if bita == 1:
				qc_ha.x(1						)
		qc_ha.barrier()

		# use cnots to write XOR of the inputs on qubit2
		qc_ha.cx(0 ,   2						)
		qc_ha.cx(1 ,   2						)

		# use ccx / toffoli gate to write AND of the inputs on qubit3
		qc_ha.ccx(0 ,   1 ,   3						)
		qc_ha.barrier()

		# extract outputs
		qc_ha.measure(2 ,   0						)  # extract XOR value
		qc_ha.measure(3 ,   1						)  # extract AND value

		# Execute the circuit on the qasm simulator
		__UpperCAmelCase    :     str													=	qiskit.execute(_UpperCAmelCase ,   _UpperCAmelCase ,   shots=10_00						)

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


if __name__ == "__main__":
				__A   			=half_adder(1, 1)
				print(f'''Half Adder Output Qubit Counts: {counts}''')





