


import argparse
import pickle

import numpy as np
import torch
from torch import nn

from transformers import ReformerConfig, ReformerModelWithLMHead
from transformers.utils import logging


logging.set_verbosity_info()


def     lowercase	(    a     , a     , a=None ):



		'''simple docstring'''




		assert torch_layer.weight.shape == weight.shape, F"{torch_layer} layer.weight does not match"
		SCREAMING_SNAKE_CASE_				:Tuple				     =						nn.Parameter(a )
		if bias is not None:
				assert torch_layer.bias.shape == bias.shape, F"{torch_layer} layer.bias does not match"
				SCREAMING_SNAKE_CASE_				:Tuple				     =						nn.Parameter(a )


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						np.asarray(weights[0] )
		SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						np.asarray(weights[1] )
		SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						np.asarray(weights[2] )

		set_param(
		    torch_layer.self_attention.query_key     , torch.tensor(a ).transpose(1     , 2 ).contiguous().view(-1     , a )     , )
		set_param(
		    torch_layer.self_attention.value     , torch.tensor(a ).transpose(1     , 2 ).contiguous().view(-1     , a )     , )
		set_param(
		    torch_layer.output.dense     , torch.tensor(a ).view(-1     , a ).contiguous().transpose(0     , 1 )     , )


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						np.asarray(weights[0] )
		SCREAMING_SNAKE_CASE_				:int				     =						np.asarray(weights[1] )
		SCREAMING_SNAKE_CASE_				:Dict				     =						np.asarray(weights[2] )
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						np.asarray(weights[3] )

		set_param(
		    torch_layer.self_attention.query     , torch.tensor(a ).transpose(1     , 2 ).contiguous().view(-1     , a )     , )
		set_param(
		    torch_layer.self_attention.key     , torch.tensor(a ).transpose(1     , 2 ).contiguous().view(-1     , a )     , )
		set_param(
		    torch_layer.self_attention.value     , torch.tensor(a ).transpose(1     , 2 ).contiguous().view(-1     , a )     , )
		set_param(
		    torch_layer.output.dense     , torch.tensor(a ).view(-1     , a ).contiguous().transpose(0     , 1 )     , )


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:List[Any]				     =						weights[0][0][0]
		SCREAMING_SNAKE_CASE_				:Any				     =						np.asarray(layer_norm_a[0] )
		SCREAMING_SNAKE_CASE_				:List[Any]				     =						np.asarray(layer_norm_a[1] )
		set_param(
		    torch_block.attention.layer_norm     , torch.tensor(a )     , torch.tensor(a )     , )

		# lsh weights + output
		SCREAMING_SNAKE_CASE_				:List[Any]				     =						weights[0][1]
		if len(a ) < 4:
				set_layer_weights_in_torch_lsh(a     , torch_block.attention     , a )
		else:
				set_layer_weights_in_torch_local(a     , torch_block.attention     , a )

		# intermediate weighs
		SCREAMING_SNAKE_CASE_				:str				     =						weights[2][0][1][2]

		# Chunked Feed Forward
		if len(a ) == 4:
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						intermediate_weights[2]

		# layernorm 2
		SCREAMING_SNAKE_CASE_				:Dict				     =						np.asarray(intermediate_weights[0][0] )
		SCREAMING_SNAKE_CASE_				:int				     =						np.asarray(intermediate_weights[0][1] )
		set_param(
		    torch_block.feed_forward.layer_norm     , torch.tensor(a )     , torch.tensor(a )     , )

		# intermediate dense
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						np.asarray(intermediate_weights[1][0] )
		SCREAMING_SNAKE_CASE_				:Any				     =						np.asarray(intermediate_weights[1][1] )
		set_param(
		    torch_block.feed_forward.dense.dense     , torch.tensor(a ).transpose(0     , 1 ).contiguous()     , torch.tensor(a )     , )

		# intermediate out
		SCREAMING_SNAKE_CASE_				:Tuple				     =						np.asarray(intermediate_weights[4][0] )
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						np.asarray(intermediate_weights[4][1] )
		set_param(
		    torch_block.feed_forward.output.dense     , torch.tensor(a ).transpose(0     , 1 ).contiguous()     , torch.tensor(a )     , )


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:str				     =						torch_model.reformer

		# word embeds
		SCREAMING_SNAKE_CASE_				:int				     =						np.asarray(weights[1] )
		set_param(
		    torch_model_reformer.embeddings.word_embeddings     , torch.tensor(a )     , )

		if isinstance(weights[3]     , a ):
				SCREAMING_SNAKE_CASE_				:Dict				     =						torch_model_reformer.embeddings.position_embeddings
				for emb_idx in range(len(position_embeddings.weights ) ):
						SCREAMING_SNAKE_CASE_				:Any				     =						np.asarray(weights[3][emb_idx][0] )
						assert (
						    position_embeddings.weights[emb_idx].shape == emb_weights.shape
						), F"{position_embeddings[emb_idx]} emb does not match"
						SCREAMING_SNAKE_CASE_				:Tuple				     =						nn.Parameter(torch.tensor(a ) )

		SCREAMING_SNAKE_CASE_				:Tuple				     =						weights[5]
		assert len(torch_model_reformer.encoder.layers ) * 4 == len(
		    a ), "HF and trax model do not have the same number of layers"
		for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers ):
				SCREAMING_SNAKE_CASE_				:Any				     =						trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
				set_block_weights_in_torch(a     , a     , a )

		# output layer norm
		SCREAMING_SNAKE_CASE_				:Any				     =						np.asarray(weights[7][0] )
		SCREAMING_SNAKE_CASE_				:str				     =						np.asarray(weights[7][1] )
		set_param(
		    torch_model_reformer.encoder.layer_norm     , torch.tensor(a )     , torch.tensor(a )     , )

		# output embeddings
		SCREAMING_SNAKE_CASE_				:int				     =						np.asarray(weights[9][0] )
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						np.asarray(weights[9][1] )
		set_param(
		    torch_model.lm_head.decoder     , torch.tensor(a ).transpose(0     , 1 ).contiguous()     , torch.tensor(a )     , )


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:Tuple				     =						ReformerConfig.from_json_file(a )
		print(F"Building PyTorch model from configuration: {config}" )
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						ReformerModelWithLMHead(a )

		with open(a     , "rb" ) as f:
				SCREAMING_SNAKE_CASE_				:Dict				     =						pickle.load(a )["weights"]

		set_model_weights_in_torch(a     , a     , config.hidden_size )

		# Save pytorch-model
		print(F"Save PyTorch model to {pytorch_dump_path}" )
		torch.save(model.state_dict()     , a )


if __name__ == "__main__":
		SCREAMING_SNAKE_CASE__     					=			argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    "--trax_model_pkl_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
		)
		parser.add_argument(
		    "--config_file",
		    default=None,
		    type=str,
		    required=True,
		    help=(
		        "The config json file corresponding to the pre-trained Reformer model. \n"
		        "This specifies the model architecture."
		    ),
		)
		parser.add_argument(
		    "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
		)
		SCREAMING_SNAKE_CASE__     					=			parser.parse_args()
		convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)










import qiskit


def     lowercase	(    a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						qiskit.Aer.get_backend("aer_simulator" )

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

		# 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
		SCREAMING_SNAKE_CASE_				:Any				     =						qiskit.execute(a     , a     , shots=1000 )

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


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






