def __init__(self, num_reads=100, qpu_sampler=None):
super(QPUSubproblemExternalEmbeddingSampler, self).__init__()
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
self.sampler = qpu_sampler
def main():
"""Entrypoint of this script.
Synopsis is as follows:
- construct qubo of some predefined size
- solve it using QBSolv with patched sampler
- show what is recorded
"""
with open('dwave_credentials.txt') as token_file:
token = token_file.read()
qubo_dict = get_random_qubo(50)
sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=ENDPOINT))
with record_sampler_invocations(sampler) as records:
response = QBSolv().sample_qubo(qubo_dict,
solver_limit=30,
solver=sampler)
print('Sampler was invoked this many times: {}'.format(len(records)))
# In this example we take only qubo calls - when I tested it it were the only
# ones made
qubo_timings = [
record['timing'] for record in records if record['method'] == 'qubo'
]
total_sampling_time = sum(record['qpu_sampling_time']
for record in qubo_timings)
print('Average QPU sampling time [QUBO]: {}'.format(total_sampling_time /
len(qubo_timings)))
def test_typical(self):
class MockScheduleSampler(DWaveSampler):
parameters = {'anneal_schedule': ''}
properties = {
'max_anneal_schedule_points': 4,
'annealing_time_range': [1, 2000]
}
def __init__(self):
pass
DWaveSampler.validate_anneal_schedule(
MockScheduleSampler(),
[[0.0, 0.0], [0.2, 0.2], [5.2, 0.2], [6.0, 1.0]])
DWaveSampler.validate_anneal_schedule(MockScheduleSampler(),
[(0, 1), (55.0, 0.45),
(155.0, 0.45), (210.0, 1)])
def execute(self, buffer, program):
from dwave.system.samplers import DWaveSampler
from dwave.system.composites import EmbeddingComposite, FixedEmbeddingComposite
from collections import Counter
import dimod
h = {}
J={}
Q={}
for inst in program.getInstructions():
Q[(inst.bits()[0], inst.bits()[1])] = inst.getParameter(0)
if inst.bits()[0] == inst.bits()[1]:
h[inst.bits()[0]] = inst.getParameter(0)
else:
J[(inst.bits()[0], inst.bits()[1])] = inst.getParameter(0)
buffer.setSize(max(h.keys())+1)
if buffer.hasExtraInfoKey('embedding'):
sampler = FixedEmbeddingComposite(DWaveSampler(token=self.token, solver=self.backend), buffer['embedding'])
else:
sampler = EmbeddingComposite(DWaveSampler(token=self.token, solver=self.backend))
if program.getTag() == "ising":
response = sampler.sample_ising(h, J, num_reads=self.shots, return_embedding=True)
else:
response = sampler.sample_qubo(Q, chain_strength=self.chain_strength, num_reads=self.shots, return_embedding=True)
if not buffer.hasExtraInfoKey('embedding'):
# we used embeddingcomposite, get the computed
# embedding
emb = response.info['embedding_context']['embedding']
buffer.addExtraInfo('embedding', emb)
counts_list = []
e_map = {}
for r in response.record:
sample, energy, nocc, _ = r
bitstring = ''.join([str(s if s == 1 else 0) for s in sample])
for i in range(nocc):
counts_list.append(bitstring)
e_map[bitstring] = energy
counts = Counter(counts_list)
buffer.setMeasurements(counts)
buffer.addExtraInfo('energies', e_map)
def test_init_generic_behavior(self, MockClient):
"""Generic solver behavior (default prior to 0.10.0) can be forced."""
sampler = DWaveSampler(client='base')
MockClient.from_config.assert_called_once_with(
client='base',
defaults={'solver': {'order_by': '-num_active_qubits'}})
def test_init_default(self, MockClient):
"""QPU with the highest number of qubits chosen by default."""
sampler = DWaveSampler()
MockClient.from_config.assert_called_once_with(
client='qpu',
defaults={'solver': {'order_by': '-num_active_qubits'}})
def solve_tsp(self):
response = EmbeddingComposite(
DWaveSampler(token=self.sapi_token,
endpoint=self.url)).sample_qubo(
self.qubo_dict,
chain_strength=self.chainstrength,
num_reads=self.numruns)
self.get_solutions(response)
return self.solution, self.distribution
def __init__(self,
objective_function=None,
dwave_sampler=None,
dwave_sampler_kwargs=None,
experiment_type=None,
population_size=1,
num_reads=1,
num_iters=None):
super().__init__(objective_function=objective_function)
self.n_obj = self.objective_function.n
self.n_qubo = self.n_obj - 1
self.dwave_solver = None
self.sampler_kwargs = None
self.qpu = False
self.population_size = population_size
self.num_reads = num_reads
# Initialize dwave sampler:
if dwave_sampler == 'QPU':
self.dwave_solver = EmbeddingComposite(DWaveSampler())
self.qpu = True
if dwave_sampler_kwargs:
self.sampler_kwargs = dwave_sampler_kwargs
else:
self.sampler_kwargs = dict()
elif dwave_sampler == 'SA':
self.dwave_solver = SimulatedAnnealingSampler()
if num_reads:
self.sampler_kwargs = {'num_reads': num_reads}
else:
self.sampler_kwargs = {'num_reads': 25}
elif dwave_sampler == 'Tabu':
self.dwave_solver = TabuSampler()
if num_reads:
self.sampler_kwargs = {'num_reads': num_reads}
else:
self.sampler_kwargs = {'num_reads': 250}
self.stopwatch = 0
if experiment_type == 'time_lim':
self.n_iters = 1000
self.time_limit = 30
if experiment_type == 'iter_lim' and num_iters:
self.n_iters = num_iters
self.time_limit = False
else:
self.n_iters = 50
self.time_limit = False
self.form_qubo = NewLQUBO(objective_function=self.objective_function)
self.solution = self.objective_function.min_v
def __init__(self, num_copies=1):
self.endpoint = 'https://cloud.dwavesys.com/sapi'
self.token = 'DEV-db4d47e5313cf3c52cac31dace7c5080a5ffc46d'
self.solver = 'DW_2000Q_2_1'
self.gamma = 1400
self.chainstrength = 4700
self.num_copies = num_copies
self.child = DWaveSampler(endpoint=self.endpoint,
token=self.token,
solver=self.solver)
def test_solver_init(self, MockClient):
"""Deprecation warning is raised for `solver_features` use, but it still works."""
# assertWarns not available in py2
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
DWaveSampler(solver_features={'qpu': True})
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
DWaveSampler(solver={'qpu': True})
self.assertEqual(len(w), 0)
MockClient.reset_mock()
solver = {'qpu': True, 'num_qubits__gt': 1000}
sampler = DWaveSampler(solver=solver)
MockClient.from_config.assert_called_once_with(solver=solver)
def test_simple(self):
sampler = DWaveSampler(solver={'qpu': True})
embedding = minorminer.find_embedding([[0, 1], [1, 2], [0, 2]],
sampler.edgelist)
fbo1 = self.step1(sampler, embedding)
fbo2 = self.step2(sampler, embedding)
self.assertEqual(fbo1, fbo2)
def __init__(self, num_copies=1):
self.endpoint = 'YOUR URL'
self.token = 'YOUR TOKEN'
self.solver = 'YOUR SOLVER'
self.gamma = 1400
self.chainstrength = 4700
self.num_copies = num_copies
self.child = DWaveSampler(endpoint=self.endpoint,
token=self.token,
solver=self.solver)
def solve_qubo_dwave(Q, n_genome_reads, num_reads=100):
# Create the solver (connecting to D-Wave) and the Sampler
config_file = '../dwave_adv.conf'
client = Client.from_config(config_file, profile='ocete')
solver = client.get_solver('Advantage_system1.1')
dwsampler = DWaveSampler(solver={
'qpu': True,
'topology__type': 'pegasus'
},
token=token,
endpoint=endpoint)
# We need to embed Q into a valid graph for the D-Wave architecture
adjdict = edgelist_to_adjacency(solver.edges)
embed = minorminer.find_embedding(Q, solver.edges)
Q_embeded = embed_qubo(Q, embed, adjdict)
# Obtain the response from the solver. This is the actual D-Wave execution!
start = time.time()
response_qpt = dwsampler.sample_qubo(
Q_embeded,
num_reads=num_reads,
label='{} reads'.format(n_genome_reads))
qpu_time = time.time() - start
client.close()
# Transform the response from the embeded graph to our original architecture
bqm = dimod.BinaryQuadraticModel.from_qubo(Q)
unembedded = unembed_sampleset(response_qpt,
embed,
bqm,
chain_break_method=majority_vote)
# Sort the solutions from lowest energy and format them to quboDict format
unformated_solutions_list = sorted(unembedded.record, key=lambda x: +x[1])
solutions_list = []
for sol, energy, num_appereances in unformated_solutions_list:
solutions_list.append([
rebuild_quboDict_from_vector(sol, n_genome_reads), energy,
num_appereances
])
return solutions_list, qpu_time, get_max_chain_length(embed)
def test_with_software_exact_solver(self):
sampler = DWaveSampler(solver_features={'software': True})
bqm = dimod.BinaryQuadraticModel.empty(dimod.SPIN)
# plant a solution
for v in sampler.nodelist:
bqm.add_variable(v, .001)
for u, v in sampler.edgelist:
bqm.add_interaction(u, v, -1)
resp = sampler.sample(bqm, num_reads=100)
# the ground solution should be all spin down
ground = dict(next(iter(resp)))
self.assertEqual(ground, {v: -1 for v in bqm})
def __init__(self, num_reads=100, qpu_sampler=None, anneal_schedule=None, **runopts):
super(ReverseAnnealingAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if anneal_schedule is None:
anneal_schedule = [[0, 1], [0.5, 0.5], [1, 1]]
self.anneal_schedule = anneal_schedule
if qpu_sampler is None:
qpu_sampler = DWaveSampler(
solver={'max_anneal_schedule_points__gte': len(self.anneal_schedule)})
# validate schedule, raising `ValueError` on invalid schedule or
# `RuntimeError` if anneal schedule not supported by QPU (this could
# happen only if user provided the `qpu_sampler`)
qpu_sampler.validate_anneal_schedule(anneal_schedule)
# embed on fly and only if needed
self.sampler = AutoEmbeddingComposite(qpu_sampler)
def test_init_solver(self, MockClient):
"""QPU can be explicitly selected (old default usage example)"""
solver = {'qpu': True, 'num_qubits__gt': 1000}
sampler = DWaveSampler(solver=solver)
MockClient.from_config.assert_called_once_with(
client='qpu',
solver=solver,
defaults={'solver': {'order_by': '-num_active_qubits'}})
def get_solver(solver_type):
solver = None
if solver_type == 'standard':
solver = EmbeddingComposite(DWaveSampler())
if solver_type == 'hybrid':
solver = hybrid_solver()
if solver_type == 'kerberos':
solver = KerberosSampler()
if solver_type == 'qbsolv':
solver = QBSolv()
return solver
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 __init__(self, num_reads=100, qpu_sampler=None, qpu_params=None, **runopts):
super(QPUSubproblemExternalEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
self.sampler = qpu_sampler
if qpu_params is None:
qpu_params = {}
self.qpu_params = qpu_params
def anneal(self):
###########Perform this only the first time object is instanciated
G = RectGridGraph(self.graph_size,
self.graph_size) #create the graph only once
net_start = [(0, 0)]
net_end = [(0, 0)]
Q = create_qubo(
G, net_start,
net_end) #in order to produce the embedding we will run this once
dwave_sampler = DWaveSampler(solver={'lower_noise': True, 'qpu': True})
A = dwave_sampler.edgelist
if self.embedding is None:
self.embedding, _ = find_embedding_minorminer(
Q, A) #create the embedding only once
#define global sampler here
fixed_sampler = self.global_sampler()
if self.costs is None:
self.cost_function(G, fixed_sampler)
best_sol = deepcopy(self.sol_)
cost_old = self.cost_
self.costs = [cost_old]
self.sols = [best_sol]
else:
cost_old = deepcopy(self.costs[-1])
best_sol = deepcopy(self.sols[-1])
###########
while self.T > self.T_min:
## memory improvement
#garbages = gc.collect()
##seems no longer tobe necessary
print(self.T)
##
i = 1
while i <= self.max_iter:
## memory improvement
#garbages = gc.collect()
######
self.param_generator()
self.cost_function(G, fixed_sampler)
cost_new = self.cost_
ap = self.accept_prob(cost_old, cost_new)
if ap > random.random():
best_sol = deepcopy(self.sol_)
cost_old = cost_new
#print(best_sol)
else:
self.cost_ = cost_old
self.sol_ = deepcopy(best_sol)
i += 1
self.costs.append(cost_old)
self.sols.append(best_sol)
self.T = self.T * self.alpha
def test_typical_small(self):
h = [0, 0, 0, 0, 0]
J = {(0, 4): 1}
bqm = dimod.BinaryQuadraticModel.from_ising(h, J)
response = DWaveSampler(solver_features={'qpu': True}).sample(bqm)
self.assertFalse(np.any(response.samples_matrix == 0))
self.assertIs(response.vartype, dimod.SPIN)
rows, cols = response.samples_matrix.shape
self.assertEqual(cols, 5)
def __init__(self, num_reads=100, qpu_sampler=None):
super(QPUSubproblemAutoEmbeddingSampler, self).__init__()
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
# convert the structured sampler to unstructured
if isinstance(qpu_sampler, dimod.Structured):
self.sampler = EmbeddingComposite(qpu_sampler)
else:
self.sampler = qpu_sampler
def quantumOptim(h,J):
h,J=convertCompatible(h,J)
sampler = EmbeddingComposite(DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi', token='[EnterTokenHere]', solver='DW_2000Q_2_1'))
response = sampler.sample_ising(h,J,num_reads=1000)
Q_energy=[]
Q_sigma=[]
for datum in response.data(['sample', 'energy']):
Q_energy.append(datum.energy)
Q_sigma.append(list(datum.sample.values()))
return Q_sigma[0],Q_energy[0]
def dwave_solver(self, num_reads=100):
""" Solves using Dwave solver
:param num_reads:
:return: tuple (energy, solution)
"""
# TODO: add sapi_token, dwave_url checker
from dwave.system.samplers import DWaveSampler
from dwave.system.composites import EmbeddingComposite
response = EmbeddingComposite(DWaveSampler()).sample(
self.bqm, num_reads=num_reads)
solution = np.array([int(i) for i in response.first[0].values()])
self.current_solution = self.solution_energy(solution), solution
return self.current_solution
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 main(nqubits, instance, T, chainstrength, numruns, greedy, inspect):
"""
Args:
nqubits (int): number of qubits for the file that contains the
information of an Exact Cover instance.
instance (int): intance used for the desired number of qubits.
T (float):
Returns:
"""
control, solution, clauses = functions.read_file(nqubits, instance)
nqubits = int(control[0])
times = functions.times(nqubits, clauses)
sh, smap = functions.h_problem(nqubits, clauses)
Q, constant = functions.symbolic_to_dwave(sh, smap)
model = dimod.BinaryQuadraticModel.from_qubo(Q, offset = 0.0)
if not chainstrength:
chainstrength = dwave.embedding.chain_strength.uniform_torque_compensation(model)
print(f'Automatic chain strength: {chainstrength}\n')
else:
print(f'Chosen chain strength: {chainstrength}\n')
if solution:
print(f'Target solution that solves the problem: {" ".join(solution)}\n')
sampler = EmbeddingComposite(DWaveSampler())
if greedy:
solver_greedy = SteepestDescentSolver()
sampleset = sampler.sample(model, chain_strength=chainstrength, num_reads=numruns, annealing_time=T, answer_mode='raw')
response = solver_greedy.sample(model, initial_states=sampleset)
else:
response = sampler.sample(model, chain_strength=chainstrength, num_reads=numruns, annealing_time=T, answer_mode='histogram')
best_sample = response.record.sample[0]
best_energy = response.record.energy[0]
print(f'Best result found: {best_sample}\n')
print(f'With energy: {best_energy+constant}\n')
good_samples = response.record.sample[:min(len(response.record.sample), nqubits)]
good_energies = response.record.energy[:min(len(response.record.energy), nqubits)]
print(f'The best {len(good_samples)} samples found in the evolution are:\n')
for i in range(len(good_samples)):
print(f'Sample: {good_samples[i]} with energy: {good_energies[i]+constant}\n')
if inspect:
dwave.inspector.show(response)
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 __init__(self, num_reads=100, qpu_sampler=None, qpu_params=None, **runopts):
super(QPUSubproblemAutoEmbeddingSampler, self).__init__(**runopts)
self.num_reads = num_reads
if qpu_sampler is None:
qpu_sampler = DWaveSampler()
# embed on fly and only if needed
self.sampler = AutoEmbeddingComposite(qpu_sampler)
if qpu_params is None:
qpu_params = {}
self.qpu_params = qpu_params
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 sample(self, Q, num_reads=10):
answer = None
self.find_embedding(Q)
while None == answer:
try:
self.create_sampler()
# hier muss was gefixt werden
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
# bqm = dimod.BinaryQuadraticModel.from_qubo(Q)
# __, target_edgelist, target_adjacency = self.sampler.target_structure
# bqm_embedded = embed_bqm(bqm, self.embedding, target_adjacency,
# smear_vartype=dimod.SPIN)
# # embed bqm gives a binary View object of the BQM which is not allowed in the TabuSampler
# print(isinstance(bqm, dimod.BinaryQuadraticModel))
# print(isinstance(bqm_embedded, dimod.BinaryQuadraticModel))
if self.mode == self.op_mode_qbsolv:
answer = self.sampler.sample_qubo(Q,
num_repeats=num_reads -
1)
else:
answer = self.sampler.sample_qubo(Q, num_reads=num_reads)
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
#######################################################################################
except SolverFailureError:
self.sampler = None
print("\n\n\n{} is now empty\n\n\n".format(self.api_tokens[0]))
with open("./empty_api_tokens", mode='a',
encoding="utf-8") as file:
file.write("{}\n".format(self.api_tokens[0]))
del self.api_tokens[0]
self.base_sampler = DWaveSampler(solver={'qpu': True},
token=self.api_tokens[0])
ret = list(answer.data(['sample', 'num_occurrences']))
return ret
