






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      lowerCAmelCase__	(    _a       :			List[Any]  ,      _a       :			List[str]  ,      _a       :			int=None    ):
		# set parameter of one layer
		assert torch_layer.weight.shape == weight.shape, F'''{torch_layer} layer.weight does not match'''
		snake_case_				:							Any						 =       nn.Parameter(_a    )
		if bias is not None:
				assert torch_layer.bias.shape == bias.shape, F'''{torch_layer} layer.bias does not match'''
				snake_case_				:							List[Any]						 =       nn.Parameter(_a    )

def      lowerCAmelCase__	(    _a       :			Optional[int]  ,      _a       :			int  ,      _a       :			Any    ):
		# set torch weights for 1-to-1 comparison
		snake_case_				:							Optional[Any]						 =       np.asarray(weights[0]    )
		snake_case_				:							Tuple						 =       np.asarray(weights[1]    )
		snake_case_				:							Tuple						 =       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      lowerCAmelCase__	(    _a       :			Tuple  ,      _a       :			Dict  ,      _a       :			Dict    ):
		# set torch weights for 1-to-1 comparison
		snake_case_				:							Dict						 =       np.asarray(weights[0]    )
		snake_case_				:							Dict						 =       np.asarray(weights[1]    )
		snake_case_				:							List[Any]						 =       np.asarray(weights[2]    )
		snake_case_				:							str						 =       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      lowerCAmelCase__	(    _a       :			Union[str, Any]  ,      _a       :			Optional[int]  ,      _a       :			Optional[int]    ):
		# layernorm 1
		snake_case_				:							List[Any]						 =       weights[0][0][0]
		snake_case_				:							Optional[int]						 =       np.asarray(layer_norm_a[0]    )
		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
		snake_case_				:							int						 =       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
		snake_case_				:							int						 =       weights[2][0][1][2]

		# Chunked Feed Forward
		if len(_a    ) == 4:
				snake_case_				:							Any						 =       intermediate_weights[2]

		# layernorm 2
		snake_case_				:							int						 =       np.asarray(intermediate_weights[0][0]    )
		snake_case_				:							str						 =       np.asarray(intermediate_weights[0][1]    )
		set_param(
		    torch_block.feed_forward.layer_norm  ,      torch.tensor(_a    )  ,      torch.tensor(_a    )  ,      )

		# intermediate dense
		snake_case_				:							Optional[int]						 =       np.asarray(intermediate_weights[1][0]    )
		snake_case_				:							Union[str, 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
		snake_case_				:							Dict						 =       np.asarray(intermediate_weights[4][0]    )
		snake_case_				:							Tuple						 =       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      lowerCAmelCase__	(    _a       :			str  ,      _a       :			List[Any]  ,      _a       :			Optional[int]    ):
		# reformer model
		snake_case_				:							Tuple						 =       torch_model.reformer

		# word embeds
		snake_case_				:							Tuple						 =       np.asarray(weights[1]    )
		set_param(
		    torch_model_reformer.embeddings.word_embeddings  ,      torch.tensor(_a    )  ,      )

		if isinstance(weights[3]  ,      _a    ):
				snake_case_				:							Optional[int]						 =       torch_model_reformer.embeddings.position_embeddings
				for emb_idx in range(len(position_embeddings.weights    )    ):
						snake_case_				:							int						 =       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'''
						snake_case_				:							List[Any]						 =       nn.Parameter(torch.tensor(_a    )    )

		snake_case_				:							List[str]						 =       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    ):
				snake_case_				:							Dict						 =       trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
				set_block_weights_in_torch(_a  ,      _a  ,      _a    )

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

		# output embeddings
		snake_case_				:							int						 =       np.asarray(weights[9][0]    )
		snake_case_				:							Optional[Any]						 =       np.asarray(weights[9][1]    )
		set_param(
		    torch_model.lm_head.decoder  ,      torch.tensor(_a    ).transpose(0  ,      1    ).contiguous()  ,      torch.tensor(_a    )  ,      )

def      lowerCAmelCase__	(    _a       :			Optional[int]  ,      _a       :			Optional[Any]  ,      _a       :			int    ):
		# Initialise PyTorch model
		snake_case_				:							List[Any]						 =       ReformerConfig.from_json_file(_a    )
		print(F'''Building PyTorch model from configuration: {config}'''    )
		snake_case_				:							Optional[Any]						 =       ReformerModelWithLMHead(_a    )

		with open(_a  ,      "rb"    ) as f:
				snake_case_				:							int						 =       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__":
							lowercase  :							int			  =    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.'''
							)
							lowercase  :							Optional[int]			  =    parser.parse_args()
							convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)








import qiskit

def      lowerCAmelCase__	(    _a       :			int  ,      _a       :			int    ):
		snake_case_				:							Tuple						 =       qiskit.Aer.get_backend("aer_simulator"    )

		# Create a Quantum Circuit acting on the q register
		snake_case_				:							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
		snake_case_				:							Any						 =       qiskit.execute(_a  ,      _a  ,      shots=10_00    )

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


if __name__ == "__main__":
							lowercase  :							List[Any]			  =    single_qubit_measure(2, 2)
							print(F"""Total count for various states are: {counts}""")
