def test_3path(self):
bqm = dimod.BinaryQuadraticModel.from_ising({'a': 10}, {
'ab': -1,
'bc': 1
})
fixed = dimod.fix_variables(bqm)
self.assertEqual(fixed, {'a': -1, 'b': -1, 'c': 1})
def test_3path(self):
bqm = dimod.BinaryQuadraticModel.from_ising({'a': 10}, {
'ab': -1,
'bc': 1
})
with self.assertWarns(DeprecationWarning):
fixed = dimod.fix_variables(bqm)
self.assertEqual(fixed, {'a': -1, 'b': -1, 'c': 1})
def solve(Q, offset, b, f1, sampler):
bqm = dimod.BinaryQuadraticModel(Q, 'BINARY')
bqm.fix_variables(f1)
f2 = dimod.fix_variables(bqm)
bqm.fix_variables(f2)
f = {**f1, **f2}
sampleset = sampler.sample(bqm)
GS = sample_graph(G, b, f, sampleset.first.sample)
return GS, sampleset, sampleset.first.energy, GS.edges
def next(self, state, **runopts):
bqm = state.problem
sampleset = state.samples
fixed_vars = dimod.fix_variables(bqm, sampling_mode=self.sampling_mode)
# make a new bqm of everything not-fixed
subbqm = bqm.copy()
subbqm.fix_variables(fixed_vars)
# update the existing state with the fixed variables
newsampleset = sampleset.copy()
for v, val in fixed_vars.items():
# index lookups on variables are fast for SampleSets
newsampleset.record.sample[:, newsampleset.variables.index(v)] = val
# make sure the energies reflect the changes
newsampleset.record.energy = bqm.energies(newsampleset)
return state.updated(subproblem=subbqm, samples=newsampleset)
def anneal(C_i, C_ij, mu, sigma, l, strength_scale, energy_fraction, ngauges,
max_excited_states):
#Initialising h and J as dictionnaries
h = {}
J = {}
for i in range(len(C_i)):
h_i = -2 * sigma[i] * C_i[i]
for j in range(len(C_ij[0])):
if j > i:
J[(i, j)] = float(2 * C_ij[i][j] * sigma[i] * sigma[j])
h_i += 2 * (sigma[i] * C_ij[i][j] * mu[j])
h[i] = h_i
#applying cutoff
print("Number of J before : " + str(len(J))) #J before cutoff
float_vals = []
for i in J.values():
float_vals.append(i)
cutoff = np.percentile(float_vals, AUGMENT_CUTOFF_PERCENTILE)
to_delete = []
for k, v in J.items():
if v < cutoff:
to_delete.append(k)
for k in to_delete:
del J[k]
print("Number of J after : " + str(len(J))) # J after cutof
new_Q = {}
isingpartial = {}
if FIXING_VARIABLES:
#Optimising heuristically the number of coupling terms
Q, _ = dimod.ising_to_qubo(h, J, offset=0.0)
bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset=0.0)
simple = dimod.fix_variables(bqm, sampling_mode=False)
if simple == {}:
new_Q = Q
else:
Q_indices = []
for i in Q:
if i in simple.keys():
continue
else:
Q_indices.append(i)
new_Q = {key: Q[key] for key in Q_indices}
print('new length', len(new_Q))
isingpartial = simple
if (not FIXING_VARIABLES) or len(new_Q) > 0:
mapping = []
offset = 0
for i in range(len(C_i)):
if i in isingpartial:
mapping.append(None)
offset += 1
else:
mapping.append(i - offset)
if FIXING_VARIABLES:
new_Q_mapped = {}
for (first, second), val in new_Q.items():
new_Q_mapped[(mapping[first], mapping[second])] = val
h, J, _ = dimod.qubo_to_ising(new_Q_mapped)
#Run gauges
qaresults = []
print("Number of variables to anneal :" + str(len(h)))
for g in range(ngauges):
#Finding embedding
qaresult = []
embedded = False
for attempt in range(5):
a = np.sign(np.random.rand(len(h)) - 0.5)
float_h = []
for i in h.values():
float_h.append(i)
h_gauge = float_h * a
J_gauge = {}
for i in range(len(h)):
for j in range(len(h)):
if (i, j) in J:
J_gauge[(i, j)] = J[(i, j)] * a[i] * a[j]
try:
print("Trying to find embeding")
sampler = EmbeddingComposite(
DWaveSampler(token='secret_token'))
embedded = True
break
except ValueError: # no embedding found
print('no embedding found')
embedded = False
continue
if not embedded:
continue
print("emebeding found")
print("Quantum annealing")
try_again = True
while try_again:
try:
#Annealing, saving energy and sample list
sampleset = sampler.sample_ising(
h_gauge,
J_gauge,
chain_strength=strength_scale,
num_reads=200,
annealing_time=20)
try_again = False
except:
print('runtime or ioerror, trying again')
time.sleep(10)
try_again = True
print("Quantum done")
qaresult.append(sampleset.record[0][0].tolist())
qaresult = np.asarray(qaresult)
qaresult = qaresult * a
qaresults[g * nreads:(g + 1) * nreads] = qaresult
full_strings = np.zeros((len(qaresults), len(C_i)))
full_strings = np.asarray(full_strings)
qaresults = np.asarray(qaresults)
if FIXING_VARIABLES:
j = 0
for i in range(len(C_i)):
if i in isingpartial:
full_strings[:, i] = 2 * isingpartial[i] - 1
else:
full_strings[:, i] = qaresults[:, j]
j += 1
else:
full_strings = qaresults
s = np.asarray(full_strings)
energies = np.zeros(len(qaresults))
s[np.where(s > 1)] = 1.0
s[np.where(s < -1)] = -1.0
bits = len(s[0])
for i in range(bits):
energies += 2 * s[:, i] * (-sigma[i] * C_i[i])
for j in range(bits):
if j > i:
energies += 2 * s[:, i] * s[:, j] * sigma[i] * sigma[
j] * C_ij[i][j]
energies += 2 * s[:, i] * sigma[i] * C_ij[i][j] * mu[j]
unique_energies, unique_indices = np.unique(energies,
return_index=True)
ground_energy = np.amin(unique_energies)
if ground_energy < 0:
threshold_energy = (1 - energy_fraction) * ground_energy
else:
threshold_energy = (1 + energy_fraction) * ground_energy
lowest = np.where(unique_energies < threshold_energy)
unique_indices = unique_indices[lowest]
if len(unique_indices) > max_excited_states:
sorted_indices = np.argsort(
energies[unique_indices])[-max_excited_states:]
unique_indices = unique_indices[sorted_indices]
print("unique indices : ", unique_indices)
print(type(unique_indices[0]))
print(type(full_strings))
final_answers = full_strings[unique_indices]
print('number of selected excited states', len(final_answers))
return final_answers
else:
final_answer = []
print("Evrything resolved by FIXING_VARIABLES")
for i in range(len(C_i)):
if i in isingpartial:
final_answer.append(2 * isingpartial[i] - 1)
final_answer = np.array(final_answer)
return np.array([final_answer])
def main():
# Note: for the purposes of a code example, main() is written as a script
# Read user input
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = "problem.txt"
print("Warning: using default problem file, '{}'. Usage: python "
"{} <sudoku filepath>".format(filename, sys.argv[0]))
# Read sudoku problem
matrix = get_matrix(filename)
# Set up
n = len(matrix) # Number of rows/columns in sudoku
m = int(math.sqrt(n)) # Number of rows/columns in sudoku subsquare
digits = range(1, n + 1)
bqm = dimod.BinaryQuadraticModel({}, {}, 0.0, dimod.SPIN)
# Constraint: Each node can only select one digit
for row in range(n):
for col in range(n):
node_digits = [get_label(row, col, digit) for digit in digits]
one_digit_bqm = combinations(node_digits, 1)
bqm.update(one_digit_bqm)
# Constraint: Each row of nodes cannot have duplicate digits
for row in range(n):
for digit in digits:
row_nodes = [get_label(row, col, digit) for col in range(n)]
row_bqm = combinations(row_nodes, 1)
bqm.update(row_bqm)
# Constraint: Each column of nodes cannot have duplicate digits
for col in range(n):
for digit in digits:
col_nodes = [get_label(row, col, digit) for row in range(n)]
col_bqm = combinations(col_nodes, 1)
bqm.update(col_bqm)
# Constraint: Each sub-square cannot have duplicates
# Build indices of a basic subsquare
subsquare_indices = [(row, col) for row in range(3) for col in range(3)]
# Build full sudoku array
for r_scalar in range(m):
for c_scalar in range(m):
for digit in digits:
# Shifts for moving subsquare inside sudoku matrix
row_shift = r_scalar * m
col_shift = c_scalar * m
# Build the labels for a subsquare
subsquare = [
get_label(row + row_shift, col + col_shift, digit)
for row, col in subsquare_indices
]
subsquare_bqm = combinations(subsquare, 1)
bqm.update(subsquare_bqm)
# Constraint: Fix known values
for row, line in enumerate(matrix):
for col, value in enumerate(line):
if value > 0:
# Recall that in the "Each node can only select one digit"
# constraint, for a given cell at row r and column c, we
# produced 'n' labels. Namely,
# ["r,c_1", "r,c_2", ..., "r,c_(n-1)", "r,c_n"]
#
# Due to this same constraint, we can only select one of these
# 'n' labels (achieved by 'generators.combinations(..)').
#
# The 1 below indicates that we are selecting the label
# produced by 'get_label(row, col, value)'. All other labels
# with the same 'row' and 'col' will be discouraged from being
# selected.
bqm.fix_variable(get_label(row, col, value), 1)
# Solve BQM
fixed = fix_variables(bqm, sampling_mode=False)
bqm.fix_variables(fixed)
solution = KerberosSampler().sample(bqm, max_iter=10, convergence=3)
best_solution = solution.first.sample
# Print solution
solution_list = [k for k, v in best_solution.items() if v == 1]
solution_list.extend([k for k, v in fixed.items() if v == 1])
for label in solution_list:
coord, digit = label.split('_')
row, col = map(int, coord.split(','))
matrix[row][col] = int(digit)
for line in matrix:
print(*line, sep=" ") # Print list without commas or brackets
# Verify
if is_correct(matrix):
print("The solution is correct")
else:
print("The solution is incorrect")
G = generate_graph(**opts['generate'])
else:
print('Input data is not specified.')
raise
for e in nx.selfloop_edges(G):
G.remove_edge(*e)
# Generate QUBO
Q, offset, b, f1 = hamilton_qubo(G, True, False)
bqm = dimod.BinaryQuadraticModel(Q, 'BINARY')
bqm.offset = offset
# Fix variables
bqm.fix_variables(f1)
f2 = dimod.fix_variables(bqm)
bqm.fix_variables(f2)
f0 = {**f1, **f2}
print(
'# of nodes, edges, variables, fixed 1, 2 & total, energy, node with no inedge, multi inedges, no outedges, multi outedges, cycles'
)
print(G.number_of_nodes(),
G.number_of_edges(),
bqm.num_variables,
len(f1),
len(f2),
len(f0),
end=' ')
# Choose one of the solvers below.