def solve(self, verbose=False, num_repeats=50, target=None, debug=False):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
if debug:
return None
return Solution(self.matching, self.pre_evaluated_solution)
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats,
target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if debug:
return response
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
energies = list(response.data_vectors['energy'])
min_en = min(energies)
ret_match, valid = self.encode(list(response.samples())[energies.index(min_en)])
return Solution(self.matching, ret_match, energy=min_en)
def solve_multi_data(self, verbose=False, target=None, num_repeats=200):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving multiple solutions of MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
return [Solution(self.matching, self.pre_evaluated_solution)]
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats,
target=target, algorithm=SOLUTION_DIVERSITY)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
samples = pd.DataFrame()
for sample, energy, occ in response.record:
match, valid = self.encode_qa(sample.tolist())
stable, size = Solution(self.matching, match).is_stable()
samples = samples.append({"match": match, "sample": sample.tolist(),
"energy": energy, "occ": occ,
"valid": valid, "stable": stable, "size": size}, ignore_index=True)
return samples
def solve_multi(self, verbose=False, num_repeats=200):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving multiple solutions of MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
return [Solution(self.matching, self.pre_evaluated_solution)]
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
opt_en = self.get_optimal_energy(self.matching.size)
solutions = []
for sample, energy, occ in response.record:
if energy == opt_en:
match, valid = self.encode_qa(sample.tolist())
if verbose and not valid:
print("Invalid encoding and valid energy!")
solutions.append(Solution(self.matching, match))
return solutions
def qubo_extractor(img,file_name):
img_name, ext = file_name.split(".")
(M,N) = img.shape[0:2]
coupler_count = 0
Q = {}
for i in range(M):
for j in range(N):
foreground_node_id = (i*N*2)+(j*2)
background_node_id = foreground_node_id+1
#foreground qubit
Q[(foreground_node_id,foreground_node_id)] = unary_potential(img,1,i,j)
#background qubit
Q[(background_node_id,background_node_id)] = unary_potential(img,0,i,j)
#for qubits of same pixel - high cost should be given here to ensure both qubits are not open
Q[(foreground_node_id,background_node_id)] = 10
coupler_count += 1
#for neighbors
neighbors = find_neighbors(img,i,j)
for k in neighbors:
neighbor_foreground_node_id = (k[0]*N*2)+(k[1]*2)
neighbor_background_node_id = neighbor_foreground_node_id+1
#f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' )
#f.write(' '+ str(background_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' )
#f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' )
#f.write(' '+ str(background_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' )
#coupler_count += 1
#print(Q)
response = QBSolv().sample_qubo(Q)
result = list(response.samples())
counter = 1
out = []
array = result[0]
for i in array:
mode = counter
if(counter > (N*M*2)):
continue
if(mode%2 == 1):
if array[i] == 1:
out.append(int(255))
else:
out.append(0)
counter += 1
out=numpy.array(out)
out = out.reshape(M,N)
img_name, ext = file_name.split(".")
if(os.path.isdir("result/" + img_name) != 1):
call(["mkdir","result/" + img_name])
rel_path = "result/" +img_name + "/"
output_file_name = str(img_name) + "_out_python." + str(ext)
file_path = rel_path + output_file_name
scipy.misc.imsave(file_path,out)
def Solver(H,J):
from dwave_qbsolv import QBSolv
h=dict(enumerate(H.flatten(),0))
j=dict(((i,j),J[i][j]) for i in range(len(J)) for j in range(len(J[0])) if i>j and J[i][j] !=0)
response = QBSolv().sample_ising(h,j)
sample=list(response.samples())
value=list(sample[0].values())
return value
def solve(self, options):
"""
Options:
'solver' - see solver input to Qbsolve.sample, default 'tabu'
'top_samples' - int, how many samples to print
'visualize' - boolean,
'verbosity' - int, default 0 (low)
"""
DEFAULT_OPTIONS = {
'solver': 'tabu',
'top_samples': 1,
'visualize': False,
'verbosity': 0,
'repititions': 5
}
complete_options = DEFAULT_OPTIONS.copy()
complete_options.update(options)
# get hamiltonian
q = self.make_Q()
# from np matrix to dwave representation
Q = dimod.BinaryQuadraticModel.from_numpy_matrix(q)
total_time = 0
for _ in range(complete_options['repititions']):
start_time = timer()
# solve using QBSolv
response = QBSolv().sample(Q,
verbosity=complete_options['verbosity'],
solver=complete_options['solver'])
end_time = timer()
if not complete_options['no_time']:
print(f'time to solve: {end_time - start_time} s')
total_time += end_time - start_time
for sample_i, sample in enumerate(
response.samples()[0:complete_options['top_samples']]):
X = self.sample_to_x_ij_matrix(sample)
print(f'------- sample {sample_i} -------')
print('solution is valid:', self.is_solution_valid(X))
print('energy:', response.record.energy[sample_i])
print('total U:', self.objective_value(X.flat))
if complete_options['visualize']:
positions = self.sample_to_positions(sample)
self.plot_3d(positions)
avg_time = total_time / complete_options['repititions']
print(f'average time: {avg_time} s')
def Solver(H, J):
from dwave_qbsolv import QBSolv
from dwave.system.samplers import DWaveSampler
from dwave.system.composites import EmbeddingComposite
from dwave.cloud import Client
import itertools
import random
sampler = EmbeddingComposite(
DWaveSampler(token='DEV-34ebdd33f77f73904ed58bac612191ccdce89841'))
h = dict(enumerate(H.flatten(), 0))
j = dict(((i, j), J[i][j]) for i in range(len(J)) for j in range(len(J[0]))
if i > j and J[i][j] != 0)
response = QBSolv().sample_ising(h, j, solver=sampler)
sample = list(response.samples())
print(sample)
return sample
def solve_multi(self, verbose=True, num_repeats=100, target=None):
if self.qubo is None:
self.create_qubo()
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
n = self.matching.size
stable_energy = -3 / 2 * self.p1 * (n - 1) * n
energies = list(response.data_vectors['energy'])
samples = enumerate(list(response.samples()))
allowed_samples = [sample for idx, sample in samples if energies[idx] == stable_energy]
return [Solution(self.matching, self.encode(sample)) for sample in allowed_samples]
def solve(self, verbose=False, num_repeats=100, target=None):
if self.qubo is None:
self.create_qubo()
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
energies = list(response.data_vectors['energy'])
min_en = min(energies)
ret_match = self.encode(list(response.samples())[energies.index(min_en)])
return Solution(self.matching, ret_match)
def qb(dets, thresh=None, confidence=None, ax=None):
from dwave_qbsolv import QBSolv
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
if len(scores) == 0:
return []
elif len(scores) == 1:
return [0]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
ious = {} #np.zeros([len(x1), len(x1)])
w2 = 0.4
for i in range(len(x1)):
xx1 = np.maximum(x1[i], x1)
yy1 = np.maximum(y1[i], y1)
xx2 = np.minimum(x2[i], x2)
yy2 = np.minimum(y2[i], y2)
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas - inter)
for j in range(len(ovr)):
if i == j:
ious[i, i] = -(1 - w2) * scores[i]
ious[i, j] += w2 * ovr[j]
else:
ious[i, j] = w2 * ovr[j]
response = QBSolv().sample_qubo(ious, verbosity=0)
samples = list(response.samples())[0]
keep = []
for i in range(len(x1)):
if samples[i] == 1:
keep.append(i)
#if len(keep) == 0:
# keep_dets = np.ndarray((0, 4))
#else:
# keep_dets = dets[keep]
## print(keep_dets)
#return keep_dets
return keep
def QBSolve_QC_solution(Qdict,
token="DEV-3fd7a21d8cf1afa9655ac1d7e9cb809bc3d7f7dc",
print_energy=False):
"""This function use QC to get solution dictionary"""
endpoint = 'https://cloud.dwavesys.com/sapi'
sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=endpoint))
response = QBSolv().sample_qubo(Qdict, solver=sampler)
if print_energy:
print("energies=" + str(list(response.data_vectors['energy'])))
qb_solution = list(response.samples())
print("\n\nqb_solution: ", qb_solution)
return qb_solution
def QBSolve_classical_solution(Qdict, print_energy=False):
"""This function use classical QBSolve to get solution dictionary"""
start = time.clock()
response = QBSolv().sample_qubo(Qdict)
qb_solution = list(response.samples())
if print_energy:
print("energies=" + str(list(response.data_vectors['energy'])))
end = time.clock()
time_taken = end - start
print("Time taken by classical QBSolv: ", time_taken)
return qb_solution
def qbsolve(Q, size=30):
q_min = 0
a_min = []
response = QBSolv().sample_qubo(Q)
for res in response.samples():
a = np.empty(size)
for key in res:
a[key] = res[key]
#------------------------------------------
q = 0
for i in xrange(size):
for j in xrange(size):
if (i, j) in Q:
q += Q[(i, j)] * a[i] * a[j]
if q < q_min:
q_min = q
a_min = a
return a_min, q_min
J.setdefault((i, j), J_list[i][j])
print('提取出h:')
print(h)
print('提取出J：')
print(J)
# 调用qbsolve第三方库得出退火模拟的结果
count_all_first = 1000 # 输入调用第三方库的次数
correct_count = 0
count = 0
q_truth_1 = 659 # 输入质因子
q_truth_2 = 571 # 输入质因子
for i in range(count_all_first):
response = QBSolv().sample_ising(h, J)
print("粒子自旋态：")
spin = list(response.samples())
print(spin)
print("粒子自旋态对应能量值：")
energy = list(response.data_vectors['energy'])
print(energy)
# 反推回去q的值
q = 2 ** (len(q_list) + 1) + 1
for j in range(len(q_list)):
q_list[j] = (1 - spin[0][len(p_list) + j]) / 2
for j in range(len(q_list)):
q = q + q_list[j] * 2 ** (j + 1)
print('q的值为')
print(q)
if q == q_truth_1 or q == q_truth_2:
correct_count = correct_count + 1
def refine(G, sol, sp_size, obj, rmethod, spsolver, sp=None):
global buildSpTime
global solveTime
start = time.perf_counter()
if sp != None:
subprob = sp
elif rmethod == "spectral":
subprob = spectralGainSubProb(G, sol, sp_size)
elif rmethod == "pairwise":
subprob = pairwiseSubProb(G, sol, sp_size)
elif rmethod == "randpair":
subprob = randPairSubProb(G, sol, sp_size)
else:
subprob = randSubProb(G, sp_size, sol)
end = time.perf_counter()
buildSpTime += (end - start)
eGain = subprob[2]
mapProbToSubProb = subprob[1]
start = time.perf_counter()
if spsolver == "qbsolv":
Q = build_qubo(subprob[0])
response = QBSolv().sample_qubo(Q)
solution = response.samples()[0]
elif spsolver == "qaoa":
solution = qaoa(subprob[0])
elif spsolver == "gurobi":
solution = pyomo(subprob[0])
elif spsolver == "sampling":
solution = randSampleSolve(subprob[0])
end = time.perf_counter()
solveTime += (end - start)
if timer:
print(str(end - start) + "s solving subproblem")
n = G.numberOfNodes()
new_sol = {}
changed = set()
for i in range(n):
new_sol[i] = solution[mapProbToSubProb[i]]
if sol[i] != new_sol[i]:
changed.add(i)
new_obj = calc_obj(subprob[0], solution)
rGain = new_obj - obj
if showgain:
print(str(eGain) + " expected gain, " + str(rGain) + " real gain")
if new_obj > obj:
for x in G.iterNodes():
if sol[x] != new_sol[x]:
if sol[x] == 0:
S.remove(x)
T.append(x)
elif sol[x] == 1:
T.remove(x)
S.append(x)
if rmethod == 'pairwise':
for x in changed:
for y in G.iterNeighbors(x):
if new_sol[x] == new_sol[y]:
mapGain[x] -= 2 * G.weight(x, y)
mapGain[y] -= 2 * G.weight(x, y)
if new_sol[x] != new_sol[y]:
mapGain[x] += 2 * G.weight(x, y)
mapGain[y] += 2 * G.weight(x, y)
return (new_sol, new_obj, subprob)
else:
return (sol, obj, subprob)
elif i==j:
D[(i,j)]= Coefficients[i,j]
# Solve the Puzzle
use_qpu=True
if use_qpu:
solver_limit = 256
G = nx.complete_graph(solver_limit)
system = DWaveSampler(token='DEV-6189564036d19f88b3a555b4175a353d6d2c0218')
embedding = minorminer.find_embedding(D.keys(), system.edgelist)
print(embedding)
res = QBSolv().sample_qubo(D, solver=FixedEmbeddingComposite(system, embedding), solver_limit=solver_limit,token='DEV-6189564036d19f88b3a555b4175a353d6d2c0218', num_reads=20)
#Emb = EmbeddingComposite(DWaveSampler(token='DEV-6189564036d19f88b3a555b4175a353d6d2c0218'))
#res = Emb.sample_qubo(D, num_reads=10000)
else:
res = QBSolv().sample_qubo(D,num_repeats=20)
samples = list(res.samples())
energy = list(res.data_vectors['energy'])
print(samples)
print(energy)
# Represent the Results
for i in range(len(samples)):
result = samples[i]
output = []
# ignore ancillary variables, which are all negative, only get positive bits
for x in range(r*m*n):
output.append(result[x])
output = np.array(output)#DisplayOut(In,np.array(output),r)
F=output.reshape(r,m*n)
output=mapseq(F)
print("energy: {}_____________________________".format(energy[i]))
print(output)
#Weights in nodes (for right node states)
for node in G.nodes:
for i in range(num_colors - 1):
for j in range(num_colors - 1 - i):
Q[(num_colors * node + i, num_colors * node + 1 + i + j)] = v2
# +2 for all wrong edges (has a 1 on the same place)
for edge in G.edges:
for i in range(num_colors):
Q[(num_colors * edge[0] + i, num_colors * edge[1] + i)] = v3
print("Q = " + str(Q))
response = QBSolv().sample_qubo(Q)
samples = list(response.samples())
print("Solution = " + str(samples))
print("Energy = " + str(list(response.data_vectors['energy'])))
energy_test = v1 * n_nodes
if response.data_vectors['energy'][0] == energy_test:
plt.title('Successfully solved with ' + str(num_colors) + ' colors')
solving = False
else:
if num_colors == 10:
plt.title('Cannot be solved with 10 or less colors')
solving = False
else:
num_colors += 1
def solve_with_qbsolv(Q):
response = QBSolv().sample_qubo(Q, num_repeats=1000)
return response.samples()[0]
def Solver(H, J):
from dwave_qbsolv import QBSolv
response = QBSolv().sample_ising(H, J)
sample = list(response.samples())
return sample
import math
#number of variables
n = 12
file = open("rou12.QUBO", "rb")
QUBO = pickle.load(file)
file.close()
file = open("rou12.flow", "rb")
flows = pickle.load(file)
file.close()
file = open("rou12.dist", "rb")
distances = pickle.load(file)
file.close()
result = QBSolv().sample_qubo(QUBO, num_repeats=50, verbosity=0, solver='tabu')
samples = list(result.samples())
perm = np.zeros((n, ), dtype=int)
solution = ""
cost = 0
for i in range(n):
for j in range(n):
if samples[0][(i * n) + j] == 1:
solution = solution + " " + str(j + 1)
perm[i] = j + 1
print("solution", ":", solution)
for i in range(n):
for j in range(n):
cost += distances[i, j] * flows[int(perm[i] - 1), int(perm[j]) - 1]
print("cost:", cost)
(cost_poly.coeff_monomial(X[i]**1) if (i == j) else 0))
for i in range(num_qubits) for j in range(i, num_qubits)}
# execution on D-Wave simulator
from dwave_qbsolv import QBSolv
result_dwave = QBSolv().sample_qubo(Qubo)
#####################################
###### END EXECUTION ON D WAVE #####
#####################################
##########################
###### DATA TRANSFER #####
##########################
# take first result
# better: check for index with lowest energy
samples = list(result_dwave.samples())[0]
# select ids of all selected edges
ids = []
for i in range(len(samples)):
if (samples[i] == 1):
ids.append(i)
print(json.dumps({"ids": ids}))
##############################
###### END DATA TRANSFER #####
##############################
QUBO[(v, j)] = QUBO[(v, j)] + (2.0) * prefactor
# Prints QUBO Matrix to console (for debugging purpose)
# for v in range(0, length_of_QUBO):
# for j in range(v, length_of_QUBO):
# print(" %s, %s : %s " % (v, j, QUBO[(v, j)]))
# Call QBSolv
answer = QBSolv().sample_qubo(QUBO,
num_repeats=num_repeats,
seed=seed,
algorithm=algorithm,
verbosity=verbosity,
timeout=timeout,
solver_limit=solver_limit,
solver=solver,
target=target,
find_max=find_max)
# # Decode QBSolv answer
samples = list(answer.samples())
print "samples", samples
print "energies", list(answer.data_vectors['energy'])
# # Decode answer and print it to the console
for i in range(len(samples)):
print "Solution Nr", i
print samples[i]
for j in range(len(samples[0])):
if samples[i][j] == 1:
print facility_to_location[j]
import itertools
import networkx as nx
from dwave_qbsolv import QBSolv
from dwave.system.samplers import DWaveSampler
from dwave.system.composites import FixedEmbeddingComposite
import minorminer
# define (sub)problem size
solver_limit = 3
qubo_size = 4
# find embedding of subproblem-sized complete graph to the QPU
G = nx.complete_graph(solver_limit)
system = DWaveSampler()
embedding = minorminer.find_embedding(G.edges, system.edgelist)
# solve a random problem
Q = {
t: random.uniform(-1, 1)
for t in itertools.product(range(qubo_size), repeat=2)
}
response = QBSolv().sample_qubo(Q,
solver=FixedEmbeddingComposite(
system, embedding),
solver_limit=solver_limit)
print("Q=" + str(Q))
print("samples=" + str(list(response.samples())))
print("energies=" + str(list(response.data_vectors['energy'])))
def Solver(H, J):
response = QBSolv().sample_ising(H, J)
sample = list(response.samples())
return sample
def main(argv):
file = open(argv[1])
lines = file.readlines()
file.close()
#delete any comments and empty lines
for i in range(len(lines) - 1, -1, -1):
#delete the newline character at the end
temp = lines[i].split("\n")
lines[i] = temp[0]
temp = lines[i].split(" #")
lines[i] = temp[0]
temp = lines[i].split("#")
lines[i] = temp[0]
if (lines[i] is ""):
tmp = lines.pop(i)
numOfNodes = int(lines[0])
#initialize graph and nodes
graph = Graph()
for i in range(0, numOfNodes):
node = Node(i)
graph.addNode(node)
#initialize edges
nextLine = 1
numOfEdges = 0
for i in range(0, numOfNodes):
nodeIDs = lines[nextLine + i].split(" ")
for j in range(0, len(nodeIDs)):
nodeA = graph.getNodeWithID(i)
nodeB = graph.getNodeWithID(int(nodeIDs[j]))
edge_existing = nodeA.getEdgeWithNode(nodeB)
if not (edge_existing is None):
continue
edge_existing = nodeB.getEdgeWithNode(nodeA)
if not (edge_existing is None):
continue
edge = Edge(numOfEdges, nodeA, nodeB)
graph.addEdge(edge)
numOfEdges = numOfEdges + 1
#print the edges
# edges = graph.getEdges()
# for i in range(0, len(edges)):
# print(str(edges[i].getID()) + " A: " + str(edges[i].getNodes()[0].getID()) + " B: " + str(edges[i].getNodes()[1].getID()))
nextLine = nextLine + numOfNodes
numOfCars = int(lines[nextLine])
nextLine = nextLine + 1
#get original car routes for each car
carRoutes = []
for i in range(0, numOfCars):
carRoutes.append([])
for i in range(0, numOfCars):
nodeIDs = lines[nextLine + i].split("-")
route = []
for j in range(0, len(nodeIDs) - 1):
nodeA = graph.getNodeWithID(int(nodeIDs[j]))
nodeB = graph.getNodeWithID(int(nodeIDs[j + 1]))
edge = nodeA.getEdgeWithNode(nodeB)
route.append(edge)
carRoutes[i].append(route)
nextLine = nextLine + numOfCars
#get the alternate routes
numOfAlternateRoutes = 3
for i in range(0, numOfCars * (numOfAlternateRoutes - 1)):
carNum = int(lines[nextLine + i].split(" ")[0])
nodeIDs = (lines[nextLine + i].split(" ")[1]).split("-")
route = []
for j in range(0, len(nodeIDs) - 1):
nodeA = graph.getNodeWithID(int(nodeIDs[j]))
nodeB = graph.getNodeWithID(int(nodeIDs[j + 1]))
edge = nodeA.getEdgeWithNode(nodeB)
route.append(edge)
carRoutes[carNum].append(route)
Q = getQuboMatrix(carRoutes, numOfAlternateRoutes)
response = QBSolv().sample_qubo(Q)
result = list(response.samples())
result = result[0]
resultingEnergy = list(response.data_vectors['energy'])
resultingEnergy = resultingEnergy[0]
# print("samples=" + str(result))
# print("energies=" + str(list(response.data_vectors['energy'])))
print("roads taken:")
for i in range(0, len(result)):
if (result[i] == 1):
print("car " + str((i // numOfAlternateRoutes) + 1) + ": route " +
str((i % numOfAlternateRoutes) + 1))
print("Resulting energy: " + str(resultingEnergy))
def sample_from_distance_matrix(dist_matrix,
dist_mul=1,
const_mul=8500,
start=None,
end=None,
**kwargs):
"""Sample TSP qubo from given distance matrix and return lowest-energy sdolution.
This is basically the same as :py:func:`sample_from_locations` except it skips
calculation of distance matrix (which is instead given as parameter) and can
take into account starting and ending node.
"""
dist_matrix = np.array(dist_matrix)
number_of_locations = dist_matrix.shape[0]
max_distance = np.max(dist_matrix)
dist_matrix = dist_matrix / max_distance
qubo = construct_qubo(dist_matrix, dist_mul, const_mul)
use_dwave = kwargs.get('use_dwave', False)
token = kwargs.get('dwave_token', None)
solver = kwargs.get('solver', None)
if 'use_dwave' in kwargs:
del kwargs['use_dwave']
del kwargs['dwave_token']
import gc
if use_dwave:
try:
num_reads = 1000
if number_of_locations > 7:
num_reads = 2000
print("Start solving using D-Wave!")
# solver = EmbeddingComposite(DWaveSampler(token=token, endpoint=DWAVE_ENDPOINT))
result = solver.sample_qubo(qubo,
num_reads=num_reads,
chain_strength=const_mul * 2)
info = {
"total_time": result.info['timing']['total_real_time'] / 10e3,
"machine": "DWAVE 2000Q"
}
except Exception as e:
print(e)
print("D-Wave failed, switched to QBSolv!")
result = QBSolv().sample_qubo(qubo, **kwargs)
info = {"machine": "local"}
else:
print("Start solving using QBSolv")
result = QBSolv().sample_qubo(qubo, **kwargs)
info = {"machine": "local"}
print("Got answer!")
route = route_from_sample(next(iter(result.samples())),
number_of_locations, start, end)
mileage = calculate_mileage(dist_matrix * max_distance, route)
info['mileage'] = mileage
print("Problem solved!")
energy = result.data_vectors['energy'][0]
del solver
del result
gc.collect()
return TSPSolution(route, energy, mileage, info)