




import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase_						=logging.get_logger(__name__)



def       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case							):
							lowerCAmelCase   =		os.path.abspath(_snake_case							)
							logger.info(F"""Converting TensorFlow checkpoint from {tf_path}"""							)
							# Load weights from TF model
							lowerCAmelCase   =		tf.train.list_variables(_snake_case							)
							lowerCAmelCase   =		[]
							lowerCAmelCase   =		[]
							lowerCAmelCase   =		[]
							for full_name, shape in init_vars:
														# logger.info(f"Loading TF weight {name} with shape {shape}")
														lowerCAmelCase   =		full_name.split('''/'''							)
														if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
																					logger.info(F"""Skipping non-model layer {full_name}"""							)
																					continue
														if "optimizer" in full_name:
																					logger.info(F"""Skipping optimization layer {full_name}"""							)
																					continue
														if name[0] == "model":
																					# ignore initial 'model'
																					lowerCAmelCase   =		name[1:]
														# figure out how many levels deep the name is
														lowerCAmelCase   =		0
														for _name in name:
																					if _name.startswith('''layer_with_weights'''							):
																												depth += 1
																					else:
																												break
														layer_depth.append(_snake_case							)
														# read data
														lowerCAmelCase   =		tf.train.load_variable(_snake_case						, _snake_case							)
														names.append('''/'''.join(_snake_case							)							)
														arrays.append(_snake_case							)
							logger.info(F"""Read a total of {len(_snake_case							):,} layers"""							)

							# Sanity check
							if len(set(_snake_case							)							) != 1:
														raise ValueError(F"""Found layer names with different depths (layer depth {list(set(_snake_case							)							)})"""							)
							lowerCAmelCase   =		list(set(_snake_case							)							)[0]
							if layer_depth != 1:
														raise ValueError(
														    '''The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP'''
														    ''' heads.'''							)

							# convert layers
							logger.info('''Converting weights...'''							)
							for full_name, array in zip(_snake_case						, _snake_case							):
														lowerCAmelCase   =		full_name.split('''/'''							)
														lowerCAmelCase   =		model
														lowerCAmelCase   =		[]
														for i, m_name in enumerate(_snake_case							):
																					if m_name == ".ATTRIBUTES":
																												# variable names end with .ATTRIBUTES/VARIABLE_VALUE
																												break
																					if m_name.startswith('''layer_with_weights'''							):
																												lowerCAmelCase   =		int(m_name.split('''-'''							)[-1]							)
																												if layer_num <= 2:
																																			# embedding layers
																																			# layer_num 0: word_embeddings
																																			# layer_num 1: position_embeddings
																																			# layer_num 2: token_type_embeddings
																																			continue
																												elif layer_num == 3:
																																			# embedding LayerNorm
																																			trace.extend(['''embeddings''', '''LayerNorm''']							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''embeddings'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''LayerNorm'''							)
																												elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
																																			# encoder layers
																																			trace.extend(['''encoder''', '''layer''', str(layer_num - 4							)]							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''encoder'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''layer'''							)
																																			lowerCAmelCase   =		pointer[layer_num - 4]
																												elif layer_num == config.num_hidden_layers + 4:
																																			# pooler layer
																																			trace.extend(['''pooler''', '''dense''']							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''pooler'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''dense'''							)
																					elif m_name == "embeddings":
																												trace.append('''embeddings'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''embeddings'''							)
																												if layer_num == 0:
																																			trace.append('''word_embeddings'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''word_embeddings'''							)
																												elif layer_num == 1:
																																			trace.append('''position_embeddings'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''position_embeddings'''							)
																												elif layer_num == 2:
																																			trace.append('''token_type_embeddings'''							)
																																			lowerCAmelCase   =		getattr(_snake_case						, '''token_type_embeddings'''							)
																												else:
																																			raise ValueError(F"""Unknown embedding layer with name {full_name}"""							)
																												trace.append('''weight'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''weight'''							)
																					elif m_name == "_attention_layer":
																												# self-attention layer
																												trace.extend(['''attention''', '''self''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''attention'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''self'''							)
																					elif m_name == "_attention_layer_norm":
																												# output attention norm
																												trace.extend(['''attention''', '''output''', '''LayerNorm''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''attention'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''output'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''LayerNorm'''							)
																					elif m_name == "_attention_output_dense":
																												# output attention dense
																												trace.extend(['''attention''', '''output''', '''dense''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''attention'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''output'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''dense'''							)
																					elif m_name == "_output_dense":
																												# output dense
																												trace.extend(['''output''', '''dense''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''output'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''dense'''							)
																					elif m_name == "_output_layer_norm":
																												# output dense
																												trace.extend(['''output''', '''LayerNorm''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''output'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''LayerNorm'''							)
																					elif m_name == "_key_dense":
																												# attention key
																												trace.append('''key'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''key'''							)
																					elif m_name == "_query_dense":
																												# attention query
																												trace.append('''query'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''query'''							)
																					elif m_name == "_value_dense":
																												# attention value
																												trace.append('''value'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''value'''							)
																					elif m_name == "_intermediate_dense":
																												# attention intermediate dense
																												trace.extend(['''intermediate''', '''dense''']							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''intermediate'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''dense'''							)
																					elif m_name == "_output_layer_norm":
																												# output layer norm
																												trace.append('''output'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''output'''							)
																					# weights & biases
																					elif m_name in ["bias", "beta"]:
																												trace.append('''bias'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''bias'''							)
																					elif m_name in ["kernel", "gamma"]:
																												trace.append('''weight'''							)
																												lowerCAmelCase   =		getattr(_snake_case						, '''weight'''							)
																					else:
																												logger.warning(F"""Ignored {m_name}"""							)
        # for certain layers reshape is necessary
														lowerCAmelCase   =		'''.'''.join(_snake_case							)
														if re.match(R'''(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)'''						, _snake_case							) or re.match(
														    R'''(\S+)\.attention\.output\.dense\.weight'''						, _snake_case							):
																					lowerCAmelCase   =		array.reshape(pointer.data.shape							)
														if "kernel" in full_name:
																					lowerCAmelCase   =		array.transpose()
														if pointer.shape == array.shape:
																					lowerCAmelCase   =		torch.from_numpy(_snake_case							)
														else:
																					raise ValueError(
																					    F"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
																					    F""" {array.shape}"""							)
														logger.info(F"""Successfully set variable {full_name} to PyTorch layer {trace}"""							)
							return model



def       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case							):
							# Instantiate model
							logger.info(F"""Loading model based on config from {config_path}..."""							)
							lowerCAmelCase   =		BertConfig.from_json_file(_snake_case							)
							lowerCAmelCase   =		BertModel(_snake_case							)

							# Load weights from checkpoint
							logger.info(F"""Loading weights from checkpoint {tf_checkpoint_path}..."""							)
							load_tfa_weights_in_bert(_snake_case						, _snake_case						, _snake_case							)

							# Save pytorch-model
							logger.info(F"""Saving PyTorch model to {pytorch_dump_path}..."""							)
							torch.save(model.state_dict()						, _snake_case							)


if __name__ == "__main__":
		UpperCAmelCase_						=argparse.ArgumentParser()
		parser.add_argument(
		    """--tf_checkpoint_path""", type=str, required=True, help="""Path to the TensorFlow 2.x checkpoint path."""
		)
		parser.add_argument(
		    """--bert_config_file""",
		    type=str,
		    required=True,
		    help="""The config json file corresponding to the BERT model. This specifies the model architecture.""",
		)
		parser.add_argument(
		    """--pytorch_dump_path""",
		    type=str,
		    required=True,
		    help="""Path to the output PyTorch model (must include filename).""",
		)
		UpperCAmelCase_						=parser.parse_args()
		convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)









import math

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



def       UpperCAmelCase       (     _snake_case = 3							):
							if isinstance(_snake_case						, _snake_case							):
														raise TypeError('''number of qubits must be a integer.'''							)
							if number_of_qubits <= 0:
														raise ValueError('''number of qubits must be > 0.'''							)
							if math.floor(_snake_case							) != number_of_qubits:
														raise ValueError('''number of qubits must be exact integer.'''							)
							if number_of_qubits > 10:
														raise ValueError('''number of qubits too large to simulate(>10).'''							)

							lowerCAmelCase   =		QuantumRegister(_snake_case						, '''qr'''							)
							lowerCAmelCase   =		ClassicalRegister(_snake_case						, '''cr'''							)

							lowerCAmelCase   =		QuantumCircuit(_snake_case						, _snake_case							)

							lowerCAmelCase   =		number_of_qubits

							for i in range(_snake_case							):
														quantum_circuit.h(number_of_qubits - i - 1							)
														counter -= 1
														for j in range(_snake_case							):
																					quantum_circuit.cp(np.pi / 2 ** (counter - j)						, _snake_case						, _snake_case							)

							for k in range(number_of_qubits // 2							):
														quantum_circuit.swap(_snake_case						, number_of_qubits - k - 1							)

							# measure all the qubits
							quantum_circuit.measure(_snake_case						, _snake_case							)
							# simulate with 10000 shots
							lowerCAmelCase   =		Aer.get_backend('''qasm_simulator'''							)
							lowerCAmelCase   =		execute(_snake_case						, _snake_case						, shots=10000							)

							return job.result().get_counts(_snake_case							)


if __name__ == "__main__":
		print(
		    F'''Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}'''
		)



