def QBSolve_quantum_solution(Q, times_list, token, annealing_time, print_energy=False):
"""This function use QC to get solution dictionary"""
Qdict = Q_dict(Q)
# print("QDICT: ", Qdict)
# endpoint = 'https://cloud.dwavesys.com/sapi'
# bqm = dimod.BinaryQuadraticModel.from_qubo(Qdict)
# print("BQM: ", bqm)
print("ACCESSING QUANTUM COMPUTER . . . . .")
print("Anneal time: ", annealing_time)
sampler = LeapHybridSampler(token=token)
start = time.clock()
# try:
response = sampler.sample_qubo(Qdict, qpu_params={'annealing_time': annealing_time})
timing_dict = response.info
# print("\n\n\n\nTIMING INFO: ", timing_dict)
qc_time = timing_dict["qpu_access_time"]
qc_time_list.append(qc_time)
print("\n\n\n\n\nQC TIMES UHUHUHUHUHHUHU", qc_time_list)
end = time.clock()
# print("INFO: ", response.info)
print("RESPONSE: ", response)
# except ValueError:
# print("\n\nEXCEPTION FOUND ...............\n")
# # response = QBSolv.QBSolv().sample_qubo(Qdict, solver=sampler)
# response = QBSolv.QBSolv().sample_qubo(Qdict)
# print("RESPONSE: ", response)
print("energies=" + str(list(response.data_vectors['energy'])))
print("num_occurence=" + str(list(response.data_vectors['num_occurrences'])))
if print_energy:
print("energies=" + str(list(response.data_vectors['energy'])))
time_taken = end - start
times_list.append(time_taken)
print("Time taken by QPU: ", time_taken)
qb_solution = list(response.samples())
qb_solution_list = list(qb_solution[0].values())
return qb_solution_list
def generate_stars(N: int, nstars: int, annealer="neal", num_reads=100):
"""
Generate valid star positions on grid.
Return a list of positions and an np.array.
Annealer may be:
1. 'neal' (simulated);
2. 'leap' (real)."""
g = 1
Q = constraint_two_dont_touch(N)
regions = [*row_regions(N), *column_regions(N)]
for region in regions:
Q = Q + g * region_constraint(region, nstars)
if annealer == 'neal':
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample_qubo(Q, num_reads=num_reads)
elif annealer == 'leap': # Go to DWave
sampler = LeapHybridSampler()
sampleset = sampler.sample_qubo(Q)
else:
raise Exception(f"Annealer {annealer} not recognized.")
minimum_theo = -2 * N * nstars**2 * g
valid_samples = []
sorted_records = sorted(sampleset.record, key=lambda r: r.energy)
variables = sampleset.variables
for record in sorted_records:
sample = {x_ij: value for x_ij, value in zip(variables, record.sample)}
energy = record.energy
cond_1 = confirm_solution_stars(sample, regions, nstars)
cond_2 = abs(energy - minimum_theo) < 1e-6
if not cond_1 | cond_2:
break
# Return a list of positions and an np.array.
yield star_solutions(N, sample)
def quantum_tsp(self):
sampler = LeapHybridSampler()
# Get a QUBO representation of the problem
Q = self.quantum_tsp_qubo()
# use the sampler to find low energy states
response = sampler.sample_qubo(Q)
sample = response.first.sample
route = [None] * len(self.G)
for (city, time), val in sample.items():
if val:
route[time] = city
if self.start is not None and route[0] != self.start:
# rotate to put the start in front
idx = route.index(self.start)
route = route[idx:] + route[:idx]
return route
def solve_puzzle(N, nstars, grid, annealer="neal", num_reads=10):
Q = constraint_two_dont_touch(N)
regions = [
*region_lists(grid),
*row_regions(N),
*column_regions(N),
]
g = 1
for region in regions:
Q = Q + g * region_constraint(region, nstars)
# Create Sampler
if annealer == 'neal':
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample_qubo(Q, num_reads=num_reads)
elif annealer == 'leap': # Go to DWave
sampler = LeapHybridSampler()
sampleset = sampler.sample_qubo(Q)
else:
raise Exception(f"Annealer {annealer} not recognized.")
minimum_energy = theoretical_minimum(N, nstars, g)
sorted_records = sorted(sampleset.record, key=lambda r: r.energy)
variables = sampleset.variables
for record in sorted_records:
sample = {x_ij: value for x_ij, value in zip(variables, record.sample)}
energy = record.energy
is_solution = confirm_solution_stars(sample, regions, nstars)
if is_solution:
_, solution = star_solutions(N, sample)
return solution
def generate_regions(N: int, nstars: int, star_positions: list, star_grid: np.array, annealer="neal", num_reads=100):
# Build Star Finder QUBO
g1, g2, g3, g4 = 1, 1, 1, 1
color_size = np.array([N]*N) #Number of sites per color
Q_reg_1 = g1 * constraint_sum_of_stars(N, nstars, star_positions)
Q_reg_2 = g2 * constraint_unique_color(N)
Q_reg_3 = g3 * constraint_contiguous(N)
Q_reg_4 = g4 * constraint_sum_of_sites(N,color_size)
Q_reg = Q_reg_1 + Q_reg_2 + Q_reg_3 + Q_reg_4
if annealer == 'neal':
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample_qubo(Q_reg, num_reads=num_reads)
elif annealer == 'leap': # Go to DWave
sampler = LeapHybridSampler()
sampleset = sampler.sample_qubo(Q_reg)
else:
raise Exception(f"Annealer {annealer} not recognized.")
upper_bound = -g1*N*nstars**2 -g2*N**2 -g4*np.sum(color_size**2)
lower_bound = upper_bound - g3*4*N**2
# Confirm Solution of Regions
sample_star = {x(i, j): value for (i, j), value in np.ndenumerate(star_grid)}
sorted_records = sorted(sampleset.record, key=lambda r: r.energy)
variables = sampleset.variables
for record in sorted_records:
sample = {x_ij: value for x_ij, value in zip(variables, record.sample)}
energy = record.energy
grid = grid_solutions(N, sample)
regions = [*region_lists(grid), *row_regions(N), *column_regions(N)]
if confirm_solution_regions(sample_star, grid, nstars):
yield grid
H_time = Constraint(normalize(sum((sum(q[i][t] for i in range(N-1))-1)**2 for t in range(N-1))), 'time')
# Express objective function and compile it to model
H = H_cost + Placeholder('lam') * (H_city + H_time)
model = H.compile()
# --- Solve QUBO ---
# Get the QUBO matrix from the model
feed_dict = {'lam':5.0} # the value of constraint
qubo, offset = model.to_qubo(feed_dict=feed_dict)
# Run QUBO on Leap's Hybrid Solver (hybrid_v1)
sampler = LeapHybridSampler(token='')
response = sampler.sample_qubo(qubo)
sample = response.record['sample'][0]
# decode the solution and check if constrains are satisfied
sample_dict = {idx: sample[i] for i,idx in enumerate(response.variables)}
decoded, broken, energy = model.decode_solution(sample_dict, 'BINARY', feed_dict=feed_dict)
if broken == {}:
print('The solution is valid')
else:
print('The solution is invalid')
# --- Visualize the result ---
# Create an array which shows traveling order from the solution
solution = sample.reshape(N-1, N-1)
Q[(return_QUBO_Index(v,j), return_QUBO_Index(w,j))] += 2*A
Q[(return_QUBO_Index(w,j), return_QUBO_Index(v,j))] += 2*A
# Objective that minimizes distance
for u in range(Total_Number_Houses):
for v in range(Total_Number_Houses):
if u!=v:
for j in range(Total_Number_Houses):
Q[(return_QUBO_Index(u,j), return_QUBO_Index(v,(j+1)%Total_Number_Houses))] += B*D[u][v]
# Run the QUBO using qbsolv (classically solving)
#resp = QBSolv().sample_qubo(Q)
# Use LeapHybridSampler() for faster QPU access
sampler = LeapHybridSampler()
resp = sampler.sample_qubo(Q)
# First solution is the lowest energy solution found
sample = next(iter(resp))
# Display energy for best solution found
print('Energy: ', next(iter(resp.data())).energy)
# Print route for solution found
route = [-1]*Total_Number_Houses
for node in sample:
if sample[node]>0:
j = node%Total_Number_Houses
v = (node-j)/Total_Number_Houses
route[j] = int(v)
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
from dwave.system import LeapHybridSampler
sampler = LeapHybridSampler()
GAMMA = 1.5
#exactsolver = dimod.ExactSolver()
Q = {('X1','X2'): 2 * GAMMA - 2,
('X1','X3'): 2 * GAMMA - 2,
('X1','X4'): 2 * GAMMA - 2,
('X2','X3'): 2 * GAMMA - 2,
('X2','X4'): 2 * GAMMA - 2,
('X3','X4'): 2 * GAMMA - 2,
('X1','X1'): 3 - 3 * GAMMA,
('X2','X2'): 3 - 3 * GAMMA,
('X3','X3'): 3 - 3 * GAMMA,
('X4','X4'): 3 - 3 * GAMMA}
results = sampler.sample_qubo(Q)
# print the results
for sample, energy in results.data(['sample', 'energy']):
print(sample, energy)
#final hamiltonian
H = (min_sigx / scale_down + lambda1 * select_n + lambda2 * expectedReturn)
model = H.compile()
qubo, offset = model.to_qubo()
useQPU = True
num_samples_hybrid = 40
#number of times hybrid solver is used
if useQPU:
for _ in range(num_samples_hybrid):
# start = time.time()
sampler = LeapHybridSampler()
response = sampler.sample_qubo(qubo)
sample = response.first.sample
final_sigx = 0
for i in range(N):
for j in range(N):
final_sigx += sample['arr[{}]'.format(i)] * sample[
'arr[{}]'.format(j)] * sigma[i][j]
print(final_sigx)
# end = time.time()
# print(end - start,"s")
else:
sampler = neal.SimulatedAnnealingSampler()
response = sampler.sample_qubo(qubo, num_sweeps=1000, num_reads=1000)
Q = defaultdict(int)
for ele in range(0, len(S)):
c = c + S[ele]
#Linear value i.e diagonal values
for ele in range(0, len(S)):
Q[ele, ele] = S[ele]*(S[ele]-c)
#Quadratic value i.e off-diagonal values
for i in range(0, len(S)):
for j in range(0, len(S)):
if(i!=j):
Q[i, j] = S[i]*S[j]
print("\n\n---Create Q %s seconds ---" % (time.time() - start_time))
solve_start = time.time()
sampleset = sampler.sample_qubo(Q)
print("\n\n---Solved in %s seconds ---" % (time.time() - solve_start))
print(sampleset)
for sample in sampleset.samples():
print(sample)
print("\n\n---Execution end %s seconds ---" % (time.time() - start_time))
def solve(
N, # Number of data points
K, # Number of clusters
dist_matrix, # NxN matrix with distances between data points
gamma_distinct=None, # Coefficent for the penalty of being
gamma_multiple=None, # Coefficient for the penalty of being assigned to multiple clusters (illegal); should be very high
target_goal=None, # Target equal value for each cluster; by default, it's N//K
point_weights=None, # N-element Weight Vector for the points in the equal size constraint; by default , we assume all ones
):
if target_goal is None:
target_goal = N // K
if point_weights is None:
point_weights = np.ones(N)
if gamma_distinct is None:
gamma_distinct = np.max(dist_matrix)
if gamma_multiple is None:
gamma_multiple = np.max(
dist_matrix
) # weight bigger than sum of all distances, not worth taking more than one
group_matrix = Array.create("x", shape=(N, K), vartype="BINARY")
distinct_size_penalty = Placeholder("gamma_distinct")
multiple_assignment_penalty = Placeholder("gamma_multiple")
target = Placeholder("target_goal")
all_terms = []
# Penalty for being assigned to multiple clusters
for i in range(N):
single_asignment_constraint = (1 - sum(group_matrix[i, :]))**2
all_terms.append(multiple_assignment_penalty *
single_asignment_constraint)
# Penalty for exceding equal number of members per cluster
for j in range(K):
cluster_member_constraint = (
target - sum(point_weights * group_matrix[:, j]))**2
all_terms.append(distinct_size_penalty * cluster_member_constraint)
# Adding objective for distances. Must minimize distances in the same group
for i in range(N):
for j in range(i + 1, N):
same_group_combinations = group_matrix[i, :] * group_matrix[j, :]
all_terms.append(dist_matrix[i, j] * sum(same_group_combinations))
# Generate QUBO from equation that represents the DQM
equation = sum(all_terms)
model = equation.compile()
Q, offset = model.to_qubo(
feed_dict={
"gamma_distinct": gamma_distinct,
"gamma_multiple": gamma_multiple,
"target_goal": target_goal,
})
# Call D-Wave solver
sampler = LeapHybridSampler()
answer = sampler.sample_qubo(Q)
best_answer = list(answer.data(["sample", "energy"]))[0].sample
# Utility function to map from QUBO temp matrix label to integer
def matrix_entry_to_pair(val):
_, i, j = val.replace("[", " ").replace("]", " ").split()
return (int(i), int(j))
cluster_result = [
matrix_entry_to_pair(k) for k, v in best_answer.items() if v == 1
]
label_result = [p[1] for p in sorted(cluster_result)]
return label_result
# https://github.com/dwave-examples/simple-ocean-programs/blob/master/Basic_Programs/general_program_qubo.py
# Import the functions and packages that are used
from dwave.system import EmbeddingComposite, DWaveSampler, LeapHybridSampler
from neal import SimulatedAnnealingSampler
# Define the problem as a Python dictionary
Q = {('B','B'): 1,
('K','K'): 1,
('A','C'): 2,
('A','K'): -2,
('B','C'): -2}
###### D-WaveのQPU Samplerを用いる方法です。（Leap時間を消費します！）
# Define the sampler that will be used to run the problem
sampler = EmbeddingComposite(DWaveSampler())
# Run the problem on the sampler and print the results
sampleset = sampler.sample_qubo(Q, num_reads = 10)
print(sampleset)
###### Leap Hybrid samplerを用いる方法です。（Leap時間を消費します！）
sampler_hybrid = LeapHybridSampler()
sampleset_hybrid = sampler_hybrid.sample_qubo(Q,time_limit=3)
print(sampleset_hybrid)
###### Simulated Annealing samplerを用いる方法です。（Leap時間を消費しません）
sampler_neal = SimulatedAnnealingSampler()
sampleset_neal = sampler_neal.sample_qubo(Q, num_reads=10)
print(sampleset_neal.aggregate())