def test_neal(self):
import neal
h = {'a': -1, 'b': +1}
J = {('a', 'b'): -1}
resp = neal.SimulatedAnnealingSampler().sample_ising(h, J)
def test_close_to_pois(self):
"""Check that 1 new / 0 old chargers scenario is close to centroid of POIs"""
w, h = (15, 15)
num_poi, num_cs, num_new_cs = (3, 0, 1)
_, pois, charging_stations, potential_new_cs_nodes = demo.set_up_scenario(
w, h, num_poi, num_cs)
pois = [(0, 0), (6, 14), (14, 0)]
centroid = np.array(pois).mean(axis=0).round().tolist()
bqm = demo.build_bqm(potential_new_cs_nodes, num_poi, pois, num_cs,
charging_stations, num_new_cs)
# random.seed(1)
sampler = neal.SimulatedAnnealingSampler()
new_charging_nodes = demo.run_bqm_and_collect_solutions(
bqm, sampler, potential_new_cs_nodes, seed=42)
new_cs_x = new_charging_nodes[0][0]
new_cs_y = new_charging_nodes[0][1]
self.assertLess(new_cs_x - centroid[0], 5)
self.assertLess(new_cs_y - centroid[1], 5)
def simulatedNeal(h, J, i, j):
h, J = convertCompatible(h, J)
# print(h)
# print(J)
sampler = neal.SimulatedAnnealingSampler()
sampler.parameters['sweeps'] = i
sampler.parameters['num_reads'] = j
response = sampler.sample_ising(h, J, sweeps=i, num_reads=j)
# k=np.array(response.record)
energies = response.record['energy']
sigmas = response.record['sample']
# k=np.min(energies)
############################
##### minIdx=list(energies).index(np.min(energies))
##########################
##### minSigma=sigmas[minIdx]
##### minSigma=minSigma.astype('float32')
# p=[k[i][0] for i in range(len(k))]
# print(response.record)
# for datum in response.data(['sample', 'energy']):
# energy0.append(datum.energy)
# sigma=list(datum.sample.values())
# print(response.record,min(energy0))
# return sigma,min(energy0)
##### minSigma=nn.Parameter(torch.from_numpy(minSigma))
return sigmas, energies
def get_solver(solver_type: str, solver_name: str, token):
filters = {}
if solver_type.endswith("QPU") and solver_name in QPU_SOLVER_NAME_LIST:
filters[
"topology__type"] = "pegasus" if solver_name == "ADVANTAGE" else "chimera"
filters[
"name__contains"] = "Advantage_system" if solver_name == "ADVANTAGE" else "DW_2000Q"
if solver_type.endswith(
"HYBRID") and solver_name in HYBRID_SOLVER_NAME_LIST:
filters[
"name__contains"] = "version2" if solver_name == "HYBRID_V2" else "v1"
if solver_type == "SA":
solver = neal.SimulatedAnnealingSampler()
elif solver_type == "QPU":
solver = DWaveSampler(client="qpu", solver=filters, token=token)
solver = EmbeddingComposite(solver)
elif solver_type == "HYBRID":
solver = LeapHybridSampler(solver=filters, token=token)
elif solver_type == "FIXED_QPU":
solver = DWaveSampler(client="qpu", solver=filters, token=token)
solver = LazyFixedEmbeddingComposite(solver)
elif solver_type == "CLIQUE_FIXED_QPU":
solver = DWaveCliqueSampler(client="qpu", solver=filters, token=token)
else:
raise NotImplementedError(
"Solver {} is not implemented".format(solver_type))
return solver
def solve_ising(linear, quad, num_reads=10, sweeps=1000, beta_range=(1.0, 50.0)):
"""Solve Ising model with Simulated Annealing (SA) provided by neal.
Args:
linear (dict[label, float]): The linear parameter of the Ising model.
quad (dict[(label, label), float]): The quadratic parameter of the Ising model.
num_reads (int, default=10): Number of run repetitions of SA.
sweeps (int, default=1000): Number of iterations in each run of SA.
beta_range (tuple(float, float), default=(1.0, 50.0)): Tuple of start beta and end beta.
Returns:
dict[label, bit]: The solution of SA.
>>> from pyqubo import Spin, solve_ising
>>> s1, s2, s3 = Spin("s1"), Spin("s2"), Spin("s3")
>>> H = (2*s1 + 4*s2 + 6*s3)**2
>>> model = H.compile()
>>> linear, quad, offset = model.to_ising()
>>> solution = solve_ising(linear, quad)
"""
max_abs_value = float(max(abs(v) for v in (list(quad.values()) + list(linear.values()))))
scale_linear = {k: float(v) / max_abs_value for k, v in linear.items()}
scale_quad = {k: float(v) / max_abs_value for k, v in quad.items()}
sa = neal.SimulatedAnnealingSampler()
sa_computation = sa.sample_ising(scale_linear, scale_quad, num_reads=num_reads,
sweeps=sweeps, beta_range=beta_range)
best = np.argmin(sa_computation.record.energy)
best_solution = list(sa_computation.record.sample[best])
return dict(zip(sa_computation.variables, best_solution))
def solve_qubo_simulated(Q, all=False, num_reads=10000):
#solver = dimod.SimulatedAnnealingSampler()
solver = neal.SimulatedAnnealingSampler()
start = time.time()
response = solver.sample_qubo(Q, num_reads=num_reads)
qpu_time = time.time() - start
# Count the number of ocurrences
ocurrences = defaultdict(int)
for sample, energy in response.data(['sample', 'energy']):
frozen_sample = frozenset(sample.items())
ocurrences[frozen_sample] += 1
# Format the solutions
solutions_list = []
printed_sols = defaultdict(bool)
for sample, energy in response.data(['sample', 'energy']):
frozen_sample = frozenset(sample.items())
if not printed_sols[frozen_sample]:
printed_sols[frozen_sample] = True
solutions_list.append([sample, energy, ocurrences[frozen_sample]])
# Sort the solutions by increasing energy
sorted_sols = sorted(solutions_list, key=lambda x: +x[1])
return sorted_sols, qpu_time
def QUBOSolve_SA(coo_qubo, offset, N, num_reads=100, num_sweeps=1000):
qubo_dict = dict(
zip([('X[%d]' % (i), 'X[%d]' % (j))
for (i, j) in zip(coo_qubo.row, coo_qubo.col)], coo_qubo.data))
sampler = neal.SimulatedAnnealingSampler()
start = time.time()
response = sampler.sample_qubo(qubo_dict,
num_reads=num_reads,
num_sweeps=num_sweeps)
end = time.time()
# create a solution lil matrix, since most of entries would be zero
# and lil is friendly to change data
# and fill it
lil_sol = lil_matrix((N, N), dtype=np.uint8)
for (key, value) in response.first.sample.items():
if int(value) != 0:
idx = int(re.findall(r'\d+', key)[0])
row, col = int(idx / N), int(idx % N)
lil_sol[row, col] = 1
print('Elapsed %.2f seconds' % (end - start))
print('Energy: %.2f' % (response.first.energy + offset))
return lil_sol.tocsr()
def simulated_annealing(self):
print("\nSimulated Annealing....")
import neal
qpu = neal.SimulatedAnnealingSampler()
self.title = "Simmulated Annealer"
selected_features = np.zeros((len(self.features), len(self.features)))
for k in range(1, len(self.features) + 1):
flag = False
print("Submitting for k={}".format(k))
kbqm = dimod.generators.combinations(self.features, k, strength=25)
kbqm.update(self.bqm)
kbqm.normalize()
while not flag:
result = qpu.sample(kbqm, num_reads=10)
# result = qpu.sample_ising(kbqm.to_ising()[0], kbqm.to_ising()[1], num_reads=10)
best = result.first.sample
if list(result.first.sample.values()).count(1) == k:
flag = True
for fi, f in enumerate(self.features):
selected_features[k - 1, fi] = best[f]
if self.is_notebook:
from helpers.draw import plot_feature_selection
from helpers.plots import plot_solutions
plot_feature_selection(self.features, selected_features,
self.title)
def next(self, state, **runopts):
new_samples = neal.SimulatedAnnealingSampler().sample(
state.problem, initial_states=state.samples,
beta_range=(self.beta, self.beta), beta_schedule_type='linear',
num_sweeps=self.num_sweeps).aggregate()
return state.updated(samples=new_samples)
def execute(self, buffer, program):
import neal
from collections import Counter
counter = 0
h = {}
J = {}
for inst in program.getInstructions():
if inst.bits()[0] == inst.bits()[1]:
h[counter] = inst.getParameter(0)
counter += 1
else:
J[(inst.bits()[0], inst.bits()[1])] = inst.getParameter(0)
sampler = neal.SimulatedAnnealingSampler()
response = sampler.sample_ising(h, J, num_reads=self.shots)
energies = [d.energy for d in response.data(['energy'])]
counts_list = []
unique_config_to_energy = {}
for i, sample in enumerate(response):
l = list(sample.values())
st = ''
for li in l:
st += '1' if li == 1 else '0'
counts_list.append(st)
if not st in unique_config_to_energy:
unique_config_to_energy[st] = energies[i]
counts = Counter(counts_list)
buffer.setMeasurements(counts)
buffer.addExtraInfo('unique-configurations', unique_config_to_energy)
def solve_q(self):
'''
######################################################
Ekq -> E2q -> E2s ->SOL(si)-> SOL(qi)
######################################################
'''
print('Problem with a type-q (boolean 0/1) variable')
varOrg, varStd, Ekq = eq_standardized(self.Ekx, 'q')
self.Ekq = Ekq
#
self.var_original = varOrg
self.var_standard = varStd
##
if self.verbose:
print('Problem in symbolic standard format: ', Ekq)
# simplifying qi**2 <- 1
#Hkq=simplify_squares(expand(Ekq))
Hkq = expand(simplify_sq_squares(expand(Ekq), 'q'))
self.Hkq = Hkq
if self.verbose:
print('Simplified Hkq=', Hkq)
# Ekq-> E2q
H2q = boole_reduce(Hkq, self.delta)
self.H2q = H2q
if self.verbose:
print('H2q=', H2q)
# ALT-1: H2q->H2s, then solve using ising SA
# ALT-2: solve H2q using q-doman SA solver
# ----------------------
# choose ALT-1: H2s
# ----------------------
H2s = Hkq2Hks(H2q)
self.H2s = H2s
if self.verbose:
print('H2s=', H2s)
#
self.extract_ising_coeffs()
'''
-----------------------------------------------------------------------------
4. SOLVE THE PROBLEM
-----------------------------------------------------------------------------
select a solver
> dimod: ExaxtSolver
> neal: SimulatedAnnealingSampler
'''
#
print('Solving the problem using neal ...')
solver = neal.SimulatedAnnealingSampler()
response = solver.sample_ising(self.ising_h, self.ising_J, \
sweeps=self.NSWEEPS, \
num_reads=self.NREADS)
vE = response.data_vectors['energy']
aSol = response.samples_matrix
idxMinE = np.argmin(vE)
tSol = aSol[idxMinE]
# copy solution to global class variables
self.min_configuration = vs2q(tSol[0])
self.min_energy = vE[idxMinE]
self.energies = vE
self.configurations = vs2q(aSol)
def solve(self):
if (self.useQPU):
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample_qubo(self.Q,
num_reads=self.n_reads,
chain_strength=self.chain)
elif (self.useNeal):
bqm = BinaryQuadraticModel.from_qubo(self.Q, offset=self.offset)
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm,
num_reads=self.n_reads,
chain_strength=self.chain)
elif (self.useHyb):
bqm = BinaryQuadraticModel.from_qubo(self.Q, offset=self.offset)
sampler = LeapHybridSampler()
sampleset = sampler.sample(bqm, num_reads=self.n_reads)
else:
bqm = BinaryQuadraticModel.from_qubo(self.Q, offset=self.offset)
sampler = TabuSampler()
sampleset = sampler.sample(bqm,
num_reads=self.n_reads,
chain_strength=self.chain)
self.sampleset = sampleset
def test_solution_quality(self):
"""Run demo.py with no POIs or existing chargers to locate two new chargers"""
w, h = (15, 15)
num_poi, num_cs, num_new_cs = (0, 0, 2)
_, pois, charging_stations, potential_new_cs_nodes = demo.set_up_scenario(
w, h, num_poi, num_cs)
bqm = demo.build_bqm(potential_new_cs_nodes, num_poi, pois, num_cs,
charging_stations, num_new_cs)
# random.seed(1)
sampler = neal.SimulatedAnnealingSampler()
new_charging_nodes = demo.run_bqm_and_collect_solutions(
bqm, sampler, potential_new_cs_nodes, seed=1)
new_cs_dist = 0
for i in range(num_new_cs):
for j in range(i + 1, num_new_cs):
new_cs_dist += abs(new_charging_nodes[i][0] -
new_charging_nodes[j][0]) + abs(
new_charging_nodes[i][1] -
new_charging_nodes[j][1])
self.assertGreater(new_cs_dist, 10)
def simulatedNeal(h,J):
h,J=convertCompatible(h,J)
sampler=neal.SimulatedAnnealingSampler()
response = sampler.sample_ising(h, J)
for datum in response.data(['sample', 'energy']):
energy=datum.energy
sigma=list(datum.sample.values())
return sigma,energy,response
def __init__(self, exact=False):
super().__init__()
self._exact = exact
if self._exact:
# dimod's brute force solver
self._solver = dimod.ExactSolver()
else:
# Simulated annealing (SA)
self._solver = neal.SimulatedAnnealingSampler()
def simulated_annealing(QUBO):
bqm = dimod.BQM.from_qubo(QUBO)
sampler = neal.SimulatedAnnealingSampler()
#response = sim_sample(sampler, bqm)
response = real_sample(sampler, bqm)
return response
def sample_on_dwave(Q, Quantum=False):
bqm = dimod.BinaryQuadraticModel.from_numpy_matrix(Q)
if Quantum:
# Real
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
return sampler.sample(bqm, chain_strength=chstr)
# Simulated
sampler = neal.SimulatedAnnealingSampler()
return sampler.sample(bqm=bqm, num_reads=numr)
def test_response_converter(self):
try:
from dimod.sampleset import SampleSet
import neal
except ImportError:
print(' skip')
return
neal_sampler = neal.SimulatedAnnealingSampler()
Q = {(1, 2): -1, (2, 3): -1}
response = neal_sampler.sample_qubo(Q)
oj_res = oj.convert_response(response)
def num_of_errors_in_chain_strengths(qpu=False):
jobs = {
"1": [(0, 2), (1, 1), (2, 1)],
"2": [(1, 1), (0, 1), (3, 2)],
"3": [(2, 1), (3, 1), (1, 1)]
}
strengths = (0.5, 1, 1.5, 1.8, 2.0, 2.1, 2.3, 2.5, 3.0, 3.5, 4.0)
errors = defaultdict(list)
for strength in strengths:
for i in range(12):
print("tick " + str(strength) + " " + str(i))
try:
bqm = get_jss_bqm(jobs,
8,
stitch_kwargs={'min_classical_gap': 2.0})
if qpu:
sampler = EmbeddingComposite(
DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(bqm,
chain_strength=strength,
num_reads=1000)
else:
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, num_reads=1000)
sol_dict = printResults(sampleset, jobs)
errors[strength].append(sol_dict['error'])
except Exception as e:
print(f"error: {strength}")
print(e)
continue
medians = []
margins = []
for key, values in errors.items():
values.sort()
values = values[1:-1]
medians.append(median(values))
margins.append([
abs(values[0] - median(values)),
abs(values[-1] - median(values))
])
plt.errorbar(errors.keys(),
medians,
yerr=np.array(margins).T,
fmt='o-',
color='blue')
plt.xlabel('chain strength')
plt.ylabel('number of error solutions provided (out of 1000)')
# plt.show()
plt.savefig('chain_strength.png')
print(errors)
def solve_s(self):
'''
solve problem with variable 's'
'''
print('Problem with a type-s (spin -1,+1) variable')
varOrg, varStd, Eks = eq_standardized(self.Ekx, 's')
#
self.var_original = varOrg
self.var_standard = varStd
print('problem in symbolic standard format', Eks)
# remove squared variables
#Hks=simplify_squares(expand(Eks))
Hks = expand(simplify_sq_squares(expand(Eks), 's'))
self.Hks = Hks
if self.verbose:
print('Hks->', Hks)
# k-body to 2-body conversion, assume that k-max is 4
Hkq = Hks2Hkq(Hks)
self.Hkq = Hkq
H2q = boole_reduce(Hkq, self.delta)
self.H2q = H2q
H2s = Hkq2Hks(H2q)
self.H2s = H2s
#
self.extract_ising_coeffs()
'''
-----------------------------------------------------------------------------
4. SOLVE THE PROBLEM
-----------------------------------------------------------------------------
select a solver
> dimod: ExaxtSolver
> neal: SimulatedAnnealingSampler
'''
#
print('Solving the problem using neal ...')
solver = neal.SimulatedAnnealingSampler()
response = solver.sample_ising(self.ising_h, self.ising_J, sweeps=self.NSWEEPS, \
num_reads=self.NREADS)
#
vE = response.data_vectors['energy']
aSol = response.samples_matrix
#
idxMinE = np.argmin(vE)
tSol = aSol[idxMinE]
# copy solution to class global variables
self.min_configuration = tSol[0]
self.min_energy = vE[idxMinE]
self.energies = vE
self.configurations = aSol
def sa_solver(bqm, previous_solution, num_reads=100):
sampler = neal.SimulatedAnnealingSampler()
response = sampler.sample(bqm, num_reads=num_reads)
current_solution = previous_solution
for sample, energy in response.data(['sample', 'energy']):
if sum(sample.values()) > 0:
current_solution = sample
size = len(previous_solution)
solution = []
for i in range(size):
key = 'x[{}]'.format(i)
solution.append(current_solution[key])
current_solution = np.array(solution)
return current_solution
def num_of_errors_in_min_gap(qpu=False, start=1.0):
jobs = {"1": [(0, 2), (1, 1), (2, 1)],
"2": [(1, 1), (2, 2), (0, 1)],
"3": [(2, 2), (0, 1), (1, 2)]}
# best_solution = { "1": [0,2,4],
# "2": [0,2,4],
# "3": [0,2,3]}
# result: 5
import csv
# wyniki.csv structure:
# min_classical_gap, not found, incorrect, num_of_reads, 5, 6, 7, 8, 9, more
with open("wyniki_min_gap.csv", mode='a') as csvfile:
filewriter = csv.writer(csvfile, delimiter=',',
quotechar='|', quoting=csv.QUOTE_MINIMAL)
# strengths = (25, 30, 35, 40, 45)
# strengths = list(range(20, 25))
from numpy import arange
gaps = list(arange(start, start+.5, 0.1))
num_reads = 1000
for gap in gaps:
for _ in range(10):
try:
bqm = get_jss_bqm(jobs, 8, stitch_kwargs={
'min_classical_gap': gap})
if qpu:
sampler = EmbeddingComposite(
DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(
bqm, chain_strength=10.0, num_reads=num_reads)
else:
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, num_reads=num_reads)
sol_dict = printResults(sampleset, jobs)
except Exception as e:
print(f"error: {gap}")
print(e)
from time import sleep
sleep(60)
continue
result_row = [gap, sol_dict['error'], sol_dict['incorrect'],
num_reads] + [sol_dict[i] for i in range(5, 10)]
filewriter.writerow(result_row)
print('zapisane', gap)
from time import sleep
sleep(30)
def num_of_errors_in_times(qpu=False):
jobs = {
"1": [(0, 2), (1, 1), (0, 1)],
"2": [(1, 1), (0, 1), (2, 2)],
"3": [(2, 1), (2, 1), (1, 1)]
}
times = range(4, 12)
errors = defaultdict(list)
for time in times:
for i in range(12):
try:
bqm = get_jss_bqm(jobs,
time,
stitch_kwargs={'min_classical_gap': 2.0})
if qpu:
sampler = EmbeddingComposite(
DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(bqm,
chain_strength=2,
num_reads=1000)
else:
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, num_reads=1000)
sol_dict = printResults(sampleset, jobs)
errors[time].append(sol_dict['error'])
except:
print(f"error: {time}")
continue
medians = []
margins = []
for key, values in errors.items():
values.sort()
values = values[1:-1]
medians.append(median(values))
margins.append([
abs(values[0] - median(values)),
abs(values[-1] - median(values))
])
plt.errorbar(errors.keys(),
medians,
yerr=np.array(margins).T,
fmt='o',
color='blue')
plt.xlabel('max_time value')
plt.ylabel('number of error solutions provided (out of 1000)')
# plt.show()
plt.savefig('times.png')
print(errors)
def qubo(Coeff):
#print(" Coeff: {}".format(Coeff) )
lamda1 = -1
lamda4 = 100
Q1 = sum(x * Coeff)
H = lamda1 * Q1 + lamda4 * Q_mode_constrain
model = H.compile()
bqm = model.to_bqm()
sa = neal.SimulatedAnnealingSampler()
sampleset = sa.sample(bqm, num_reads=20)
decoded_samples = model.decode_sampleset(sampleset)
best_sample = min(decoded_samples, key=lambda x: x.energy)
opt = best_sample.sample
#print("SA-Opt:{} Energy:{}".format(best_sample.sample, best_sample.energy) )
return opt
def solve_ising(linear,
quad,
num_reads=10,
sweeps=1000,
beta_range=(1.0, 50.0)):
"""[deprecated] Solve Ising model with Simulated Annealing (SA) provided by neal.
Args:
linear (dict[label, float]): The linear parameter of the Ising model.
quad (dict[(label, label), float]): The quadratic parameter of the Ising model.
num_reads (int, default=10): Number of run repetitions of SA.
sweeps (int, default=1000): Number of iterations in each run of SA.
beta_range (tuple(float, float), default=(1.0, 50.0)): Tuple of start beta and end beta.
Note:
:func:`solve_ising` is deprecated. Use `dwave-neal` package instead like below.
>>> from pyqubo import Spin
>>> import neal
>>> s1, s2, s3 = Spin("s1"), Spin("s2"), Spin("s3")
>>> H = (2*s1 + 4*s2 + 6*s3)**2
>>> model = H.compile()
>>> bqm = model.to_bqm()
>>> sa = neal.SimulatedAnnealingSampler()
>>> sampleset = sa.sample(bqm, num_reads=10)
>>> samples = model.decode_sampleset(sampleset)
>>> best_sample = min(samples, key=lambda s: s.energy)
>>> pprint(best_sample.sample) # doctest: +SKIP
{'s1': 0, 's2': 0, 's3': 1}
"""
max_abs_value = float(
max(abs(v) for v in (list(quad.values()) + list(linear.values()))))
scale_linear = {k: float(v) / max_abs_value for k, v in linear.items()}
scale_quad = {k: float(v) / max_abs_value for k, v in quad.items()}
sa = neal.SimulatedAnnealingSampler()
sa_computation = sa.sample_ising(scale_linear,
scale_quad,
num_reads=num_reads,
num_sweeps=sweeps,
beta_range=beta_range)
best = np.argmin(sa_computation.record.energy)
best_solution = list(sa_computation.record.sample[best])
return dict(zip(sa_computation.variables, best_solution))
def __init__(self, B, K, C, gamma, xi, N, sampler_type) -> None:
self.gamma = gamma
self.B = B
self.K = K
self.C = C
self.xi = xi
self.N = N
self.sampler_type = sampler_type
if (sampler_type == 'HQPU'):
self.sampler = LeapHybridSampler()
if (sampler_type == 'SA'):
self.sampler = neal.SimulatedAnnealingSampler()
if (sampler_type == 'QPU'):
self.sampler = EmbeddingComposite(DWaveSampler())
pass
def qubo(Coeff):
print(" Coeff: {}".format(Coeff) )
lamda1 = -1; lamda4 = 100;
Q1 = sum(x*Coeff)
H = lamda1*Q1 + lamda4*Q_mode_constrain
model = H.compile()
bqm = model.to_bqm()
sa = neal.SimulatedAnnealingSampler()
sampleset = sa.sample(bqm, num_reads=20)
decoded_samples = model.decode_sampleset(sampleset)
best_sample = min(decoded_samples, key=lambda x: x.energy)
opt = best_sample.sample
#print("SA-Opt:{} Energy:{}".format(best_sample.sample, best_sample.energy) )
## Q: Is it possiable to have more than one activate mode in a junction if lambda4 is too small ?
## Do we have to check that ?
return opt
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 solve_qubo_simulated(Q,
all=False,
print_it=False,
save_it=False,
num_reads=10000):
#solver = dimod.SimulatedAnnealingSampler()
sampler = neal.SimulatedAnnealingSampler()
start = time.time()
response = sampler.sample_qubo(Q, num_reads=num_reads)
qpu_time = time.time() - start
# Count the number of ocurrences
ocurrences = defaultdict(int)
for sample, energy in response.data(['sample', 'energy']):
frozen_sample = frozenset(sample.items())
ocurrences[frozen_sample] += 1
# Print the results
if print_it:
printed = defaultdict(bool)
for sample, energy in response.data(['sample', 'energy']):
frozen_sample = frozenset(sample.items())
if not printed[frozen_sample]:
printed[frozen_sample] = True
print('({}, {}) --> {:.4f}'.format(sample,
ocurrences[frozen_sample],
energy))
if save_it:
target = open('results.txt', 'w')
target.write('{\n')
printed_2 = defaultdict(bool)
for sample, energy in response.data(['sample', 'energy']):
frozen_sample = frozenset(sample.items())
if not printed_2[frozen_sample]:
printed_2[frozen_sample] = True
target.write('{}: ({}, {:.4f}),\n'.format(
frozen_sample, ocurrences[frozen_sample], energy))
target.write('}')
return qpu_time
def next(self, state, **runopts):
beta = state.get('beta', self.beta)
seed = runopts.pop('seed', self.seed)
aggregate = runopts.pop('aggregate', self.aggregate)
new_samples = neal.SimulatedAnnealingSampler().sample(
state.problem,
initial_states=state.samples,
beta_range=(beta, beta),
beta_schedule_type='linear',
num_reads=self.num_reads,
initial_states_generator='tile',
num_sweeps=self.num_sweeps,
seed=seed)
if aggregate:
new_samples = new_samples.aggregate()
return state.updated(samples=new_samples)
