y_label_RemotoCNOTandWindowLookAhead0_state_cut = []
y_label_RemotoCNOTandWindowLookAhead1_state_cut = []
y_label_RemotoCNOTandWindowLookAhead3_state_cut = []
'''generate architecture graph'''
'''q0 - v0, q1 - v1, ...'''
G = ct.GenerateArchitectureGraph(num_vertex, method_AG)
DiG = None
if isinstance(G, DiGraph): #check whether it is a directed graph
DiG = G
G = nx.Graph(DiG)
if draw_architecture_graph == True: nx.draw(G, with_labels=True)
'''calculate shortest path and its length'''
#shortest_path_G = nx.shortest_path(G, source=None, target=None, weight=None, method='dijkstra')
#shortest_length_G = dict(nx.shortest_path_length(G, source=None, target=None, weight=None, method='dijkstra'))
if DiG == None:
res = ct.ShortestPath(G)
shortest_path_G = res[1]
shortest_length_G = (res[0], res[2])
else:
res = ct.ShortestPath(DiG)
shortest_path_G = res[1]
shortest_length_G = (res[0], res[2])
'''use all possible swaps in parallel'''
# =============================================================================
# if imoprt_swaps_combination_from_json == True:
# fileObject = open('inputs\\swaps for architecture graph\\'+method_AG[0]+'.json', 'r')
# possible_swap_combination = json.load(fileObject)
# fileObject.close()
# else:
# if use_Astar_search == True or use_Astar_lookahead == True or use_RemotoCNOTandWindow == True or use_UDecompositionFullConnectivity == True or use_HeuristicGreedySearch == True:
# possible_swap_combination = ct.FindAllPossibleSWAPParallel(G)
ANN = tf.keras.models.load_model('my_model.h5')
method_AG = ['IBM QX20']
num_qubits = 20
num_data = 50
error = []
error2 = []
data_set = np.zeros([num_data, num_qubits, num_qubits])
data_set_add, label_set = ct.machinelearning.CreateRandomDataSet(
num_data, num_qubits, method_AG)
for i in range(num_data):
data_set[i] = data_set_add[i]
res = ct.machinelearning.CalSwapCostViaANN(ANN, data_set)
for i in range(num_data):
error.append(label_set[i] - res[i])
'''cal dis via shortes distance'''
'''generate architecture graph'''
G = ct.GenerateArchitectureGraph(num_qubits, method_AG)
'''calculate shortest path and its length'''
shortest_length_G = ct.ShortestPath(G)[0]
label_shortest_dis = [0] * num_data
for k in range(num_data):
for i in range(num_qubits):
for j in range(num_qubits):
if data_set[k][i][j] == 1:
label_shortest_dis[k] += shortest_length_G[i][j] - 1
for i in range(num_data):
error2.append(label_shortest_dis[i] - res[i])
#print('error is ', error)
print('max error between our method and ANN is ', max(error))
print('max error between sum of shoteset path and ANN is ', max(error2))
def CreateRandomDataSet(num_data, num_qubits, method_AG, num_layer=1):
'''
generate data set for single layer containing only CNOT gates
'''
'''generate quantum qubits'''
q_phy = QuantumRegister(num_qubits, 'v')
q_log = QuantumRegister(num_qubits, 'q')
'''generate architecture graph'''
'''q0 - v0, q1 - v1, ...'''
G = ct.GenerateArchitectureGraph(num_qubits, method_AG)
DiG = None
if isinstance(G, DiGraph): #check whether it is a directed graph
DiG = G
G = nx.Graph(DiG)
'''only use single swap'''
possible_swap_combination = []
edges = list(G.edges()).copy()
for current_edge in edges:
possible_swap_combination.append([current_edge])
'''calculate shortest path and its length'''
if DiG == None:
res = ct.ShortestPath(G)
shortest_path_G = res[1]
shortest_length_G = (res[0], res[2])
else:
res = ct.ShortestPath(DiG)
shortest_path_G = res[1]
shortest_length_G = (res[0], res[2])
'''create data set for 1 layer'''
if num_layer == 1:
data_set = []
label_set = []
for i in range(num_data):
print('generating ', i+1, '/', num_data,'data')
num_CNOT = GenNumCNOT(np.floor(num_qubits/2))
data_add, label_add = CreateOneRandomData(num_CNOT, num_qubits, G, q_phy, q_log,
shortest_length_G, shortest_path_G,
possible_swap_combination)
data_set.append(data_add)
label_set.append(label_add)
else:
data_set = np.zeros([num_data, num_layer, num_qubits, num_qubits]).astype(np.float32)
label_set = np.zeros([num_data]).astype(np.float32)
# =============================================================================
# for i in range(num_data):
# print('generating ', i+1, '/', num_data,'data')
# num_CNOT = GenNumCNOTMultiLayer(np.floor(num_qubits/2), num_layer)
# # print('num of CNOTs are ', num_CNOT)
# data_add, label_add = CreateOneRandomDataMultiLayer(
# num_CNOT, num_qubits,G, q_phy, q_log, shortest_length_G,
# shortest_path_G, possible_swap_combination, num_layer)
# data_set[i] = data_add
# label_set[i] = label_add
# =============================================================================
'''map implememtation for multi-layers'''
print('generating CNOT numbers')
num_CNOT = futures.map(GenNumCNOTMultiLayer, [np.floor(num_qubits/2)]*num_data,
[num_layer]*num_data)
print('generating layer layouts and labels')
res = futures.map(CreateOneRandomDataMultiLayer, num_CNOT, [num_qubits]*num_data,
[G]*num_data, [q_phy]*num_data, [q_log]*num_data,
[shortest_length_G]*num_data, [shortest_path_G]*num_data,
[possible_swap_combination]*num_data, [num_layer]*num_data)
print('processing output data')
i = -1
for data in res:
i += 1
data_add, label_add = data
data_set[i] = data_add
label_set[i] = label_add
return data_set, label_set