def test_quantum2():
''' Example using D-Wave's quantum annealing
Note: Embedding is done with the use of D-Wave composite
'''
X = np.array([[1, 2], [1, 3], [9, 5], [9, 6]]) # input data
k = 2
model = genModel(X, k) # generate BQM model (not yet embedded)
sampler = EmbeddingComposite(DWaveSampler(
solver={'qpu': True
})) # sets D-Wave's sampler, embedding is done automatically
solution_set = sampler.sample(
model, num_reads=100,
return_embedding=True) # run on the D-wave hardware
print("Embedding: ", solution_set.info["embedding_context"]["embedding"])
# Count the number of qubits used
num_qubits = 0
for entry in solution_set.info["embedding_context"]["embedding"].values():
num_qubits += len(entry)
print("Number of qubits: ", num_qubits)
M, assignments = postprocess2(
X, solution_set.first.sample) # postprocess the solution
print("Centroids: ")
print(M)
print("Assignments: " + str(assignments))
def objective(trial):
b1 = trial.suggest_uniform('b1', 0.0, 20)
b2 = trial.suggest_uniform('b2', 0.0, 20)
b3 = trial.suggest_uniform('b3', 0.0, 20)
def_dict = {
"balancer1": b1,
"balancer2": b2,
"balancer3": b3,
"IntChain": 1.0
}
bqm = model.to_dimod_bqm(feed_dict=def_dict)
sampler = EmbeddingComposite(DWaveSampler(sampler="DW_2000Q_6"))
responses = sampler.sample(bqm, num_reads=5000)
solutions = model.decode_dimod_response(responses, feed_dict=def_dict)
cnt = 0
for idx, sol in enumerate(solutions):
if len(sol[1]) < 10:
cnt += responses.record[idx][2]
return cnt
def test_many_bqm_async(self):
sampler = EmbeddingComposite(self.qpu)
# in the future it would be good to test a wide variety of BQMs,
# see https://github.com/dwavesystems/dimod/issues/671
# but for now let's just test a few
bqm0 = dimod.BinaryQuadraticModel.from_ising({
'a': 2.0,
'b': -2.0
}, {('a', 'b'): -1})
bqm1 = dimod.BinaryQuadraticModel.from_ising({2: 4}, {
(0, 1): 1.5,
(1, 2): 5
})
samplesets0 = []
samplesets1 = []
for _ in range(10):
# this should be async
samplesets0.append(sampler.sample(bqm0))
samplesets1.append(sampler.sample(bqm1))
if all(ss.done() for ss in samplesets0):
warnings.warn("Sampler calls appear to be synchronous")
for ss0, ss1 in zip(samplesets0, samplesets1):
dimod.testing.assert_sampleset_energies(ss0, bqm0)
dimod.testing.assert_sampleset_energies(ss1, bqm1)
self.assertTrue(all(ss.done() for ss in samplesets0))
self.assertTrue(all(ss.done() for ss in samplesets1))
def cluster_points(scattered_points, filename):
# Set up problem
# Note: max_distance gets used in division later on. Hence, the max(.., 1)
# is used to prevent a division by zero
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = max(get_max_distance(coordinates), 1)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = {(0, 0, 1), (0, 1, 0), (1, 0, 0)}
for coord in coordinates:
csp.add_constraint(choose_one_group, (coord.r, coord.g, coord.b))
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.b, weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.b, weight)
bqm.add_interaction(coord0.r, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.r, weight)
bqm.add_interaction(coord0.b, coord1.g, weight)
bqm.add_interaction(coord0.g, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.b, weight)
# Submit problem to D-Wave sampler
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
#sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000)
best_sample = sampleset.first.sample
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
return groupings
def solve_QPU(
self,
h1=1.0,
num=100,
sol="DW_2000Q_6",
emb_param={
"verbose": 2,
"max_no_improvement": 6000,
"timeout": 600,
"chainlength_patience": 1000,
"threads": 15
}):
'''
EmbeddingComposite サンプラを用いた、Solver。結果を変数に格納する
self.best_dist 得られた最良の距離（最短距離）
self.best_route 得られた最良のルート
parameters
-----
float h1(default 1.0) : ModelからQUBO行列を作成する際の距離の重み
float h1(default 1.0) : ModelからQUBO行列を作成する際の制約の重み
int num : サンプリング回数
str sol : Solver名
dict emb_param : 内部で呼ばれるfind_embeddingのオプション
returns
-----
なし
'''
sampler = EmbeddingComposite(DWaveSampler(solver=sol))
#QUBO変換
Q, offset = self.model.to_qubo(feed_dict={"H1": h1})
#D-Waveへデータ送信
self.responses = sampler.sample_qubo(Q,
num_reads=num,
chain_strength=5.0,
embedding_parameters=emb_param,
postprocess="optimization")
#結果をDecode（Constraintをチェックするため）
self.solutions = self.model.decode_dimod_response(self.responses,
feed_dict={"H1": h1})
#ベストな距離を変数に格納する
self.best_dist = 100000
self.best_route = []
for sol in self.solutions:
#制約違反がない結果について、過去のBestの距離と比較
if len(sol[1]) == 0:
tmp_sol = [
sum(i * val for i, val in sol[0]['x'][j].items())
for j in range(self.size)
]
if self.route_len(tmp_sol) < self.best_dist:
self.best_dist = self.route_len(tmp_sol)
self.best_route = tmp_sol
def test_dwave_system(self):
from dwave.system import DWaveSampler, EmbeddingComposite
sampler = EmbeddingComposite(DWaveSampler())
h = {'a': -1, 'b': +1}
J = {('a', 'b'): -1}
resp = sampler.sample_ising(h, J)
def main(token='', n_vertices=0, neighbours=None, filename=None, local=False):
''' Using any graph at all, if given the number of nodes
and the neighbours, 0-indexed, this will try to minimize the
number of same-coloured neighbours.
Runs on the Basic Dwave Solver, so very quickly and painlessly.
:param n_vertices: This is the number of vertices in the graph to be 2-coloured.
Vertices should be 0-indexed.
:param neighbours: This is the adjacency list describing the graph.
This should only describe vertex indices, 0-indexed.
:param filename: If the problem is desired to be loaded from a file,
this string should be the path to that file.
:param local: Utilized solely by __main__, will make the program output
the whole solution for display in Dwave's web inspector.
:param token: The Dwave token to be used.
This should be a string, in the format used on the dwave leap website.
:return: This returns a dictionary. The only key is "solution",
containing an ordered list of the states of the vertices for the best solution.
Each state is either 1 or -1.
'''
if filename == None:
filename = 'problem.txt'
if neighbours == None:
n_vertices, neighbours = load_problem(filename)
# 2. Define problem
h = [0 for x in range(n_vertices)]
J = dict((tuple(neighbour), 10) for neighbour in neighbours)
# print(J)
# 3. Instantiate solver
sampler = EmbeddingComposite(DWaveSampler(token=token))
# 4. Sample problem
solution = sampler.sample_ising(h, J, chain_strength=50, num_reads=50)
# 5. Use response
best_solution = [int(solution.first.sample[x]) for x in range(n_vertices)]
# print( best_solution )
if local:
return solution
else:
return {'solution': best_solution}
def test_initial_state(self):
sampler = EmbeddingComposite(self.qpu)
bqm = dimod.BinaryQuadraticModel.from_ising({'a': 2.0, 'b': -2.0},
{('a', 'b'): -1})
kwargs = {'initial_state': {'a': 1, 'b': 1},
'anneal_schedule': [(0, 1), (55.0, 0.45),
(155.0, 0.45), (210.0, 1)]}
sampler.sample(bqm, **kwargs).resolve()
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 factor(P):
bP = "{:06b}".format(P)
csp = dbc.factories.multiplication_circuit(3)
bqm = dbc.stitch(csp, min_classical_gap=.1)
p_vars = ['p0', 'p1', 'p2', 'p3', 'p4', 'p5']
fixed_variables = dict(zip(reversed(p_vars), bP))
fixed_variables = {var: int(x) for (var, x) in fixed_variables.items()}
for var, value in fixed_variables.items():
bqm.fix_variable(var, value)
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(bqm, num_reads=1000)
a, b = to_base_ten(sampleset.first.sample)
print("Given integer P={0}, found factors a={1} and b={2}".format(P, a, b))
return a, b
def optimize_advantage(self,count=False,Best=0,balancer=1.0):
from pyqubo import Array,Constraint,Placeholder,UnaryEncInteger,Sum #LogEncInteger
from dwave.system import EmbeddingComposite,DWaveSampler
x = Array.create("x",shape=(self.num),vartype="BINARY")
#y = LogEncInteger("y",lower=0,upper=5)
y = UnaryEncInteger("y",lower=0,upper=5)
#価値が最大になるように（符号を反転させる）
#H1 = -sum([x[i]*self.p[i].get_value() for i in range(self.num)])
H1 = -Sum(0,self.num,lambda i :x[i]*self.p[i].get_value() )
#重さが目的の重量になるように
#H2 = Constraint((self.limit_weight -sum([x[i]*p_i.get_weight() for i,p_i in enumerate(self.p)]) - y*10)**2,"Const Weight")
H2 = Constraint((self.limit_weight -Sum(0,self.num,lambda i: x[i]*self.p[i].get_weight()) - y*10)**2,"Const Weight")
#H2 = Constraint((self.limit_weight -Sum(0,self.num,lambda i: x[i]*self.p[i].get_weight()))**2,"Const Weight")
H = H1 + H2*Placeholder("balancer")
model = H.compile()
balance_dict = {"balancer":balancer}
bqm = model.to_dimod_bqm(feed_dict=balance_dict)
sampler = EmbeddingComposite(DWaveSampler(solver="Advantage_system1.1"))
#sampler = EmbeddingComposite(DWaveSampler(solver="DW_2000Q_6"))
responses = sampler.sample(bqm,num_reads=1000)
solutions = model.decode_dimod_response(responses,feed_dict=balance_dict)
#Optuna用 バランス調査
if count == True:
counter = 0
for idx,sol in enumerate(solutions):
const_str = sol[1]
val = sum(int(sol[0]['x'][i])*self.p[i].get_value() for i in range(self.num))
weight = sum(int(sol[0]['x'][i])*self.p[i].get_weight() for i in range(self.num))
#重量が制限以下、かつ価値が最適解の9割以上をカウント
if len(const_str) == 0 and val > Best*0.9 and weight <= self.limit_weight:
counter += responses.record[idx][2]
del H1,H2,H,model,bqm,responses,solutions
gc.collect()
return counter
if len(solutions[0][1]) == 0:
print(f" y= { sum(2**i*y_i for i,y_i in enumerate(solutions[0][0]['y']))}")
print("## Advantage Solver Optimized Result")
self.print([int(solutions[0][0]['x'][i]) for i in range(self.num)])
else:
print("## Advantage Solver Optimizing Failed")
def solve_dwave(Q, conf_file, **kwargs):
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
from dwave.system import EmbeddingComposite
from dwave.system import DWaveSampler
sampler = DWaveSampler(config_file=conf_file, permissive_ssl=True)
solver = EmbeddingComposite(sampler)
logger.info(f'Using {sampler.solver} as the sub-QUBO solver.')
return solve_qbsolv(Q, solver=solver, **kwargs)
def set_sampler():
'''Returns a dimod sampler'''
token = get_token()
sampler = EmbeddingComposite(
DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi/',
token=token,
solver={'qpu': True}))
return sampler
def __init__(self, qmasm, profile=None, solver=None, qbsolv=False):
"Acquire either a software sampler or a sampler representing a hardware solver."
self.qmasm = qmasm
self.sampler, self.client_info = self._get_sampler(profile, solver)
if qbsolv:
if solver == None:
self.qbsolv_sampler = EmbeddingComposite(self.sampler)
else:
self.qbsolv_sampler = self.sampler
self.sampler = QBSolv()
self.client_info[
"solver_name"] = "QBSolv + " + self.client_info["solver_name"]
else:
self.qbsolv_sampler = None
def main(sampler_type, region, show, inspect):
if sampler_type is None:
print("No solver selected, defaulting to hybrid")
sampler_type = 'hybrid'
# get the appropriate signed social network
G = global_signed_social_network(region=region)
# choose solver and any tuning parameters needed
if sampler_type == 'cpu':
params = dict(num_reads=100)
sampler = SimulatedAnnealingSampler()
elif sampler_type == 'hybrid':
params = dict()
sampler = LeapHybridSampler()
elif sampler_type == 'qpu':
params = dict(
num_reads=100,
chain_strength=2.0,
)
sampler = dimod.TrackingComposite(EmbeddingComposite(DWaveSampler()))
else:
raise RuntimeError("unknown solver type")
# use the chosen sampler (passing in the parameters)
edges, colors = dnx.structural_imbalance(
G, sampler, label='Example - Structural Imbalance', **params)
if inspect and sampler_type == 'qpu':
dwave.inspector.show(sampler.output)
print("Found", len(edges), 'violations out of', len(G.edges), 'edges')
draw_social_network(G, colors)
if show:
plt.show()
else:
filename = 'structural imbalance {} {}.png'.format(
sampler_type, region)
plt.savefig(filename, facecolor='white')
plt.clf()
def main(sampler_type, region, show):
if sampler_type is None:
print("No solver selected, defaulting to hybrid")
sampler_type = 'hybrid'
if region == 'global' and sampler_type == 'qpu':
print("Given region is too large for the QPU, please choose another "
"region or use hybrid.")
# get the appropriate signed social network
G = global_signed_social_network(region=region)
# choose solver and any tuning parameters needed
if sampler_type == 'cpu':
params = dict(num_reads=100)
sampler = SimulatedAnnealingSampler()
elif sampler_type == 'hybrid':
params = dict()
sampler = LeapHybridSampler()
elif sampler_type == 'qpu':
params = dict(
num_reads=100,
chain_strength=2.0,
)
sampler = EmbeddingComposite(DWaveSampler())
else:
raise RuntimeError("unknown solver type")
# use the chosen sampler (passing in the parameters)
edges, colors = dnx.structural_imbalance(G, sampler, **params)
print("Found", len(edges), 'violations out of', len(G.edges), 'edges')
draw_social_network(G, colors)
if show:
plt.show()
else:
filename = 'stuctural imbalance {} {}.png'.format(sampler_type, region)
plt.savefig(filename, facecolor='white', dpi=500)
plt.clf()
def get_sampler(self, profile, solver):
"Return a dimod.Sampler object and associated solver information."
# Handle built-in software samplers as special cases.
info = {}
if solver != None:
info["solver_name"] = solver
if solver == "exact":
return ExactSolver(), info, {}
elif solver == "neal":
return SimulatedAnnealingSampler(), info, {}
elif solver == "tabu":
return TabuSampler(), info, {}
elif solver == "kerberos" or (solver != None
and solver[:9] == "kerberos,"):
base_sampler = KerberosSampler()
try:
sub_sampler_name = solver.split(",")[1]
except IndexError:
sub_sampler_name = None
sub_sampler, sub_info, params = self.get_sampler_from_config(
profile, sub_sampler_name, "qpu")
info.update(self._recursive_properties(sub_sampler))
info["solver_name"] = "kerberos + %s" % sub_info["solver_name"]
params["qpu_sampler"] = sub_sampler
return base_sampler, info, params
elif solver == "qbsolv" or (solver != None
and solver[:7] == "qbsolv,"):
base_sampler = QBSolv()
try:
sub_sampler_name = solver.split(",")[1]
except IndexError:
sub_sampler_name = None
sub_sampler, sub_info, params = self.get_sampler(
profile, sub_sampler_name)
if getattr(sub_sampler, "structure", None) != None:
sub_sampler = EmbeddingComposite(sub_sampler)
info.update(self._recursive_properties(sub_sampler))
info["solver_name"] = "QBSolv + %s" % sub_info["solver_name"]
params["solver"] = sub_sampler
return base_sampler, info, params
# In the common case, read the configuration file, either the
# default or the one named by the DWAVE_CONFIG_FILE environment
# variable.
return self.get_sampler_from_config(profile, solver)
def solve(self,
useQPU=False,
useNeal=False,
useHyb=True,
time_limit = 10,
num_reads = 100,
chain_strength = 10000):
Q = self.Q
BQM_offset = 0 # TODO: Use the accumulated quadratic constants from the constraints
bqm = BinaryQuadraticModel.from_qubo(Q, offset=BQM_offset)
self.sampleset = None
# Call the requested solver
if ( useQPU ):
print("Solving using the DWaveSampler on the QPU...")
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample_qubo(Q, num_reads=num_reads,chain_strength = chain_strength)
elif ( useHyb ):
print("Solving using the LeapHybridSolver...")
sampler = LeapHybridSampler()
sampleset = sampler.sample(bqm, time_limit = time_limit)
elif ( useNeal ):
print("Solving using the SimulatedAnnealing...")
sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, num_reads = num_reads)
else:
print("Solving using the TabuSampler...")
sampler = TabuSampler()
sampleset = sampler.sample(bqm, num_reads = num_reads)
self.sampleset = sampleset
count = 0
for res in self.sampleset.data(): count += 1
return (count)
def solve_dwave(self):
X = Array.create('X', shape=(self.n), vartype='SPIN')
H0 = 0
for (u, v) in self.G.edges:
H0 -= (1 - X[u] * X[v]) * self.G.edges[u, v]['w']
model = H0.compile()
bqm = model.to_dimod_bqm()
response = EmbeddingComposite(DWaveSampler()).sample(bqm,
num_reads=100)
result = model.decode_dimod_response(response, topk=1)
optimized_v = result[0][0]['X']
self.v_group = []
for i in range(self.n):
self.v_group.append(optimized_v[i])
self.cutted = []
for (u, v) in self.G.edges:
if optimized_v[u] != optimized_v[v]:
self.cutted.append([u, v])
from dijkstra_solver import dijkstra_solver
import networkx as nx
from dimod import BinaryQuadraticModel
import dimod
import dwave.inspector
from dwave.system import DWaveSampler, EmbeddingComposite
G = nx.Graph()
G.add_weighted_edges_from([('S', 'a', 4.0), ('a', 'b', 7.0), ('b', 'G', 2.0),
('G', 'd', 3.0), ('c', 'd', 8.0), ('c', 'S', 6.0),
('c', 'b', 9.0)])
lagrange = 20
chainstrength = 20
numruns = 1000
model = dijkstra_solver(G, 'S', 'G', lagrange)
Q = model.to_qubo()
bqm = BinaryQuadraticModel.from_qubo(Q[0], offset=Q[1])
sampler = EmbeddingComposite(DWaveSampler())
sampleset = sampler.sample(bqm,
chain_strength=chainstrength,
num_reads=numruns)
dwave.inspector.show(bqm, sampleset, sampler)
# Constrain I: there should be N segments in the trip
Q_cI = defaultdict(int)
for i in range(N_tot):
Q_cI[(i, i)] = l_I * (1 - 2 * N_req)
for j in range(i+1, N_tot):
Q_cI[(i, j)] = l_I * 2
# Constrain II: the trip should start and finish at the North Pole
Q_cII = defaultdict(int)
for i in range(N_tot):
Q_cII[(i, i)] = l_II
Q_cII[(0, 2)] = -l_II * 2
Q_cII[(1, 3)] = -l_II * 2
Q_cII[(4, 5)] = -l_II * 2
QUBO_print("Q_goal", Q_goal, N_tot)
QUBO_print("Q_cI", Q_cI, N_tot)
QUBO_print("Q_cII", Q_cII, N_tot)
Q = QUBO_sum(Q_cI, Q_cII);
Q = QUBO_sum(Q, Q_goal);
chain_strength = QUBO_guess_chain_strength(Q)
print("Chain Strength: {}".format(chain_strength), end="\n\n")
sampleset = EmbeddingComposite(DWaveSampler()).sample_qubo(
Q, num_reads=10, chain_strength=chain_strength)
print(sampleset)
csp = full_adder(csp, "a1", "b1", "cin", "0")
csp = full_adder(csp, "a2", "b2", "0_cout", "1")
csp = full_adder(csp, "a3", "b3", "1_cout", "2")
csp = full_adder(csp, "a4", "b4", "2_cout", "3")
csp = full_adder(csp, "a5", "b5", "3_cout", "4")
csp = full_adder(csp, "a6", "b6", "4_cout", "5")
csp = full_adder(csp, "a7", "b7", "5_cout", "6")
csp = full_adder(csp, "a8", "b8", "6_cout", "7")
csp = full_adder(csp, "a9", "b9", "7_cout", "8")
csp = full_adder(csp, "a10", "b10", "8_cout", "9")
for i in range(0, 9):
csp.fix_variable("sum" + str(i), 1)
csp.fix_variable("9_cout", 1)
bqm = dbc.stitch(csp)
sampler = EmbeddingComposite(DWaveSampler(solver={"qpu": True}))
sampleset = sampler.sample(bqm, num_reads=10000)
print(sampleset)
for sample, energy in sampleset.data(["sample", "energy"]):
string = ""
for i in range(1, 10):
string += "a" + str(i) + ": " + str(sample["a" + str(i)]) + ", "
string += "b" + str(i) + ": " + str(sample["b" + str(i)]) + ", "
string += "cin: " + str(sample["cin"]) + " energy: " + str(energy)
print(string)
dwave.inspector.show(sampleset)
def cluster_points(scattered_points, filename, architecture):
# Set up problem
# Note: max_distance gets used in division later on. Hence, the max(.., 1)
# is used to prevent a division by zero
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = max(get_max_distance(coordinates), 1)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = {(0, 0, 1), (0, 1, 0), (1, 0, 0)}
for coord in coordinates:
csp.add_constraint(choose_one_group, (coord.r, coord.g, coord.b))
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.b, weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.b, weight)
bqm.add_interaction(coord0.r, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.r, weight)
bqm.add_interaction(coord0.b, coord1.g, weight)
bqm.add_interaction(coord0.g, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.b, weight)
# Submit problem to D-Wave sampler
if architecture == 'pegasus':
solver = DWaveSampler(solver={
'topology__type': 'pegasus',
'qpu': True
})
print(solver.solver)
sampler = EmbeddingComposite(solver)
else:
solver = DWaveSampler(solver={
'topology__type': 'chimera',
'qpu': True
})
print(solver.solver)
sampler = EmbeddingComposite(solver)
sampleset = sampler.sample(bqm,
chain_strength=4,
num_reads=1000,
return_embedding=True)
best_sample = sampleset.first.sample
# Inspect the embedding
embedding = sampleset.info['embedding_context']['embedding']
num_qubits = 0
for k in embedding.values():
num_qubits += len(k)
print("Number of qubits used in embedding = " + str(num_qubits))
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
# Print solution onto terminal
# Note: This is simply a more compact version of 'best_sample'
print(groupings)
from collections import defaultdict
import networkx as nx
# 2. Set up the problem
# Create empty graph
G = nx.Graph()
# Add edges to the graph (also adds nodes)
G.add_edges_from([('a', 'b'), ('b', 'c'), ('b', 'd'), ('c', 'd'), ('c', 'f'),
('d', 'f'), ('d', 'e'), ('e', 'f')])
print(G.edges)
# ------- Set up our QUBO dictionary -------
# Initialize our Q matrix
Q = defaultdict(int)
# Update Q matrix for every edge in the graph
for i, j in G.edges:
Q[(i, i)] += -1
Q[(j, j)] += -1
Q[(i, j)] += 2
# 3. Instantiate a solver
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
# 4. Solve the problem
sampleset = sampler.sample_qubo(Q, chain_strength=8, num_reads=100)
# 5. Interpret the results - print the results with the lowest energy
print(sampleset.lowest())
def generateRealSamples(qubo, num_reads=10):
sampler = DWaveSampler()
embedding = EmbeddingComposite(sampler)
return embedding.sample_qubo(qubo, num_reads=guarded_num_reads(num_reads))
from cliparser import parser
if __name__ == "__main__":
args = parser.parse_args()
options = {
'no_time': args.no_time,
'verbosity': args.verbosity
}
if args.solver in ['hybrid', 'embed', 'sim_anneal', 'tabu']:
solverClass = DwaveSolver
if args.solver == 'hybrid':
options['solver'] = LeapHybridSampler()
elif args.solver == 'embed':
options['solver'] = EmbeddingComposite(DWaveSampler())
elif args.solver == 'sim_anneal':
options['solver'] = neal.SimulatedAnnealingSampler()
elif args.solver == 'tabu':
options['solver'] = 'tabu'
options['visualize'] = args.visualize
options['top_samples'] = args.sols_to_print
elif args.solver == 'cplex':
solverClass = CplexNeosSolver
elif args.solver == 'qiskit':
solverClass = QiskitSolver
solver = solverClass(args.num_molecules, args.lattice_size)
solver.solve(options)
numruns = 1 # update
sample_set = sampler.sample_qubo(Q,
chain_strength=chainstrength,
num_reads=numruns)
return sample_set
## ------- Main program -------
if __name__ == "__main__":
token = get_token()
## ------- Set up our QUBO dictionary -------
Q = get_qubo()
## ------- Run our QUBO on the QPU -------
sampler = EmbeddingComposite(
DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi/',
token=token,
solver={'qpu': True}))
sample_set = run_on_qpu(Q, sampler)
## ------- Return results to user -------
for sample, energy in sample_set.data(['sample', 'energy']):
print(sample, energy)
def cluster_points(scattered_points, filename):
# Set up problem
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = get_max_distance(coordinates)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = allowed_States(k)
for coord in coordinates:
mylist = list(vars(coord).values())
mylist.remove(coord.x)
mylist.remove(coord.y)
csp.add_constraint(choose_one_group, mylist)
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
for i in range(k):
bqm.add_interaction(getattr(coord0, "x" + str(i)),
getattr(coord1, "x" + str(i)), weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
for p in range(k):
for m in range(k):
if p != m:
bqm.add_interaction(getattr(coord0, "x" + str(p)),
getattr(coord1, "x" + str(m)),
weight)
# Submit problem to D-Wave sampler
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000)
best_sample = sampleset.first.sample
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
# Print solution onto terminal
# Note: This is simply a more compact version of 'best_sample'
print(groupings)
from dwave.system import DWaveSampler, EmbeddingComposite
import dwave.inspector
sampler = EmbeddingComposite(DWaveSampler(solver='DW_2000Q_6',
#token='',
))
h = {}
J = {
('Lisa', 'Timo'): 3,
# Ergänzen Sie hier die Werte
# der anderen Koppler
}
response = sampler.sample_ising(
h,
J,
num_reads=100,
chain_strength=1, # hiermit müssen Sie
# rumspielen um
# gute Lösungen zu
# bekommen
annealing_time=20, # diesen Wert
# können Sie zstl.
# ändern um bessere
# Lösungen zu
# bekommen
)
dwave.inspector.show(response)
from dwave.system import DWaveSampler, EmbeddingComposite
import random
import pyqubo
sampler = EmbeddingComposite(DWaveSampler())
N = int(input())
m = int(input())
weight = [random.randint(-100, 100) for i in range(N)]
x = pyqubo.Array.create('bin_array', shape=N, vartype='BINARY')
lagrangian = 0
for elem in weight:
lagrangian += abs(elem)
hamiltonian = -sum(
a * j for a, j in zip(weight, x)) + lagrangian * (sum(i for i in x) - m)**2
Q, offset = hamiltonian.compile().to_qubo()
sampleset = sampler.sample_qubo(Q, num_reads=1000)
print(sampleset) # doctest: +SKIP
print(' '.join(map(str, weight)))