import matplotlib matplotlib.use("agg") import matplotlib.pyplot as plt # Importo l'analizzatore import dwave.inspector # Selezioni il sampler che useremo. Voglio un metodo quantistico, # quindi uso il DwaweSampler from dwave.system.samplers import DWaveSampler # Utilizzo un composite per fare l'embedding from dwave.system.composites import EmbeddingComposite # Preparo il sampler usando l'embedding scelto sampler = EmbeddingComposite(DWaveSampler(solver='Advantage_system1.1')) # Creo un grafo vuoto G = nx.Graph() # Prendo un grafo da un file grafo = open( "/workspace/Tesi/Esempi-commentati/Pipelines-Antennas/JOHNSON8-2-4.txt", "rb") #grafo = open("/workspace/Tesi/Esempi-commentati/Pipelines-Antennas/chesapeake.txt", "rb") G = nx.read_edgelist(grafo) #Creo la funzione per formulare il QUBO def massimo_set_indipendente_qubo(G, weight=None, lagrange=2.0): # un QUBO vuoto per un grafo vuoto
# -*- coding: utf-8 -*- """ Created on Thu Jun 4 16:49:59 2020 @author: usama """ from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite import matplotlib.pyplot as plt import neal import numpy as np from numpy.random import randn token = 'Enter Dwave Token' sampler = EmbeddingComposite(DWaveSampler(token=token, solver={'qpu': True})) #sampler=neal.SimulatedAnnealingSampler() #This function is taken from Dr Fayyaz ul Amir Afsar Minhas (Github User: foxtrotmike) def getExamples(n=100, d=2): """ Generates n d-dimensional normally distributed examples of each class The mean of the positive class is [1] and for the negative class it is [-1] DO NOT CHANGE THIS FUNCTION """ Xp = randn(n, d) + 1 #generate n examples of the positive class #Xp[:,0]=Xp[:,0]+1 Xn = randn(n, d) - 1 #generate n examples of the negative class #Xn[:,0]=Xn[:,0]-1
def setUp(self, MockClient): # using the mock self.sampler = DWaveSampler() self.sampler.solver = MockSolver()
fixed_variables = dict(zip(reversed(p_vars), "{:06b}".format(P))) fixed_variables = {var: int(x) for (var, x) in fixed_variables.items()} ## Fix the result of the product (kind of making a constrain). ## As a resul all 'p0',...,'p5' will be removed from the bqm. for var, value in fixed_variables.items(): bqm.fix_variable(var, value) ## SETTING UP A SOLVER from helpers.solvers import default_solver #my_solver, my_token = default_solver() from dwave.system.samplers import DWaveSampler #sampler = DWaveSampler(solver={'qpu': True}) # Some accounts need to replace this line with the next: sampler = DWaveSampler(solver={'qpu': True}, token='DEV-7201bbe105379663905954b7ed302eed2bd97866') _, target_edgelist, target_adjacency = sampler.structure ## embedding from dwave.embedding import embed_bqm, unembed_sampleset from helpers.embedding import embeddings ## Embedding logical qubits to physical ones embedding = embeddings[sampler.solver.id] ## Set connections betweeen physical qubits bqm_embedded = embed_bqm(bqm, embedding, target_adjacency, 4.0) #print(bqm_embedded) # Return num_reads solutions (responses are in the D-Wave's graph of indexed qubits) kwargs = {}
import networkx as nx import dwave_networkx as dnx from minorminer import find_embedding from dwave.system.samplers import DWaveSampler try: import matplotlib.pyplot as plt except ImportError: matplotlib.use("agg") import matplotlib.pyplot as plt N = int(sys.argv[1]) G = nx.complete_graph(N) # Do the embedding dwave_sampler = DWaveSampler(solver={'topology__type__eq': 'chimera'}) A = dwave_sampler.edgelist embedding = find_embedding(G, A) qubits = 0 for chain in embedding.values(): qubits += len(chain) print("\nEmbedding for", N, "clique found using", qubits, "qubits.") fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 6)) node_color_list = [(random(), random(), random()) for i in range(N)] chain_color_list = {i: node_color_list[i] for i in range(N)} # Draw the QUBO as a networkx graph pos = nx.spring_layout(G)
location = 'office' if sample['location'] else 'home' length = 'short' if sample['length'] else 'long' mandatory = 'mandatory' if sample['mandatory'] else 'optional' print( "During {} at {}, you can schedule a {} meeting that is {}".format( time, location, length, mandatory)) print( '################################################################################' ) # Solving on a D-Wave System from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite sampler = EmbeddingComposite( DWaveSampler() ) # endpoint='https://URL_to_my_D-Wave_system/', token='ABC-123456789012345678901234567890', solver='My_D-Wave_Solver' response = sampler.sample( bqm, num_reads=50 ) # map our unstructured problem (variables such as time etc.) to the sampler's graph structure (the QPU's numerically indexed qubits) in a process known as minor-embedding. total = 0 for sample, energy, occurrences in response.data( ['sample', 'energy', 'num_occurrences'], sorted_by='num_occurrences'): total = total + occurrences if energy == min_energy: # prints all those solutions (assignments of variables) for which the BQM has its minimum value and the number of times it was found time = 'business hours' if sample['time'] else 'evenings' location = 'office' if sample['location'] else 'home' length = 'short' if sample['length'] else 'long' mandatory = 'mandatory' if sample['mandatory'] else 'optional' print("{}: During {} at {}, you can schedule a {} meeting that is {}".
def train_model(X_train, y_train, X_test, y_test, lmd): """ Train qboost model :param X_train: train input :param y_train: train label :param X_test: test input :param y_test: test label :param lmd: lmbda to control regularization term :return: """ NUM_READS = 3000 NUM_WEAK_CLASSIFIERS = 35 # lmd = 0.5 TREE_DEPTH = 3 # define sampler dwave_sampler = DWaveSampler(solver={'qpu': True}) # sa_sampler = micro.dimod.SimulatedAnnealingSampler() emb_sampler = EmbeddingComposite(dwave_sampler) N_train = len(X_train) N_test = len(X_test) print("\n======================================") print("Train#: %d, Test: %d" % (N_train, N_test)) print('Num weak classifiers:', NUM_WEAK_CLASSIFIERS) print('Tree depth:', TREE_DEPTH) # input: dataset X and labels y (in {+1, -1} # Preprocessing data imputer = SimpleImputer() # scaler = preprocessing.MinMaxScaler() scaler = preprocessing.StandardScaler() normalizer = preprocessing.Normalizer() centerer = preprocessing.KernelCenterer() # X = imputer.fit_transform(X) X_train = scaler.fit_transform(X_train) X_train = normalizer.fit_transform(X_train) X_train = centerer.fit_transform(X_train) # X_test = imputer.fit_transform(X_test) X_test = scaler.fit_transform(X_test) X_test = normalizer.fit_transform(X_test) X_test = centerer.fit_transform(X_test) ## Adaboost print('\nAdaboost') clf = AdaBoostClassifier(n_estimators=NUM_WEAK_CLASSIFIERS) # scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy') print('fitting...') clf.fit(X_train, y_train) hypotheses_ada = clf.estimators_ # clf.estimator_weights_ = np.random.uniform(0,1,size=NUM_WEAK_CLASSIFIERS) print('testing...') y_train_pred = clf.predict(X_train) y_test_pred = clf.predict(X_test) print('accu (train): %5.2f' % (metric(y_train, y_train_pred))) print('accu (test): %5.2f' % (metric(y_test, y_test_pred))) # Ensembles of Decision Tree print('\nDecision tree') clf2 = WeakClassifiers(n_estimators=NUM_WEAK_CLASSIFIERS, max_depth=TREE_DEPTH) clf2.fit(X_train, y_train) y_train_pred2 = clf2.predict(X_train) y_test_pred2 = clf2.predict(X_test) print(clf2.estimator_weights) print('accu (train): %5.2f' % (metric(y_train, y_train_pred2))) print('accu (test): %5.2f' % (metric(y_test, y_test_pred2))) # Ensembles of Decision Tree print('\nQBoost') DW_PARAMS = { 'num_reads': NUM_READS, 'auto_scale': True, # "answer_mode": "histogram", 'num_spin_reversal_transforms': 10, # 'annealing_time': 10, 'postprocess': 'optimization', } clf3 = QBoostClassifier(n_estimators=NUM_WEAK_CLASSIFIERS, max_depth=TREE_DEPTH) clf3.fit(X_train, y_train, emb_sampler, lmd=lmd, **DW_PARAMS) y_train_dw = clf3.predict(X_train) y_test_dw = clf3.predict(X_test) print(clf3.estimator_weights) print('accu (train): %5.2f' % (metric(y_train, y_train_dw))) print('accu (test): %5.2f' % (metric(y_test, y_test_dw))) # Ensembles of Decision Tree print('\nQBoostPlus') clf4 = QboostPlus([clf, clf2, clf3]) clf4.fit(X_train, y_train, emb_sampler, lmd=lmd, **DW_PARAMS) y_train4 = clf4.predict(X_train) y_test4 = clf4.predict(X_test) print(clf4.estimator_weights) print('accu (train): %5.2f' % (metric(y_train, y_train4))) print('accu (test): %5.2f' % (metric(y_test, y_test4))) print("=============================================") print("Method \t Adaboost \t DecisionTree \t Qboost \t QboostIt") print("Train\t %5.2f \t\t %5.2f \t\t\t %5.2f \t\t %5.2f" % (metric(y_train, y_train_pred), metric(y_train, y_train_pred2), metric(y_train, y_train_dw), metric(y_train, y_train4))) print("Test\t %5.2f \t\t %5.2f \t\t\t %5.2f \t\t %5.2f" % (metric(y_test, y_test_pred), metric(y_test, y_test_pred2), metric(y_test, y_test_dw), metric(y_test, y_test4))) print("=============================================") # plt.subplot(211) # plt.bar(range(len(y_test)), y_test) # plt.subplot(212) # plt.bar(range(len(y_test)), y_test_dw) # plt.show() return
def factor(P, use_saved_embedding=True): #################################################################################################### # get circuit #################################################################################################### construction_start_time = time.time() validate_input(P, range(2 ** 6)) # get constraint satisfaction problem csp = dbc.factories.multiplication_circuit(3) # get binary quadratic model bqm = dbc.stitch(csp, min_classical_gap=.1) # we know that multiplication_circuit() has created these variables p_vars = ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'] # convert P from decimal to binary fixed_variables = dict(zip(reversed(p_vars), "{:06b}".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() # get QPU sampler sampler = DWaveSampler() _, target_edgelist, target_adjacency = sampler.structure if use_saved_embedding: # load a pre-calculated embedding from factoring.embedding import embeddings embedding = embeddings[sampler.solver.id] else: # get the embedding embedding = minorminer.find_embedding(bqm.quadratic, target_edgelist) if bqm and not embedding: raise ValueError("no embedding found") # apply the embedding to the given problem to map it to the sampler bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, 3.0) # draw samples from the QPU kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = 50 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' response = sampler.sample(bqm_embedded, **kwargs) # convert back to the original problem space response = dimod.unembed_response(response, embedding, source_bqm=bqm) sampler.client.close() log.debug('embedding and sampling time: %s', time.time() - sample_time) #################################################################################################### # output results #################################################################################################### output = { "results": [], # { # "a": Number, # "b": Number, # "valid": Boolean, # "numOfOccurrences": Number, # "percentageOfOccurrences": Number # } "timing": { "actual": { "qpuProcessTime": None # microseconds } }, "numberOfReads": None } # we know that multiplication_circuit() has created these variables a_vars = ['a0', 'a1', 'a2'] b_vars = ['b0', 'b1', 'b2'] # histogram answer_mode should return counts for unique solutions if 'num_occurrences' not in response.data_vectors: response.data_vectors['num_occurrences'] = [1] * len(response) # should equal num_reads total = sum(response.data_vectors['num_occurrences']) results_dict = OrderedDict() for sample, num_occurrences in response.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] # aggregate results by unique A and B values (ignoring internal circuit variables) if (a, b, P) in results_dict: results_dict[(a, b, P)]["numOfOccurrences"] += num_occurrences results_dict[(a, b, P)]["percentageOfOccurrences"] = 100 * \ results_dict[(a, b, P)]["numOfOccurrences"] / total else: results_dict[(a, b, P)] = {"a": a, "b": b, "valid": a * b == P, "numOfOccurrences": num_occurrences, "percentageOfOccurrences": 100 * num_occurrences / total} output['results'] = list(results_dict.values()) output['numberOfReads'] = total if 'timing' in response.info: output['timing']['actual']['qpuProcessTime'] = response.info['timing']['qpu_access_time'] return output
# q_0 + q_4 - 2 q_0 q_4 - 1 # # Constrain qubits 1 and 4 to have opposite values - but notice that we're # going to embed qubits 1 and 5 to have the same value # 2 q_1 q_4 - q_4 - 0.5 (q_1 + q_5) # # Constrain qubits 0 and 5 to have the same value - and yes, we will embed # 1 and 5 to have the same value # q_0 + 0.5 (q_1 + q_5) - 2 q_0 q_5 - 1 # # Constrain qubits 1 and 5 to have the same value, explicitly # chainstrength (q_1 + q_5 - 2q_1 q_5 - 1) numruns = 1000 chainstrength = float(sys.argv[1]) sampler = DWaveSampler(solver={'topology__type': 'chimera'}) # Add all the equations together Q = { (0, 0): 2, (1, 1): chainstrength, (5, 5): chainstrength, (0, 4): -2, (1, 4): 2, (0, 5): -2, (1, 5): -2 * chainstrength } bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset=-2 - chainstrength) results = sampler.sample(bqm, num_reads=numruns)
qdict = prb.get_cvrptw_qubo(penalty_const, reward_const, capacity_const, time_windows_const).dict printqubo = False if printqubo: for key in qdict.keys(): ((v, d, t), (v2, d2, t2)) = key # if qdict[key] < penalty_const and abs(qdict[(key)]) > 0.1: if (v == v2) and (d == d2) and (d != 0) and (t != t2): print(key, end='') print(" - ", end='') print(qdict[key]) print("annealing") solver = hybrid_solver() # solver = neal.SimulatedAnnealingSampler() dwave_sampler = DWaveSampler(token=DWAVE_API_TOKEN, endpoint=endpoint) response = solver.sample_qubo(qdict) for sample in response: # for key in sample: # if sample[key] == 1: # print(key) solution = CVRPTWSolution(prb, sample) solution.description() # print(solution.total_cost()) print(solution.check()) print('energy: ', energy(qdict, sample, False)) print()
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from dwave.system.samplers import DWaveSampler from dwave.system.composites import LazyFixedEmbeddingComposite import sys import dimod # Set up the QUBO. Start with the equations from the slides: chainstrength = float(sys.argv[1]) numruns = 1000 Q = {(0, 0): 2, (0, 1): -2, (0, 2): -2, (1, 2): 2} bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset=-2) sampler = LazyFixedEmbeddingComposite( DWaveSampler(solver={'topology__type': 'pegasus'})) response = sampler.sample(bqm, chain_strength=chainstrength, num_reads=numruns) print(sampler.properties['embedding']) for sample, energy in response.data(['sample', 'energy']): print(sample, energy)
def solve(d_min, eta, i_max, k, lambda_zero, n, N, N_max, p_delta, q, topology, Q, DIR, sim): try: if (not sim): string = "\n---------- Started Algorithm in Quantum Mode ----------\n" print(string) write(DIR, string) sampler = DWaveSampler(solver={ 'topology__type': topology, 'qpu': True, 'annealing_time': 0.001 }) A = get_active(sampler, n) else: string = "\n---------- Started Algorithm in Simulating Mode ----------" print(string) write(DIR, string) sampler = neal.SimulatedAnnealingSampler() if (topology == 'chimera'): string = "---------- Using Chimera Topology ----------\n" print(string) write(DIR, string) if (n > 2048): n = int( input( f"WARNING: {n} inserted value is bigger than max topology size (2048), please insert a valid n or press any key to exit: " )) try: A = generate_chimera(n) except: exit() else: string = "---------- Using Pegasus Topology ----------\n" print(string) write(DIR, string) A = generate_pegasus(n) dir = DIR + "_matrix.txt" file = open(dir, 'a') i = 0 for row in Q: i += 1 print(f"--- Printing Q in file './{dir}' ... {int((i/n)*100)} %", end='\r') file.write(str(row) + '\n') print(f"--- Printing Q in file './{dir}' END --- ") file.close() d_min, eta, i_max, k, lambda_zero, n, N, N_max, p_delta, q, topology, Q, DIR, sim string = "\n --- DATA --- \ndmin = " + str(d_min) + " - eta = " + str( eta) + " - imax = " + str(i_max) + " - k = " + str( k) + " - lambda 0 = " + str(lambda_zero) + " - n = " + str( n) + " - N = " + str(N) + " - Nmax = " + str( N_max) + " - pdelta = " + str(p_delta) + "\n" print(string) write(DIR, string) I = np.identity(n) p = 1 Theta_one, m_one = g(Q, A, np.arange(n), p, sim) Theta_two, m_two = g(Q, A, np.arange(n), p, sim) string = "Working on z1..." print(string, end=' ') write(DIR, string) start = time.time() z_one = map_back(annealer(Theta_one, sampler, k), m_one) convert_1 = datetime.timedelta(seconds=(time.time() - start)) string = "Ended in " + str(convert_1) + " .\nWorking on z2..." print(string, end=' ') write(DIR, string) start = time.time() z_two = map_back(annealer(Theta_two, sampler, k), m_two) convert_2 = datetime.timedelta(seconds=(time.time() - start)) string = "Ended in " + str(convert_2) + " ." print(string) write(DIR, string) f_one = function_f(Q, z_one).item() f_two = function_f(Q, z_two).item() if (f_one < f_two): z_star = z_one f_star = f_one m_star = m_one z_prime = z_two else: z_star = z_two f_star = f_two m_star = m_two z_prime = z_one if (f_one == f_two) == False: S = (np.outer(z_prime, z_prime) - I) + np.diagflat(z_prime) else: S = [[0 for col in range(n)] for row in range(n)] except KeyboardInterrupt: string = "KeyboardInterrupt occurred before cycle, closing program..." print(string) write(DIR, string) exit() e = 0 d = 0 i = 1 lam = lambda_zero sum_time = 0 while True: start_time = time.time() try: string = str(round(((i / i_max) * 100), 2)) + "% -- ETA: " + str( datetime.timedelta(seconds=((sum_time / (i - 1)) * (i_max - i - 1)))) + "\n" except: string = str(round( ((i / i_max) * 100), 2)) + "% -- ETA: not yet available\n" print(string) try: Q_prime = np.add(Q, (np.multiply(lam, S))) if (i % N == 0): p = p - ((p - p_delta) * eta) Theta_prime, m = g(Q_prime, A, m_star, p, sim) #for kindex in range(1, k+1): string = "Working on z'..." print(string, end=' ') write(DIR, string) start = time.time() z_prime = map_back(annealer(Theta_prime, sampler, k), m) convert_z = datetime.timedelta(seconds=(time.time() - start)) string = "Ended in " + str(convert_z) + " ." print(string) write(DIR, string) #z_prime = run_annealer(Theta_prime, sampler) if make_decision(q): z_prime = h(z_prime, q) if (z_prime == z_star) == False: f_prime = function_f(Q, z_prime).item() if (f_prime < f_star): tmp = z_prime.copy() z_prime = z_star.copy() z_star = tmp.copy() f_star = f_prime m_star = m e = 0 d = 0 S = S + ((np.outer(z_prime, z_prime) - I) + np.diagflat(z_prime)) else: d = d + 1 #if make_decision(sim_ann((p - p_delta), f_prime, f_star)): # if make_decision((p - p_delta)**(f_prime - f_star)): tmp = z_prime.copy() z_prime = z_star.copy() z_star = tmp.copy() f_star = f_prime m_star = m e = 0 lam = min(lambda_zero, (lambda_zero / (2 + (i - 1) - e))) else: e = e + 1 # debug print converted = datetime.timedelta(seconds=(time.time() - start_time)) try: if (n > 16): string = "-- -- Valori ciclo " + str(i) + "/" + str( i_max ) + " -- --\np = " + str(p) + ", f_prime = " + str( f_prime) + ", f_star = " + str( f_star) + ", e = " + str(e) + ", d = " + str( d) + ", Nmax = " + str( N_max) + ", dmin = " + str( d_min) + " e lambda = " + str( lam) + "\nCi ho messo " + str( converted) + " in totale\n" else: string = "-- -- Valori ciclo " + str(i) + "/" + str( i_max ) + " -- --\np = " + str(p) + ", f_prime = " + str( f_prime ) + ", f_star = " + str(f_star) + ", e = " + str( e) + ", d = " + str(d) + ", Nmax = " + str( N_max ) + ", dmin = " + str(d_min) + " e lambda = " + str( lam) + "\nz* = " + str(z_star) + "\nz' = " + str( z_prime) + "\nCi ho messo " + str( converted) + " in totale\n" print(string) write(DIR, string) except: if (n > 16): string = "-- -- Valori ciclo " + str(i) + "/" + str( i_max ) + " -- --\nNon ci sono variazioni di f, z\ne = " + str( e) + ", d = " + str(d) + ", Nmax = " + str( N_max) + ", dmin = " + str( d_min) + " e lambda = " + str( lam) + "\nCi ho messo " + str( converted) + " in totale\n" else: string = "-- -- Valori ciclo " + str(i) + "/" + str( i_max ) + " -- --\nNon ci sono variazioni di f, z\ne = " + str( e) + ", d = " + str(d) + ", Nmax = " + str( N_max) + ", dmin = " + str( d_min) + " e lambda = " + str( lam) + "\nz* = " + str( z_star) + "\nCi ho messo " + str( converted) + " in totale\n" print(string) write(DIR, string) dir = DIR + "_vector.txt" file = open(dir, 'a') file.write("Ciclo " + str(i) + "-esimo - z* --> " + str(z_star) + "\n") file.close() sum_time = sum_time + (time.time() - start_time) if ((i == i_max) or ((e + d >= N_max) and (d < d_min))): if (i != i_max): string = "Uscito al ciclo " + str(i) + "/" + str( i_max) + " ed è stata raggiunta la convergenza." print(string) write(DIR, string) else: string = "Uscito al ciclo " + str(i) + "/" + str( i_max) + "\n" print(string) write(DIR, string) break i = i + 1 except KeyboardInterrupt: #sum_time = sum_time + (time.time() - start_time) break converted = datetime.timedelta(seconds=sum_time) if i != 1: conv = datetime.timedelta(seconds=(sum_time / (i - 1))) else: conv = datetime.timedelta(seconds=(sum_time)) string = "Tempo medio per iterazione: " + str( conv) + "\nTempo totale: " + str(converted) + "\n" print(string) write(DIR, string) return np.atleast_2d(z_star).T
#Minimum Vertex Cover #Step one: Draw a single graph #Imports include numpy, matplotlib, and networkx import networkx as nx import matplotlib import matplotlib.pyplot as plt import numpy as np import matplotlib.pyplot as plt a5 = nx.star_graph(4) plt.subplot(121) nx.draw(a5, with_labels=True, front_weight=’bold’) #Step two: Solve the graphs minimum vertex cover from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite #Define sampler sampler = EmbeddingComposite(DWaveSampler()) print(dnx.min_vertex_cover(a5, sampler)) #Factor #Set an integer to factor P = 21 #Binary representation of P bP = "{:06b}".format(P) print(bP) #Convert the CSP into BQM csp = dbc.factories.multiplication_circuit(3) bqm = dbc.stitch(csp, min_classical_gap=.1) from helpers import draw draw.circuit_from(bqm) #Create variables p_vars = ['p0', 'p1', 'p2', 'p3', 'p4', 'p5']
from minorminer import find_embedding from dwave.system.samplers import DWaveSampler from dwave.system.composites import FixedEmbeddingComposite # Set up the QUBO. Start with the equations from the slides: # x + y - 2xy -1 # 2yz - y - z # -2zx + z + x - 1 # QUBO: 2x - 2xy + 2yz - 2zx - 2 Q = {(0, 0): 2, (0, 1): -2, (0, 2): -2, (1, 2): 2} chainstrength = 5 numruns = 1000 dwave_sampler = DWaveSampler() A = dwave_sampler.edgelist embedding = find_embedding(Q, A) print(embedding) response = FixedEmbeddingComposite(DWaveSampler(), embedding).sample_qubo( Q, chain_strength=chainstrength, num_reads=numruns) for sample, energy, num, cbf in response.data( ['sample', 'energy', 'num_occurrences', 'chain_break_fraction']): print(sample, energy, num, cbf)
same_bis = grid[:, x, y].flatten() if (x, y) in origin_list: scale = w_sameori else: scale = w_same sumLessOne(same_bis, J, scale=scale) # convert all 3 degree term to qubo form reduceBySubstitution(J, J_3D, 2) # show QUBO embedding print(J) if use_qpu: solver_limit = 205 G = nx.complete_graph(solver_limit) system = DWaveSampler() embedding = minorminer.find_embedding(J.keys(), system.edgelist) print(embedding) res = QBSolv().sample_qubo(J, solver=FixedEmbeddingComposite( system, embedding), solver_limit=solver_limit, num_reads=5000) #res = EmbeddingComposite(DWaveSampler()).sample_qubo(J, num_reads=20) else: res = QBSolv().sample_qubo(J, num_repeats=2000) samples = list(res.samples()) energy = list(res.data_vectors['energy']) print(samples[i]) print(energy) energy, samples = zip(*sorted(zip(energy, samples), key=lambda k: k[0]))
def __init__(self, objective_function=None, dwave_sampler=None, dwave_sampler_kwargs=None, num_activation_vectors=None, activation_vec_hamming_dist=1, max_hd=None, parse_samples=True, experiment_type=None, num_reads=None, num_iters=None, network_type='minimum'): super().__init__(objective_function=objective_function) # Initialize switch network: # The default behavior here is to choose the smaller of either permutation or # sorting networks for the given input size. self.n_obj = self.objective_function.n if network_type == 'sorting': self.network = SortingNetwork(self.n_obj) elif network_type == 'permutation': self.network = PermutationNetwork(self.n_obj) elif network_type == 'minimum': s = SortingNetwork(self.n_obj) p = PermutationNetwork(self.n_obj) if s.depth <= p.depth: self.network = s else: self.network = p else: raise TypeError('Network type {} not recognized'.format(str(network_type))) self.n_qubo = self.network.depth self.dwave_solver = None self.sampler_kwargs = None self.qpu = False # 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 # Initialize type of experiment # When running a timed experiment there is a high number of iterations and a 30 sec wall clock # When running a iteration experiment there is a iteration limit of 30 and no wall clock 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 if max_hd: self.max_hd = max_hd else: self.max_hd = 0 if num_activation_vectors: self.num_activation_vec = num_activation_vectors else: self.num_activation_vec = self.n_qubo self.form_qubo = LQUBO(objective_function=self.objective_function, switch_network=self.network, max_hamming_dist=self.max_hd, num_activation_vectors=self.num_activation_vec, activation_vec_hamming_dist=activation_vec_hamming_dist) self.solution = self.objective_function.min_v if parse_samples: self.selection = CheckAndSelect else: self.selection = Select
from minorminer import find_embedding from dwave.system.samplers import DWaveSampler from dwave.system.composites import FixedEmbeddingComposite # Graph partitioning as full mesh gamma = 3 N = 8 linear = N - 1 - (7 * gamma) quad = (2 * gamma) - 2 Q = {} for i in range(N): Q[i, i] = linear for j in range(i + 1, N): Q[i, j] = quad chainstrength = 5 numruns = 100 dwave_sampler = DWaveSampler() A = dwave_sampler.edgelist embedding = find_embedding(Q, A) print(embedding)
# Uncomment if you need to paste in a solver and/or token # my_solver = 'paste your solver in here' # my_token = 'paste your token in here' # Your default or manually set solver and token are used in the next cell. The cell sets a *sampler*, the component used to find variable values that minimize the Ising model representing our problem. Here we use a D-Wave system but Ocean tools are designed to swap in and out samplers with ease. For example you might first run a classical sampler on your computer's CPU during testing, and only once your code is ready, submit the problem for solution on the quantum computer. # # *DWaveSampler()* from Ocean software's [dwave-system](https://docs.ocean.dwavesys.com/projects/system/en/latest/) tool handles the connection to a D-Wave system. This tool also handles mapping between the graph of our problem, NetworkX's *complete_graph(4)* graph with nodes labeled Alice, Bob etc, to the D-Wave QPU's numerically indexed qubits. This mapping, known as *minor-embedding*, is done by the *EmbeddingComposite()* composite. # In[ ]: # Select a D-Wave system and handle mapping from problem graph to sampler graph from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite sampler = EmbeddingComposite(DWaveSampler(solver=my_solver, token=my_token)) # ### Solving the Problem # Next, the *structural_imbalance()* algorithm, from Ocean's [dwave_networkx](https://docs.ocean.dwavesys.com/projects/dwave-networkx/en/latest/) extension of the NetworkX graphic package, submits the Ising model we formulated in the previous section to a D-Wave system. It returns a partition of our social network into two colored sets and the frustrated edges. # In[ ]: # Return a good partition (minimal structural imbalance) and its frustrated edges import dwave_networkx as dnx imbalance, bicoloring = dnx.structural_imbalance(G, sampler) # Mark the returned frustrated edges and node set (color) on the graph for edge in G.edges: G.edges[edge]['frustrated'] = edge in imbalance for node in G.nodes: G.nodes[node]['color'] = bicoloring[node]
from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite # Set up the QUBO. Start with the equations from the slides: # x + y - 2xy -1 # 2yz - y - z # -2zx + z + x - 1 # QUBO: 2x - 2xy + 2yz - 2zx - 2 chainstrength = 5 numruns = 100 Q = {(0, 0): 2, (0, 1): -2, (0, 2): -2, (1, 2): 2} response = EmbeddingComposite(DWaveSampler()).sample_qubo( Q, chain_strength=chainstrength, num_reads=numruns) for smpl, energy in response.data(['sample', 'energy']): print(smpl, energy)
(20.0, 1.0) # After 20us, set the anneal setting to 100% (max) ) # A custom anneal schedule can have up to four points. def anneal_sched_custom_3(): return ( (0.0, 0.0), # Start everything at 0 (1.0, 0.80), # Quickly ramp up to 80% anneal at 1µs (19.0, 0.81), # From 1µs to 19µs, slowly go from 80% to 81%. (20.0, 1.0) # End the full anneal at 20µs ) print('Boolean NOT Gate with Default Annealing Schedule') sampler = DWaveSampler() # We put a small bias for qubit 0 to see if the annealing schedule # makes a difference in the distribution of solutions. Q = {(0, 0): -1.1, (0, 4): 0, (4, 0): 2, (4, 4): -1} response_1 = sampler.sample_qubo(Q, anneal_schedule=anneal_sched_custom_1(), num_reads=1000) response_2 = sampler.sample_qubo(Q, anneal_schedule=anneal_sched_custom_2(), num_reads=1000) response_3 = sampler.sample_qubo(Q, anneal_schedule=anneal_sched_custom_3(), num_reads=1000) print('Anneal schedule 1:')
from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite from itertools import combinations Sampler = EmbeddingComposite(DWaveSampler()) #Eri Montano #traveling sales man problem #this is a 4 city problem and should work with more cities #order of initial upper triangle for the city/weight order distance = [4,6,5,1,4,7] E = len(distance) N = int((1+(1+E*8)**0.5)/2) #calcualte based on edges cities = list(range(N)) gamma = 15.0 chainstrength = 10 numruns = 100 edges = list(combinations(cities,2)) print (edges) Q = {(a,b): 0 for a in range(E) for b in range(E)} for i in range(E): #form the diagonal Q[(i,i)] = distance[i]-(6*gamma)
N = int(sys.argv[1]) G = nx.complete_graph(N) fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(12, 6)) # Draw the QUBO as a networkx graph pos = nx.spring_layout(G) nx.draw_networkx(G, pos=pos, font_size=10, node_size=100, node_color='cyan', ax=axes[0]) # Embed the graph on Chimera dwave_sampler_chimera = DWaveSampler(solver={'topology__type': 'chimera'}) chimera_edges = dwave_sampler_chimera.edgelist chimera_graph = dnx.chimera_graph(16, edge_list=chimera_edges) clique_embedding_chimera = find_clique_embedding(N, chimera_graph) # Draw the graph embedded on Chimera dnx.draw_chimera_embedding(chimera_graph, clique_embedding_chimera, embedded_graph=G, unused_color=None, ax=axes[1]) # Embed the graph on Pegasus dwave_sampler_pegasus = DWaveSampler(solver={'topology__type': 'pegasus'}) pegasus_edges = dwave_sampler_pegasus.edgelist pegasus_graph = dnx.pegasus_graph(16, edge_list=pegasus_edges)
def setUpClass(cls): try: cls.qpu = DWaveSampler(solver=dict(flux_biases=True)) except (ValueError, ConfigFileError): raise unittest.SkipTest("no qpu available")
def solve(Q, problem, is_simulated): print('IS_SIMULATED', is_simulated) sampler = neal.SimulatedAnnealingSampler() if is_simulated else EmbeddingComposite(DWaveSampler(token=SAPI_TOKEN, endpoint=ENDPOINT, solver='DW_2000Q_2_1')) response = sampler.sample_qubo(Q, chain_strength=CHAIN_STRENGTH, num_reads=NUM_READS) return decode_solution(response, problem)
def execute(circuit, backend=None, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False, seed_mapper=None): outputs = list() inputs = list() for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == True: outputs.append( circuit.annealergraph.qubits[qubit]['components'][-1]) # can't omit output bit from being included as input, but is its put # first in the list, it will be zero the top portion of the readout inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == False: inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) sampler = DWaveSampler( endpoint='https://cloud.dwavesys.com/sapi', token='DEV-beb5d0babc40334f66b655704f1b5315917b4c41', solver='DW_2000Q_2_1') ''' qubit_weights, coupler_weights, dwavemap = circuit.annealergraph.map_to_Dwave_graph(list(sampler._nodelist), list(sampler.edgelist)) ins = list() outs = list() for name in inputs: ins.append(dwavemap[name][0]) for name in outputs: outs.append(dwavemap[name][0]) inputs = ins outputs = outs ''' qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = 100 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' print("Running...") response = EmbeddingComposite(sampler).sample(bqm, **kwargs) sampler.client.close() print("Done.") print(response.data) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) print(embedding) if len(circuit.annealergraph.qubitweights) < 18: # ExactSolver simulation print("\nExactSolver Check:") print("Simulating problem with {} qubits".format( len(circuit.annealergraph.qubitweights))) qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) sampler = dimod.ExactSolver() response = sampler.sample(bqm) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) else: print("Problem to large to simulate. Used {} qubits".format( len(circuit.annealergraph.qubitweights)))
# Be sure to count them once for each segment # s0 and s3 H += 2 * ((q[0, 0] + q[0, 1] + q[1, 0] + q[1, 1]) ** 2) # s2 and s7 and s10 H += 3 * ((q[0, 2] + q[1, 2]) ** 2) # s6 and s9 H += 2 * ((q[0, 0] + q[1, 0]) ** 2) # s8 H += (q[0, 1] + q[1, 1]) ** 2 # s11 H += (q[0, 1] + q[0, 2] + q[1, 1] + q[1, 2]) ** 2 # Compile the model, and turn it into a QUBO object model = H.compile() Q = model.to_qubo(feed_dict={'gamma': 100}) # Turn the QUBO object into a BinaryQuadraticModel, using the computed # offset bqm = BinaryQuadraticModel.from_qubo(Q[0], offset=Q[1]) # Run the QUBO on the solver from your config file response = EmbeddingComposite(DWaveSampler()).sample(bqm, chain_strength=chainstrength, num_reads=numruns) # Write complete results to file output = open('Traffic1_results.txt', 'w') for smpl, energy in response.data(['sample', 'energy']): sol, broken, eny = model.decode_solution(smpl, feed_dict={'gamma': 100}, vartype='BINARY') if not broken: output.write(str(energy) + ' ' + str([node for node in smpl if smpl[node] > 0]) + '\n') output.close()
# Import networkx for graph tools import networkx as nx # Import dwave_networkx for d-wave graph tools/functions import dwave_networkx as dnx # Import matplotlib.pyplot to draw graphs on screen import matplotlib.pyplot as plt # Set the solver we're going to use from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite # it stops in this line below sampler = EmbeddingComposite(DWaveSampler()) # Create empty graph G = nx.Graph() # Add edges to graph - this also adds the nodes G.add_edges_from([(1, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5), (4, 6), (5, 6), (6, 7)]) # Find the maximum independent set, S S = dnx.maximum_independent_set(G, sampler=sampler, num_reads=10) # Print the solution for the user print('Maximum independent set size found is', len(S)) print(S) # Visualize the results
# Create a binary constraint satisfaction problem csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY) # Add constraint that each node (province) select a single color for province in provinces: variables = [province+str(i) for i in range(colors)] csp.add_constraint(one_color_configurations, variables) # Add constraint that each pair of nodes with a shared edge not both select one color for neighbor in neighbors: v, u = neighbor for i in range(colors): variables = [v+str(i), u+str(i)] csp.add_constraint(not_both_1, variables) # Convert the binary constraint satisfaction problem to a binary quadratic model bqm = dwavebinarycsp.stitch(csp) # Set up a solver using the local system’s default D-Wave Cloud Client configuration file # and sample 50 times sampler = EmbeddingComposite(DWaveSampler()) # doctest: +SKIP response = sampler.sample(bqm, num_reads=50) # doctest: +SKIP # Plot the lowest-energy sample if it meets the constraints sample = next(response.samples()) # doctest: +SKIP if not csp.check(sample): # doctest: +SKIP print("Failed to color map") else: plot_map(sample)
def anneal(C_i, C_ij, mu, sigma, l, strength_scale, energy_fraction, ngauges, max_excited_states): #Initialising h and J as dictionnaries h = {} J = {} for i in range(len(C_i)): h_i = -2*sigma[i]*C_i[i] for j in range(len(C_ij[0])): if j > i: J[(i, j)] = float(2*C_ij[i][j]*sigma[i]*sigma[j]) h_i += 2*(sigma[i]*C_ij[i][j]*mu[j]) h[i] = h_i #applying cutoff print("Number of J before : "+str(len(J))) #J before cutoff float_vals = [] for i in J.values(): float_vals.append(i) cutoff = np.percentile(float_vals, AUGMENT_CUTOFF_PERCENTILE) to_delete = [] for k, v in J.items(): if v < cutoff: to_delete.append(k) for k in to_delete: del J[k] print("Number of J after : "+str(len(J))) # J after cutof new_Q = {} isingpartial = {} if FIXING_VARIABLES: #Optimising heuristically the number of coupling terms Q, _ = dimod.ising_to_qubo(h, J, offset = 0.0) bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset = 0.0) simple = dimod.fix_variables(bqm, sampling_mode = False) if simple == {} : new_Q = Q else : Q_indices = [] for i in Q : if i in simple.keys() : continue else : Q_indices.append(i) new_Q = {key : Q[key] for key in Q_indices} print('new length', len(new_Q)) isingpartial = simple if (not FIXING_VARIABLES) or len(new_Q) > 0: #Calling dwave machines cant_connect = True while cant_connect: try: print('about to call remote') client = Client.from_config(token='secrettoken') solver = client.get_solvers() dwave_sampler = DWaveSampler(solver={'qpu': True}) # define sampler print('called remote {}'.format(dwave_sampler)) print('solver', solver) cant_connect = False except IOError: print('Network error, trying again', datetime.datetime.now()) time.sleep(10) cant_connect = True #Tuning annealing parameters dwave_sampler.parameters["annealing_time"] = a_time dwave_sampler.parameters["num_reads"] = nreads dwave_sampler.parameters["answer_mode"] = 'raw' mapping = [] offset = 0 for i in range(len(C_i)): if i in isingpartial: mapping.append(None) offset += 1 else: mapping.append(i - offset) if FIXING_VARIABLES: new_Q_mapped = {} for (first, second), val in new_Q.items(): new_Q_mapped[(mapping[first], mapping[second])] = val h, J, _ = dimod.qubo_to_ising(new_Q_mapped) #Run gauges qaresults = np.zeros((ngauges*nreads, len(h))) print("Number of variables to anneal :"+str(len(h))) for g in range(ngauges): #Finding embedding embedded = False for attempt in range(5): a = np.sign(np.random.rand(len(h)) - 0.5) float_h = [] for i in h.values(): float_h.append(i) h_gauge = float_h*a J_gauge = {} for i in range(len(h)): for j in range(len(h)): if (i, j) in J: J_gauge[(i, j)] = J[(i, j)]*a[i]*a[j] try: print("Trying to find embeding") sampler = EmbeddingComposite(dwave_sampler) embedded = True break except ValueError: # no embedding found print('no embedding found') embedded = False continue if not embedded: continue print("Quantum annealing") try_again = True while try_again: try: #Annealing, saving energy and sample list sampleset = sampler.sample_ising(h_gauge, J_gauge, chain_strength = strength_scale) print(sampleset.info) qaresults.append(sampleset.record[0][0].tolist()) energy.append(sampleset.record[0][1]) try_again = False except: print('runtime or ioerror, trying again') time.sleep(10) try_again = True print("Quantum done") qaresults = qaresults * a qaresults[g*nreads:(g+1)*nreads] = qaresult full_strings= np.zeros((len(qaresults),len(C_i))) if FIXING_VARIABLES: j = 0 for i in range(len(C_i)): if i in isingpartial: full_strings[:, i] = 2*isingpartial[i] - 1 else: full_strings[:, i] = qaresults[:, j] j += 1 else: full_strings = qaresults s = full_strings energies = np.zeros(len(qaresults)) s[np.where(s > 1)] = 1.0 s[np.where(s < -1)] = -1.0 bits = len(s[0]) for i in range(bits): energies += 2*s[:, i]*(-sigma[i]*C_i[i]) for j in range(bits): if j > i: energies += 2*s[:, i]*s[:, j]*sigma[i]*sigma[j]*C_ij[i][j] energies += 2*s[:, i]*sigma[i]*C_ij[i][j] * mu[j] unique_energies, unique_indices = np.unique(energies, return_index=True) ground_energy = np.amin(unique_energies) if ground_energy < 0: threshold_energy = (1 - energy_fraction) * ground_energy else: threshold_energy = (1 + energy_fraction) * ground_energy lowest = np.where(unique_energies < threshold_energy) unique_indices = unique_indices[lowest] if len(unique_indices) > max_excited_states: sorted_indices = np.argsort(energies[unique_indices])[-max_excited_states:] unique_indices = unique_indices[sorted_indices] final_answers = full_strings[unique_indices] print('number of selected excited states', len(final_answers)) return final_answers else: final_answer = [] print("Evrything resolved by FIXING_VARIABLES") for i in range(len(C_i)): if i in isingpartial: final_answer.append(2*isingpartial[i] - 1) final_answer = np.array(final_answer) return np.array([final_answer])
print('Logic gate: 2 by 2 multiplier') print('=============================') print('Given virtual qubits a0, a1, b0, b1, c0, c1, c2, c3, c4;') print('list possible solutions where:') print(' C = A * B, and C = 9 (c3=1, c2=0, c1=0, c0=1)') print('') # At the top of this file, set useQpu to True to use a live QPU. # # For this tutorial we need a triangular configution, but the physical # topology of the QPU does not have triangles. There is a technique # called "embedding" that allows us to map our virtual problem onto a # physical platform. The concept of embedding is described more # thoroughly in the embedding tutorials. if (useQpu): sampler = DWaveSampler() # live QPU sampler_embedded = EmbeddingComposite(sampler) # we will need to embed # See these pages for information on embedding: # https://docs.dwavesys.com/docs/latest/c_gs_4.html # https://docs.dwavesys.com/docs/latest/c_handbook_5.html else: sampler = SimulatedAnnealingSampler() # simulated quantum annealer sampler_embedded = sampler # we do not need to embed for a simulation csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY) """ Now we tie together logic gates and operators in the form of constraints. Listing constraints is an easy way to get a problem onto the D-Wave, but it is not necessarily an optimal way to do it.