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_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 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 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_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 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(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 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")
# Creo la seconda parte dell'Hamiltoniana creando e unendo # tutti i vincoli per le coppie di provincie vicine H2 = colori_diversi(neighbours[len(neighbours) - 1][0], neighbours[len(neighbours) - 1][1]) for i in range(len(neighbours) - 1): H2 = H2 + colori_diversi(neighbours[i][0], neighbours[i][1]) # Creo l'Hamiltoniana e la faccio diventare una BQM model = H1 + H2 bqm = model.compile().to_bqm() # Creo il set dei risultati utilizzando il sampler definito prima chainstrenght = None sampleset = sampler.sample(bqm, num_reads=20, chain_strength=chainstrenght, label="Problema della mappa") #risultati #print(sampleset) # Uso l'inspector dwave.inspector.show(sampleset) # Seleziono il risultato migliore, ossia quello a energia minore risultato = sampleset.first.sample #print(risultato) #print(risultato[0]) # Creo un grafo vuoto
# --------------------------------------------------------------------------# # This program demonstrates a basic Ocean program that runs a QUBO problem on # the D-Wave QPU as a binary quadratic model (BQM). # --------------------------------------------------------------------------# # Import the functions and packages that are used from dwave.system import EmbeddingComposite, DWaveSampler from dimod import BinaryQuadraticModel # Define the problem as a Python dictionary and convert it to a BQM Q = {('B','B'): 1, ('K','K'): 1, ('A','C'): 2, ('A','K'): -2, ('B','C'): -2} # Convert the problem to a BQM bqm = BinaryQuadraticModel.from_qubo(Q) # 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(bqm, num_reads = 10, label='Example - Simple Ocean Programs: BQM') print(sampleset)
def backup(expName, topo, samples): with open("data/" + expName + topo + str(datetime.now()), "wb") as f: pickle.dump(samples, f) arr = [4, 4, 8, 4, 4, 8] #np.random.randint(1,high=100,size=20) print(arr) H = 0 for i in range(len(arr)): H += arr[i] * Spin(f'x_{i}') H *= H model = H.compile() sampler = DWaveSampler() embedded = EmbeddingComposite(sampler) bqm = model.to_bqm() # we need pyqubo>=1.0.0 print("embedding and sampling...") sampleset = embedded.sample(bqm, num_reads=100) backup("num partitioning arr", "Chimera", arr) backup("num partitioning", "Chimera", sampleset) decoded_samples = model.decode_sampleset(sampleset) best = min(decoded_samples, key=lambda x: x.energy) # decision version of the partitioning problemm: does there exist a partition? print(best) # how close are we? print(best.energy)
nodes = list(i for i in range(24)) edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11), (0, 11), (0, 12), (1, 13), (2, 14), (3, 15), (4, 16), (5, 17), (6, 18), (7, 19), (8, 20), (9, 21), (10, 22), (11, 23), (12, 16), (12, 20), (13, 17), (13, 21), (14, 18), (14, 22), (15, 19), (15, 23), (16, 20), (17, 21), (18, 22), (19, 23)] ##################### G = create_graph(edges) bqm = get_bqm(nodes, edges) # Define the sampler and run the problem sampler = EmbeddingComposite(DWaveSampler()) sample_set = sampler.sample(bqm) # Print the solution # print(sample_set) result = list(sample_set.first.sample[i] for i in nodes) vertices = [] for i in range(len(result)): if result[i] == 1: vertices.append(i) print('Maximum independent set size found is', (len(vertices))) print(vertices) # Visualize the results subset_1 = G.subgraph(vertices) notVertices = list(set(G.nodes()) - set(vertices)) subset_0 = G.subgraph(notVertices)
def run(bqm, num_reads): sampler = EmbeddingComposite(DWaveSampler()) response = sampler.sample(bqm, num_reads) return get_response(response)
def cluster_points(scattered_points, filename, problem_inspector): """Perform clustering analysis on given points Args: scattered_points (list of tuples): Points to be clustered filename (str): Output file for graphic problem_inspector (bool): Whether to show problem inspector """ # 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()) sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000, label='Example - Clustering') best_sample = sampleset.first.sample # Visualize graph problem if problem_inspector: 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)
def run_qca_minimal(E_k=1, qpu_arch='pegasus', use_classical=False, num_reads=10, show_inspector=False, plot_emb_path=None, h_array=[-1, 0], J_matrix=[[0, 1], [1, 0]]): ''' Minimal 1 Driver 2 Cell QCA Problem (introduced in the Leap slide deck). Params: E_k : kink energy in eV. qpu_arch : QPU architecture to use. Either 'pegasus' (that is the newer architecture) or 'chimera' (the old one). use_classical : set to True to use D-Wave's classical Ising solver such that you don't have to use up your D-Wave Leap minutes for testing. num_reads : count of samples to request from the D-Wave QPU or classical sampler. Don't use too high of a value on the QPU as that might use up your Leap minutes very quickly. show_inspector : set to True to show problem inspector in the end. plot_emb_path : supply a string path to plot the embedding ''' import matplotlib.pyplot as plt # general dwave dependencies import dwave import dwave.embedding import dwave.inspector from dwave.system import DWaveSampler, EmbeddingComposite from dwave.cloud import Client from dwave.cloud.exceptions import SolverNotFoundError import dimod from dimod.reference.samplers import ExactSolver from minorminer import find_embedding import neal # dependencies for plotting connectivity graph import networkx as nx import dwave_networkx as dnx # general math and Python dependencies import math import numpy as np import itertools # define self bias (h) and coupling strengths (J) h = -E_k * np.array(h_array) J = -E_k * np.array(J_matrix) N = len(h) # create edgelist (note that {} initializes Python dicts) linear = {} # qubit self-bias quadratic = {} # inter-qubit bias for i in range(N): linear[i] = h[i] for j in range(i + 1, N): if J[i][j] != 0: quadratic[(i, j)] = J[i][j] # construct a bqm containing the provided self-biases (linear) and couplings # (quadratic). Specify the problem as SPIN (Ising). print('Constructing BQM...') bqm = dimod.BinaryQuadraticModel(linear, quadratic, 0, dimod.SPIN) # get DWave sampler and target mapping edgelist print('Choosing solver...') client = Client.from_config() solver = None try: if qpu_arch == 'pegasus': solver = client.get_solver('Advantage_system1.1').id elif qpu_arch == 'chimera': solver = client.get_solver('DW_2000Q_6').id else: raise ValueError('Specified QPU architecture is not supported.') except SolverNotFoundError: print(f'The pre-programmed D-Wave solver name for architecture ' '\'{qpu_arch}\' is not available. Find the latest available ' 'solvers by:\n' 'from dwave.cloud import Client\nclient = Client.from_config()\n' 'client.get_solvers()\nAnd update this script.') raise # get the specified QPU dwave_sampler = DWaveSampler(solver=solver) # run the problem sampler = None response = None if use_classical: print('Choosing classical sampler...') sampler = neal.SimulatedAnnealingSampler() else: print('Choosing D-Wave QPU as sampler...') sampler = EmbeddingComposite(dwave_sampler) response = sampler.sample(bqm, num_reads=num_reads) # print(response) print('Problem completed from selected sampler.') # plot the embedding if specified if not use_classical and plot_emb_path != None: print(f'Plotting embedding to {plot_emb_path}...') embedding = response.info['embedding_context']['embedding'] plt.figure(figsize=(16, 16)) T_nodelist, T_edgelist, T_adjacency = dwave_sampler.structure if qpu_arch == 'pegasus': G = dnx.pegasus_graph(16, node_list=T_nodelist) dnx.draw_pegasus_embedding(G, embedding, node_size=8, cmap='rainbow') elif qpu_arch == 'chimera': G = dnx.chimera_graph(16, node_list=T_nodelist) dnx.draw_chimera_embedding(G, embedding, node_size=8, cmap='rainbow') plt.savefig(plot_emb_path) # take first result from response use_result = [*response.first.sample.values()] # NOTE that response.record contains all returned results and some # statistics. You can inspect what's inside by using pdb or reading the # dimod.SampleSet documentation. # show dwave web inspector if specified if show_inspector and not use_classical: print('\nOpening problem inspector on your browser.') dwave.inspector.show(response) return response
#%% qubo_small #%% bqm_small = dimod.BQM.from_qubo(qubo_small) #%% bqm_small #%% from dwave.system import DWaveSampler, EmbeddingComposite #%% qpu = DWaveSampler() #%% sampler = EmbeddingComposite(qpu, embedding_parameters={ 'timeout': 10, 'tries': 1 }) #%% result = sampler.sample(bqm_small) #%% result #%%
def factor(P): # Construct circuit # ================= construction_start_time = time.time() validate_input(P, range(2**6)) # Constraint satisfaction problem # where the number of csp = dbc.factories.multiplication_circuit(4) # Binary quadratic model bqm = dbc.stitch(csp, min_classical_gap=.1) # multiplication_circuit() creates these variables p_vars = ['p0', 'p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7'] binary = "{:0" + str(8) + "b}" # Convert P from decimal to binary fixed_variables = dict(zip(reversed(p_vars), binary.format(P))) fixed_variables = {var: int(x) for (var, x) in fixed_variables.items()} print("fixed variables") print(fixed_variables) # Fix product qubits for var, value in fixed_variables.items(): print(var, value) bqm.fix_variable(var, value) log.debug('bqm construction time: %s', time.time() - construction_start_time) # Run problem # =========== sample_time = time.time() # Set a QPU sampler sampler = EmbeddingComposite(DWaveSampler()) num_reads = 1000 sampleset = sampler.sample(bqm, num_reads=num_reads) log.debug('embedding and sampling time: %s', time.time() - sample_time) # Output results # ============== output = { "Results": [], # { # "a": Number, # "b": Number, # "Valid": Boolean, # "Occurrences": Number, # "Percentage of results": Number # } "Timing": { "Actual": { "QPU processing time": None # microseconds } }, "Number of reads": None } # multiplication_circuit() creates these variables a_vars = ['a0', 'a1', 'a2', 'a3'] b_vars = ['b0', 'b1', 'b2', 'b3'] results_dict = OrderedDict() for sample, num_occurrences in sampleset.data( ['sample', 'num_occurrences']): # Convert A and B from binary to decimal a = b = 0 for lbl in reversed(a_vars): a = (a << 1) | sample[lbl] for lbl in reversed(b_vars): b = (b << 1) | sample[lbl] # Cast from numpy.int to int a, b = int(a), int(b) # Aggregate results by unique A and B values (ignoring internal circuit variables) if (a, b, P) in results_dict: results_dict[(a, b, P)]["Occurrences"] += num_occurrences results_dict[(a, b, P)]["Percentage of results"] = 100 * \ results_dict[(a, b, P)]["Occurrences"] / num_reads else: # if a * b == P: results_dict[(a, b, P)] = { "a": a, "b": b, "Valid": a * b == P, "Occurrences": num_occurrences, "Percentage of results": 100 * num_occurrences / num_reads } output['Results'] = list(results_dict.values()) output['Number of reads'] = num_reads output['Timing']['Actual']['QPU processing time'] = sampleset.info[ 'timing']['qpu_access_time'] return output
for k in range(j): bqm.add_interaction(j, k, scaling * 2 * A[i, j] * A[i, k]) return bqm # setup n = 11 A, b = setup_random(n) # A, b = setup_easy() scaling = 1.0 / n chain_strength = 1.0 num_reads = 10000 # sampling bqm = binlin(A, b, scaling=scaling) samples = sampler.sample(bqm, num_reads=num_reads).aggregate() # brute-force exact solution bestx, minnorm = bruteforce(A, b) # results print("A =", A) print("b =", b) print("Brute-force solution:", bestx, "norm:", minnorm) print() idxbest = None for idx, sample in enumerate(samples.record.sample): isvalid = np.linalg.norm(sample - bestx) == 0 if isvalid: idxbest = idx print("Solution #{} (valid = {})".format(idx, isvalid)) print("Sample:", sample)
import dimod from dimod import BinaryQuadraticModel from dwave.system import DWaveSampler, EmbeddingComposite import dwave.inspector import numpy as np with open("willxujun.data", "r") as myfile: data = myfile.read() z2 = [int(k) for k in data.split()] arr = np.array(z2) numpy_matrix = arr.reshape(64, 64) bqm = dimod.BinaryQuadraticModel.from_numpy_matrix(numpy_matrix) sampler = EmbeddingComposite(DWaveSampler()) sampleset = sampler.sample(bqm, chain_strength=10000, num_reads=1000) dwave.inspector.show(bqm, sampleset, sampler)
import dimod import dwave.inspector from dwave.system import DWaveSampler, EmbeddingComposite # define problem bqm = dimod.BQM.from_ising({}, {'ab': 1, 'bc': 1, 'ca': 1}) # get sampler print("sampler init") sampler = EmbeddingComposite(DWaveSampler()) # sample print("sampling") sampleset = sampler.sample(bqm, num_reads=100, chain_strength=1, label='bqm/sampleset inspector example') # inspect print("inspecting") dwave.inspector.show(bqm, sampleset)
#https://docs.ocean.dwavesys.com/en/stable/examples/multi_gate.html import dwavebinarycsp def strange(a, b): return a or not b csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY) csp.add_constraint(strange, ['a', 'b']) bqm = dwavebinarycsp.stitch(csp) from dwave.system import DWaveSampler, EmbeddingComposite sampler = EmbeddingComposite(DWaveSampler()) dataset = sampler.sample(bqm, num_reads=10) print(dataset)
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)
def factor(P, gap_size, max_graph_size, size_of_circuit): # Construct circuit # ================= construction_start_time = time.time() extra_number = 1 # Constraint satisfaction problem """Normal Case CSP""" csp = dbc.factories.multiplication_circuit(size_of_circuit) # Binary quadratic model bqm = dbc.stitch(csp, max_graph_size=max_graph_size, min_classical_gap=gap_size) # multiplication_circuit() creates these variables p_vars = make_array(size_of_circuit * 2, 'p') a_vars = make_var_array(size_of_circuit, 'a') b_vars = make_var_array(size_of_circuit, 'b') binary = "{:0" + str(size_of_circuit * 2) + "b}" # Convert P from decimal to binary fixed_variables = dict(zip(reversed(p_vars), binary.format(P))) fixed_variables = {var: int(x) for (var, x) in fixed_variables.items()} # Fix product qubits for var, value in fixed_variables.items(): bqm.fix_variable(var, value) bqm.fix_variable('a0', 1) bqm.fix_variable('b0', 1) log.debug('bqm construction time: %s', time.time() - construction_start_time) # Run problem # =========== sample_time = time.time() # # Set a local sampler # sampler = neal.SimulatedAnnealingSampler() # Set a QPU sampler sampler = EmbeddingComposite(DWaveSampler()) num_reads = 2000 print("running localy") sampleset = sampler.sample(bqm, num_reads=num_reads) log.debug('embedding and sampling time: %s', time.time() - sample_time) # Output results # ============== output = { "Results": [], # { # "a": Number, # "b": Number, # "Valid": Boolean, # "Occurrences": Number, # "Percentage of results": Number # } "Timing": { "Actual": { "QPU processing time": None # microseconds } }, "Number of reads": None } # multiplication_circuit() creates these variables results_dict = OrderedDict() for sample, num_occurrences in sampleset.data(['sample', 'num_occurrences']): # Convert A and B from binary to decimal a = b = 0 bitA = bitB = "" for lbl in reversed(a_vars): a = (a << 1) | sample[lbl] bitA += str(sample[lbl]) for lbl in reversed(b_vars): b = (b << 1) | sample[lbl] bitB += str(sample[lbl]) # Cast from numpy.int to int a, b = int((a << 1)), int((b << 1)) a += extra_number b += extra_number bitA = bitA + "1" bitB = bitB + "1" # a, b = int(a + 2 ** (size_of_circuit-1) + 2 ** 0), int(a + 2 ** (size_of_circuit-1) + 2 ** 0) # Aggregate results by unique A and B values (ignoring internal circuit variables) if (a, b, P) in results_dict: results_dict[(a, b, P)]["Occurrences"] += num_occurrences results_dict[(a, b, P)]["Percentage of results"] = 100 * \ results_dict[(a, b, P)]["Occurrences"] / num_reads else: # if a * b == P: results_dict[(a, b, P)] = { "a": a, "b": b, "bitA": bitA, "bitB": bitB, "product": a * b, "Valid": a * b == P, "Occurrences": num_occurrences, "Percentage of results": 100 * num_occurrences / num_reads} # elif a == 659 or b == 659 or a == 571 or b == 571: # results_dict[(a, b, P)] = { # "a": a, # "b": b, # "bitA": bitA, # "bitB": bitB, # "product": a * b, # "Valid": a * b == P, # "Occurrences": num_occurrences, # "Percentage of results": 100 * num_occurrences / num_reads} # else: # wrong_A = wrong_A + 1 # results_dict[(a, b, P)] = {"a": a, # "b": b, # "Valid": a * b == P, # "Occurrences": num_occurrences, # "Percentage of results": 100 * num_occurrences / num_reads} output['Results'] = list(results_dict.values()) output['Number of reads'] = num_reads # pprint(output['Results']) # pprint(results_dict) # output['Timing']['Actual']['QPU processing time'] = sampleset.info['timing']['qpu_access_time'] save_data(P, 'DW_2000Q+OneBit', size_of_circuit, gap_size, max_graph_size, output) return output, csp
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 factor(P, gap_size, max_graph_size, size_of_circuit): # Construct circuit # ================= construction_start_time = time.time() validate_input(P, range(2**(size_of_circuit * 2))) # Constraint satisfaction problem # where the number of csp = dbc.factories.multiplication_circuit(size_of_circuit) # Binary quadratic model bqm = dbc.stitch(csp, min_classical_gap=gap_size, max_graph_size=max_graph_size) # multiplication_circuit() creates these variables p_vars = make_array(size_of_circuit * 2, 'p') binary = "{:0" + str(size_of_circuit * 2) + "b}" # Convert P from decimal to binary fixed_variables = dict(zip(reversed(p_vars), binary.format(P))) fixed_variables = {var: int(x) for (var, x) in fixed_variables.items()} # Fix product qubits for var, value in fixed_variables.items(): bqm.fix_variable(var, value) log.debug('bqm construction time: %s', time.time() - construction_start_time) # Run problem # =========== sample_time = time.time() # # Set a local sampler # sampler = neal.SimulatedAnnealingSampler() # Set a QPU sampler sampler = EmbeddingComposite(DWaveSampler()) num_reads = 2000 print("Sent to D-Wave") sampleset = sampler.sample(bqm, num_reads=num_reads) log.debug('embedding and sampling time: %s', time.time() - sample_time) # Output results # ============== output = { "Results": [], # { # "a": Number, # "b": Number, # "Valid": Boolean, # "Occurrences": Number, # "Percentage of results": Number # } "Timing": { "Actual": { "QPU processing time": None # microseconds } }, "Number of reads": None } # multiplication_circuit() creates these variables a_vars = make_array(size_of_circuit, 'a') b_vars = make_array(size_of_circuit, 'b') wrong_A = 0 results_dict = OrderedDict() for sample, num_occurrences in sampleset.data( ['sample', 'num_occurrences']): # Convert A and B from binary to decimal a = b = 0 for lbl in reversed(a_vars): a = (a << 1) | sample[lbl] for lbl in reversed(b_vars): b = (b << 1) | sample[lbl] # Cast from numpy.int to int a, b = int(a), int(b) # Aggregate results by unique A and B values (ignoring internal circuit variables) if (a, b, P) in results_dict: results_dict[(a, b, P)]["Occurrences"] += num_occurrences results_dict[(a, b, P)]["Percentage of results"] = 100 * \ results_dict[(a, b, P)]["Occurrences"] / num_reads else: # if a * b == P: # results_dict[(a, b, P)] = {a, b, a * b == P, num_occurrences, 100 * num_occurrences / num_reads} results_dict[(a, b, P)] = { "a": a, "b": b, "Valid": a * b == P, "Occurrences": num_occurrences, "Percentage of results": 100 * num_occurrences / num_reads } # else: # wrong_A = wrong_A + 1 # results_dict[(a, b, P)] = {"a": a, # "b": b, # "Valid": a * b == P, # "Occurrences": num_occurrences, # "Percentage of results": 100 * num_occurrences / num_reads} output['Results'] = list(results_dict.values()) output['Number of reads'] = num_reads # output['Timing']['Actual']['QPU processing time'] = sampleset.info['timing']['qpu_access_time'] save_data(P, 'Advantage_system1.1', size_of_circuit, gap_size, max_graph_size, output) return output
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)
study.optimize(objective, n_trials=200) b1 = study.best_params["b1"] b2 = study.best_params["b2"] b3 = study.best_params["b3"] def_dict = { "balancer1": b1, "balancer2": b2, "balancer3": b3, "IntChain": 10.0 } bqm = model.to_dimod_bqm(feed_dict=def_dict) sampler = EmbeddingComposite(DWaveSampler(sampler="DW_2000Q_6")) responses = sampler.sample(bqm, num_reads=1000) #sampler = LeapHybridSampler() #responses = sampler.sample(bqm,time_limit=60) solutions = model.decode_dimod_response(responses, feed_dict=def_dict) cnt = 0 for sol in solutions: if len(sol[1]) < 10: weight_const_flag = False for i in range(n): if sum(sol[0]['x'][i][j] * a[i, j] for j in range(m)) > b[i]: weight_const_flag = True
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)
NVAR = 50 ## hi = {0: 1, 1: -1, 2: .5} ## Jji = { (0,1): .5, (1,2): .5, (0,2): -0.5 } hi = {} Jji = {} for i in range(NVAR): hi[i] = random.random() for j in range(i + 1, NVAR): Jji[(j, i)] = random.random() print("{} parameters in Ising model.".format(str(len(Jji) + len(hi)))) # another parameter value is dimod.Vartype.BINARY for 0/1 valued variables bqm = dimod.BinaryQuadraticModel(hi, Jji, 0.0, dimod.Vartype.SPIN) print("Sampling model..") sampler = EmbeddingComposite(DWaveSampler()) sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000, label='BQM/Ising model test') best_sample = sampleset.first.sample print(best_sample)