






import math

import qiskit





def 				snake_case  (     lowerCamelCase = 1				,  lowerCamelCase = 1				,  lowerCamelCase = 1					):




	'''simple docstring'''







	if (
	    isinstance(lowerCamelCase				,  lowerCamelCase					)
	    or isinstance(lowerCamelCase				,  lowerCamelCase					)
	    or isinstance(lowerCamelCase				,  lowerCamelCase					)
	):
		raise TypeError("""inputs must be integers."""					)

	if (input_a < 0) or (input_a < 0) or (carry_in < 0):
		raise ValueError("""inputs must be positive."""					)

	if (
	    (math.floor(lowerCamelCase					) != input_a)
	    or (math.floor(lowerCamelCase					) != input_a)
	    or (math.floor(lowerCamelCase					) != carry_in)
	):
		raise ValueError("""inputs must be exact integers."""					)

	if (input_a > 2) or (input_a > 2) or (carry_in > 2):
		raise ValueError("""inputs must be less or equal to 2."""					)

	# build registers
	__lowercase             =  qiskit.QuantumRegister(4				,  """qr"""					)
	__lowercase             =  qiskit.ClassicalRegister(2				,  """cr"""					)
	# list the entries
	__lowercase             =  [input_a, input_a, carry_in]

	__lowercase             =  qiskit.QuantumCircuit(lowerCamelCase				,  lowerCamelCase					)

	for i in range(0				,  3					):
		if entry[i] == 2:
			quantum_circuit.h(lowerCamelCase					)  # for hadamard entries
		elif entry[i] == 1:
			quantum_circuit.x(lowerCamelCase					)  # for 1 entries
		elif entry[i] == 0:
			quantum_circuit.i(lowerCamelCase					)  # for 0 entries

    # build the circuit
	quantum_circuit.ccx(0				,  1				,  3					)  # ccx = toffoli gate
	quantum_circuit.cx(0				,  1					)
	quantum_circuit.ccx(1				,  2				,  3					)
	quantum_circuit.cx(1				,  2					)
	quantum_circuit.cx(0				,  1					)

	quantum_circuit.measure([2, 3]				,  lowerCamelCase					)  # measure the last two qbits

	__lowercase             =  qiskit.Aer.get_backend("""aer_simulator"""					)
	__lowercase             =  qiskit.execute(lowerCamelCase				,  lowerCamelCase				,  shots=1_000					)

	return job.result().get_counts(lowerCamelCase					)


if __name__ == "__main__":
						print(F'''Total sum count for state is: {quantum_full_adder(1, 1, 1)}''')









import argparse

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoTokenizer, RobertaPreLayerNormConfig, RobertaPreLayerNormForMaskedLM
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCamelCase      :      str     						=						logging.get_logger(__name__)





def 				snake_case  (     lowerCamelCase				,  lowerCamelCase					):




	'''simple docstring'''







	__lowercase             =  RobertaPreLayerNormConfig.from_pretrained(
	    lowerCamelCase				,  architectures=["""RobertaPreLayerNormForMaskedLM"""]					)

	# convert state_dict
	__lowercase             =  torch.load(hf_hub_download(repo_id=lowerCamelCase				,  filename="""pytorch_model.bin"""					)					)
	__lowercase             =  {}
	for tensor_key, tensor_value in original_state_dict.items():
		# The transformer implementation gives the model a unique name, rather than overwiriting 'roberta'
		if tensor_key.startswith("""roberta."""					):
			__lowercase             =  """roberta_prelayernorm.""" + tensor_key[len("""roberta."""					) :]

		# The original implementation contains weights which are not used, remove them from the state_dict
		if tensor_key.endswith(""".self.LayerNorm.weight"""					) or tensor_key.endswith(""".self.LayerNorm.bias"""					):
			continue

		__lowercase             =  tensor_value

	__lowercase             =  RobertaPreLayerNormForMaskedLM.from_pretrained(
	    pretrained_model_name_or_path=lowerCamelCase				,  config=lowerCamelCase				,  state_dict=lowerCamelCase					)
	model.save_pretrained(lowerCamelCase					)

	# convert tokenizer
	__lowercase             =  AutoTokenizer.from_pretrained(lowerCamelCase					)
	tokenizer.save_pretrained(lowerCamelCase					)


if __name__ == "__main__":
						__UpperCamelCase      :      List[Any]     						=						argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    """--checkpoint-repo""",
						    default=None,
						    type=str,
						    required=True,
						    help="""Path the official PyTorch dump, e.g. 'andreasmadsen/efficient_mlm_m0.40'.""",
						)
						parser.add_argument(
						    """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
						)
						__UpperCamelCase      :      Dict     						=						parser.parse_args()
						convert_roberta_prelayernorm_checkpoint_to_pytorch(args.checkpoint_repo, args.pytorch_dump_folder_path)

