






import argparse

# utilities to import the model weights and config file
import os
import pickle as pkl

# PyTorch + new model classes
import torch
from torch import nn

from transformers import AutoTokenizer, MegaConfig, MegaForMaskedLM


# import the EncoderLayer class used to pretrain
# !! NOTE !! this requires the version of fairseq that is built when you install the Mega source
try:
	from fairseq.modules.mega_layer import MegaEncoderLayer
except ImportError:
	raise ImportError('''You need to install the version of fairseq from the Mega repo!''')

class        _SCREAMING_SNAKE_CASE			(     nn.Module ):





	def __init__(						self							:   Dict					,    __lowerCamelCase							:   Tuple					,    __lowerCamelCase							:   Optional[int]					,    __lowerCamelCase							:   List[Any]      ):
		super().__init__()
		UpperCamelCase	:Optional[Any]		=      mega_args
		UpperCamelCase	:Dict		=      nn.Embedding(__lowerCamelCase					,    self.mega_args.encoder_embed_dim      )
		UpperCamelCase	:List[Any]		=      nn.ModuleList([MegaEncoderLayer(self.mega_args      ) for _ in range(__lowerCamelCase      )]      )
		UpperCamelCase	:Optional[Any]		=      depth





	def 		_A					(						self							:   Dict					,    __lowerCamelCase							:   Optional[int]					,    __lowerCamelCase							:   Tuple					,    __lowerCamelCase							:   Optional[Any]=True					,    __lowerCamelCase							:   Optional[Any]=0      ):

		# Mega expects embeddings to be (time, batch, embedding size), but
		# Hugging Face returns tokens as (batch, time)
		if batch_first:
			UpperCamelCase	:Optional[int]		=      input_ids.T

		# to make things more confusing, Mega expects the attention mask to
		# be (batch, time), but with values of 0 (normal token) and 1 (ignore token)
		# which is the opposite of what HF returns
		if ignore_mask_value == 0:
			UpperCamelCase	:List[Any]		=      1 - attention_mask

		# get token embeddings from IDs
		UpperCamelCase	:int		=      self.embedding_layer(__lowerCamelCase      )

		# pass through the Mega layers
		# input is (time, batch, encoder dim) and output is the same
		for encoder in self.encoders:
			UpperCamelCase	:List[str]		=      encoder(__lowerCamelCase					,    __lowerCamelCase      )

		# return according to the shape specified
		if batch_first:
			# (T, B, H) --> (B, T, H)
			return torch.transpose(__lowerCamelCase					,    0					,    1      )
		else:
			return embeds

class        _SCREAMING_SNAKE_CASE			(     nn.Module ):





	def __init__(						self							:   List[Any]					,    __lowerCamelCase							:   int					,    __lowerCamelCase							:   Optional[int]					,    __lowerCamelCase							:   Optional[int]      ):
		super().__init__()
		UpperCamelCase	:Dict		=      MegaLM(__lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase      )
		UpperCamelCase	:Dict		=      nn.Linear(mega_args.encoder_embed_dim					,    __lowerCamelCase      )
		UpperCamelCase	:Optional[Any]		=      nn.Dropout(p=0.1      )





	def 		_A					(						self							:   Tuple					,    __lowerCamelCase							:   Optional[Any]					,    __lowerCamelCase							:   Any					,    __lowerCamelCase							:   List[str]=True					,    __lowerCamelCase							:   Optional[Any]=0      ):
		UpperCamelCase	:Dict		=      self.mega(__lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase      )
		return self.mlm_head(self.dropout(__lowerCamelCase      )      )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    Any      ,     __magic_name__   :    Union[str, Any]      ,     __magic_name__   :    int   )						->     Any:






	"""simple docstring"""



	with open(os.path.join(__magic_name__      ,     """model_args.pkl"""   )      ,     """rb"""   ) as f:
		UpperCamelCase	:Union[str, Any]		=      pkl.load(__magic_name__   )

	# load the original encoder
	UpperCamelCase	:int		=      OriginalMegaForMaskedLM(**__magic_name__   ).eval()

	# load its weights
	print(
	    """Original Mega encoder:"""      ,     original_mlm.mega.load_state_dict(
	        torch.load(os.path.join(__magic_name__      ,     """encoder_weights.pt"""   )      ,     map_location="""cpu"""   )   )      ,     )
	print(
	    """Original Mega MLM layer:"""      ,     original_mlm.mlm_head.load_state_dict(
	        torch.load(os.path.join(__magic_name__      ,     """mlm_head_weights.pt"""   )      ,     map_location="""cpu"""   )   )      ,     )

	# create a new config from the old one
	UpperCamelCase	:Dict		=      MegaConfig(
	    num_hidden_layers=mega_original_args["""depth"""]      ,     vocab_size=mega_original_args["""vocab_size"""]      ,     hidden_size=mega_original_args["""mega_args"""].encoder_embed_dim      ,     shared_representation_size=mega_original_args["""mega_args"""].encoder_z_dim      ,     intermediate_size=mega_original_args["""mega_args"""].encoder_hidden_dim      ,     ema_projection_size=mega_original_args["""mega_args"""].encoder_n_dim      ,     dropout_prob=mega_original_args["""mega_args"""].dropout      ,     attention_probs_dropout_prob=mega_original_args["""mega_args"""].attention_dropout      ,     hidden_dropout_prob=mega_original_args["""mega_args"""].hidden_dropout      ,     activation=mega_original_args["""mega_args"""].activation_fn      ,     attention_activation=mega_original_args["""mega_args"""].attention_activation_fn      ,     bidirectional=mega_original_args["""mega_args"""].bidirectional      ,     use_chunking=mega_original_args["""mega_args"""].encoder_chunk_size > 0      ,     chunk_size=mega_original_args["""mega_args"""].encoder_chunk_size      ,     truncation=mega_original_args["""mega_args"""].truncation_length      ,     normalization_type=mega_original_args["""mega_args"""].normalization_type      ,     normalize_before_mega=__magic_name__      ,     norm_affine=__magic_name__      ,     use_feature_dropout=mega_original_args["""mega_args"""].feature_dropout      ,     relative_positional_bias=mega_original_args["""mega_args"""].rel_pos_bias      ,     max_positions=mega_original_args["""mega_args"""].max_source_positions      ,     nffn_hidden_size=mega_original_args["""mega_args"""].encoder_ffn_embed_dim      ,     normalize_before_ffn=mega_original_args["""mega_args"""].normalize_before      ,     nffn_activation_dropout_prob=0.0      ,     add_token_type_embeddings=__magic_name__      ,     add_lm_hidden_dense_layer=__magic_name__      ,     )

	UpperCamelCase	:Tuple		=      MegaForMaskedLM(__magic_name__   ).eval()

	# the originl checkpoint just uses nn.Embedding for the word embeddings
	# we use a wrapper module for embeddings to add support for positional embeddings
	UpperCamelCase	:List[str]		=      original_mlm.mega.embedding_layer.weight

	# modify the state dictionary of the original checkpoint to account for naming issues in the Hugging Face
	# ecosystem -- any names containing "beta" or "gamma" aren't safe to use and are renamed upon _load_pretrained,
	# also renaming previously confusing parameter names
	UpperCamelCase	:Tuple		=      original_mlm.mega.encoders.state_dict()
	UpperCamelCase	:Any		=      {}
	for module_name in original_state_dict.keys():
		UpperCamelCase	:Union[str, Any]		=      None
		# have to handle gamma, beta, and alpha differently due to their use
		# in multiple modules within the original repository;
		# beta is used in EMA, MovingAverageGatedAttention, and RotaryRelativePositionalBias, and must be renamed due to flax/tf weights
		# the EMA sublayer was renamed from "move" to "ema_gate" for readability, so that is also done here
		if "beta" in module_name:
			# EMA sub-layers were always called "move" in the original repo
			if "move.beta" in module_name:
				UpperCamelCase	:List[Any]		=      module_name.replace("""move.beta"""      ,     """ema_gate.ema_expansion_matrix"""   )
			elif "mega_layer.beta" in module_name:
				UpperCamelCase	:Dict		=      module_name.replace("""beta"""      ,     """qk_bias"""   )
			else:
				UpperCamelCase	:str		=      module_name.replace("""beta"""      ,     """b_param"""   )
        # beta is used in EMA and MovingAverageGatedAttention, and must be renamed due to flax/tf weights
		elif "gamma" in module_name:
			if "move.gamma" in module_name:
				UpperCamelCase	:List[str]		=      module_name.replace("""move.gamma"""      ,     """ema_gate.kernel_projection_matrix"""   )
			elif "mega_layer.gamma" in module_name:
				UpperCamelCase	:List[Any]		=      module_name.replace("""gamma"""      ,     """qk_weight"""   )
			else:
				UpperCamelCase	:Dict		=      module_name.replace("""gamma"""      ,     """g_param"""   )
        # alpha is used in EMA and positional bias; renaming to improve readability
		elif "move.alpha" in module_name:
			UpperCamelCase	:Any		=      module_name.replace("""move.alpha"""      ,     """ema_gate.decay_factor"""   )
		# delta is only used in EMA; renaming to improve readability
		elif "move.delta" in module_name:
			UpperCamelCase	:Tuple		=      module_name.replace("""move.delta"""      ,     """ema_gate.damping_factor"""   )
		# omega is only used in EMA; renaming to improve readability
		elif "omega" in module_name:
			UpperCamelCase	:int		=      module_name.replace("""move.omega"""      ,     """ema_gate.residual_weight"""   )

		if new_module_name:
			UpperCamelCase	:Tuple		=      new_module_name

	if len(__magic_name__   ) != 0:
		print(f"""Renaming these keys: {updated_keys.keys()}"""   )
	else:
		print("""No need to rename state dict entries"""   )
	for old, new in updated_keys.items():
		UpperCamelCase	:Dict		=      original_state_dict.pop(__magic_name__   )

	# now attempt to load the state dictionary with updated names
	# note that we now call it `mega.layers` instead of `mega.encoders` due to hugging face style
	print("""HF Mega encoder:"""      ,     hf_mlm.mega.layers.load_state_dict(__magic_name__   )   )

	# load the MLM head weights directly
	print(
	    """HF Mega MLM layer:"""      ,     hf_mlm.mlm_head.load_state_dict(
	        torch.load(os.path.join(__magic_name__      ,     """mlm_head_weights.pt"""   )      ,     map_location="""cpu"""   )   )      ,     )

	# test on a randomly generated input sequence
	UpperCamelCase	:Dict		=      torch.randint(0      ,     hf_config.vocab_size      ,     size=(4, 256)   )
	UpperCamelCase	:List[Any]		=      torch.ones_like(__magic_name__   )
	# mask a few tokens to make sure masking is applied appropriately :)
	UpperCamelCase	:List[str]		=      0

	# run forward passes
	UpperCamelCase	:Union[str, Any]		=      original_mlm(__magic_name__      ,     __magic_name__      ,     batch_first=__magic_name__      ,     ignore_mask_value=0   )
	UpperCamelCase	:Dict		=      hf_mlm(__magic_name__      ,     __magic_name__   )[0]

	# print shapes and diff
	print(f"""original output {original_output.shape}"""   )
	print(f"""hf output {hf_output.shape}"""   )
	print(f"""max diff: {(original_output - hf_output).max()}"""   )  # 0.0
	UpperCamelCase	:Dict		=      torch.allclose(__magic_name__      ,     __magic_name__      ,     atol=1E-3   )

	if success:
		print("""Yay!"""   )
		hf_mlm.save_pretrained(__magic_name__   )
	else:
		raise RuntimeError(f"""Something's broken :(\nOriginal:\n{original_output}\n\nHF\n{hf_output}\n{hf_mlm}"""   )

	if includes_tokenizer:
		print("""Transferring tokenizer"""   )
		UpperCamelCase	:Dict		=      AutoTokenizer.from_pretrained(__magic_name__   )
		tokenizer.save_pretrained(__magic_name__   )


if __name__ == "__main__":
	UpperCAmelCase_					:		Union[str, Any]           = argparse.ArgumentParser()

	parser.add_argument(
	    '''--pretrained_checkpoint_path''',
	    default=None,
	    type=str,
	    required=True,
	    help='''Point to the directory containing your model weights using the official Mega repo''',
	)

	parser.add_argument(
	    '''--output_path''', default=None, type=str, required=True, help='''Location to save the Hugging Face version'''
	)

	parser.add_argument(
	    '''--includes_tokenizer''',
	    action='''store_true''',
	    help='''Use this flag if there is a Hugging Face tokenizer in the original checkpoint repo''',
	)

	UpperCAmelCase_					:		Optional[Any]           = parser.parse_args()

	convert_checkpoint_to_huggingface(args.pretrained_checkpoint_path, args.output_path, args.includes_tokenizer)








import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    float = np.pi / 2      ,     __magic_name__   :    float = np.pi / 2      ,     __magic_name__   :    float = np.pi / 2   )						->     qiskit.result.counts.Counts:






	"""simple docstring"""



	UpperCamelCase	:Optional[int]		=      QuantumRegister(3      ,     """qr"""   )  # Define the number of quantum bits
	UpperCamelCase	:Optional[Any]		=      ClassicalRegister(1      ,     """cr"""   )  # Define the number of classical bits

	UpperCamelCase	:List[Any]		=      QuantumCircuit(__magic_name__      ,     __magic_name__   )  # Define the quantum circuit.

	# Build the circuit
	quantum_circuit.u(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     0   )  # Quantum State to teleport
	quantum_circuit.h(1   )  # add hadamard gate
	quantum_circuit.cx(
	    1      ,     2   )  # add control gate with qubit 1 as control and 2 as target.
	quantum_circuit.cx(0      ,     1   )
	quantum_circuit.h(0   )
	quantum_circuit.cz(0      ,     2   )  # add control z gate.
	quantum_circuit.cx(1      ,     2   )

	quantum_circuit.measure([2]      ,     [0]   )  # measure the qubit.

	# Simulate the circuit using qasm simulator
	UpperCamelCase	:Union[str, Any]		=      Aer.get_backend("""aer_simulator"""   )
	UpperCamelCase	:Dict		=      execute(__magic_name__      ,     __magic_name__      ,     shots=1000   )

	return job.result().get_counts(__magic_name__   )


if __name__ == "__main__":
	print(
	    '''Total count for teleported state is: '''
	    F'''{quantum_teleportation(np.pi/2, np.pi/2, np.pi/2)}'''
	)
