def solve_multi(self, verbose=False, num_repeats=200): if self.qubo is None: self.pre_process() if verbose: print("Solving multiple solutions of MAX-SMTI with Qbsolv") if self.qubo_size == 0 or self.qubo_size == 1: return [Solution(self.matching, self.pre_evaluated_solution)] if self.mode == "np": # more memory intensive response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats) elif self.mode == "bqm": response = QBSolv().sample(self.qubo, num_repeats=num_repeats) else: raise Exception(f"mode: {self.mode} cannot be solved yet") if verbose: print(response) for index, sample in enumerate(list(response.samples())): match, valid = self.encode(sample) print(index, ":", Solution(self.matching, match).is_stable(), match, valid) opt_en = self.get_optimal_energy(self.matching.size) solutions = [] for sample, energy, occ in response.record: if energy == opt_en: match, valid = self.encode_qa(sample.tolist()) if verbose and not valid: print("Invalid encoding and valid energy!") solutions.append(Solution(self.matching, match)) return solutions
def qbsolv_solver(self, ising=True): """ qbsolv is for breaking up large optmisation problems into smaller ones for the D-Wave machines. This function has not been properly implemented yet. """ if ising: response = QBSolv().sample_ising(self.h, self.j) else: response = QBSolv().sample_qubo(self.q_dict) min_energy = 0 for sample in response.data(['sample', 'energy']): sample_dict = { 'sample': {k: int((1 + sample[0][k]) / 2) for k in sample[0]} } sample_dict.update({'energy': sample[1]}) self.samples.append(sample_dict) min_energy = min(sample[1], min_energy) self.solution = { f'x{k+1}': v for k, v in sample_dict['sample'].items() if k < len(self.masses) } if min_energy == sample[1] else self.solution self._solution_blocks() return response
def solve_multi_data(self, verbose=False, target=None, num_repeats=200): if self.qubo is None: self.pre_process() if verbose: print("Solving multiple solutions of MAX-SMTI with Qbsolv") if self.qubo_size == 0 or self.qubo_size == 1: return [Solution(self.matching, self.pre_evaluated_solution)] if self.mode == "np": # more memory intensive response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats, target=target, algorithm=SOLUTION_DIVERSITY) elif self.mode == "bqm": response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target) else: raise Exception(f"mode: {self.mode} cannot be solved yet") if verbose: print(response) for index, sample in enumerate(list(response.samples())): match, valid = self.encode(sample) print(index, ":", Solution(self.matching, match).is_stable(), match, valid) samples = pd.DataFrame() for sample, energy, occ in response.record: match, valid = self.encode_qa(sample.tolist()) stable, size = Solution(self.matching, match).is_stable() samples = samples.append({"match": match, "sample": sample.tolist(), "energy": energy, "occ": occ, "valid": valid, "stable": stable, "size": size}, ignore_index=True) return samples
def qubo_extractor(img,file_name): img_name, ext = file_name.split(".") (M,N) = img.shape[0:2] coupler_count = 0 Q = {} for i in range(M): for j in range(N): foreground_node_id = (i*N*2)+(j*2) background_node_id = foreground_node_id+1 #foreground qubit Q[(foreground_node_id,foreground_node_id)] = unary_potential(img,1,i,j) #background qubit Q[(background_node_id,background_node_id)] = unary_potential(img,0,i,j) #for qubits of same pixel - high cost should be given here to ensure both qubits are not open Q[(foreground_node_id,background_node_id)] = 10 coupler_count += 1 #for neighbors neighbors = find_neighbors(img,i,j) for k in neighbors: neighbor_foreground_node_id = (k[0]*N*2)+(k[1]*2) neighbor_background_node_id = neighbor_foreground_node_id+1 #f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' ) #f.write(' '+ str(background_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' ) #f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' ) #f.write(' '+ str(background_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' ) #coupler_count += 1 #print(Q) response = QBSolv().sample_qubo(Q) result = list(response.samples()) counter = 1 out = [] array = result[0] for i in array: mode = counter if(counter > (N*M*2)): continue if(mode%2 == 1): if array[i] == 1: out.append(int(255)) else: out.append(0) counter += 1 out=numpy.array(out) out = out.reshape(M,N) img_name, ext = file_name.split(".") if(os.path.isdir("result/" + img_name) != 1): call(["mkdir","result/" + img_name]) rel_path = "result/" +img_name + "/" output_file_name = str(img_name) + "_out_python." + str(ext) file_path = rel_path + output_file_name scipy.misc.imsave(file_path,out)
def Solver(H,J): from dwave_qbsolv import QBSolv h=dict(enumerate(H.flatten(),0)) j=dict(((i,j),J[i][j]) for i in range(len(J)) for j in range(len(J[0])) if i>j and J[i][j] !=0) response = QBSolv().sample_ising(h,j) sample=list(response.samples()) value=list(sample[0].values()) return value
def solve(self, options): """ Options: 'solver' - see solver input to Qbsolve.sample, default 'tabu' 'top_samples' - int, how many samples to print 'visualize' - boolean, 'verbosity' - int, default 0 (low) """ DEFAULT_OPTIONS = { 'solver': 'tabu', 'top_samples': 1, 'visualize': False, 'verbosity': 0, 'repititions': 5 } complete_options = DEFAULT_OPTIONS.copy() complete_options.update(options) # get hamiltonian q = self.make_Q() # from np matrix to dwave representation Q = dimod.BinaryQuadraticModel.from_numpy_matrix(q) total_time = 0 for _ in range(complete_options['repititions']): start_time = timer() # solve using QBSolv response = QBSolv().sample(Q, verbosity=complete_options['verbosity'], solver=complete_options['solver']) end_time = timer() if not complete_options['no_time']: print(f'time to solve: {end_time - start_time} s') total_time += end_time - start_time for sample_i, sample in enumerate( response.samples()[0:complete_options['top_samples']]): X = self.sample_to_x_ij_matrix(sample) print(f'------- sample {sample_i} -------') print('solution is valid:', self.is_solution_valid(X)) print('energy:', response.record.energy[sample_i]) print('total U:', self.objective_value(X.flat)) if complete_options['visualize']: positions = self.sample_to_positions(sample) self.plot_3d(positions) avg_time = total_time / complete_options['repititions'] print(f'average time: {avg_time} s')
def Solver(H, J): from dwave_qbsolv import QBSolv from dwave.system.samplers import DWaveSampler from dwave.system.composites import EmbeddingComposite from dwave.cloud import Client import itertools import random sampler = EmbeddingComposite( DWaveSampler(token='DEV-34ebdd33f77f73904ed58bac612191ccdce89841')) h = dict(enumerate(H.flatten(), 0)) j = dict(((i, j), J[i][j]) for i in range(len(J)) for j in range(len(J[0])) if i > j and J[i][j] != 0) response = QBSolv().sample_ising(h, j, solver=sampler) sample = list(response.samples()) print(sample) return sample
def get_solver(solver_type): solver = None if solver_type == 'qpu': solver = hybrid_solver() if solver_type == 'cpu': solver = QBSolv() return solver
def main(): """Entrypoint of this script. Synopsis is as follows: - construct qubo of some predefined size - solve it using QBSolv with patched sampler - show what is recorded """ with open('dwave_credentials.txt') as token_file: token = token_file.read() qubo_dict = get_random_qubo(50) sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=ENDPOINT)) with record_sampler_invocations(sampler) as records: response = QBSolv().sample_qubo(qubo_dict, solver_limit=30, solver=sampler) print('Sampler was invoked this many times: {}'.format(len(records))) # In this example we take only qubo calls - when I tested it it were the only # ones made qubo_timings = [ record['timing'] for record in records if record['method'] == 'qubo' ] total_sampling_time = sum(record['qpu_sampling_time'] for record in qubo_timings) print('Average QPU samping time [QUBO]: {}'.format(total_sampling_time / len(qubo_timings)))
def sample_qubo_slices(self, Q: TQubo = None, return_time=False, logfile: str = None, seed: int=None, **qbsolv_params)\ -> ResponseContainer: #-> Union[object, Tuple[object, float]]: """ Submit a QUBO to (see `qbsolv <https://github.com/dwavesystems/qbsolv>`_). :param Q: the QUBO's in the from of a QuboSlice container. If not defined, :py:meth:~`to_qubo` will be called. :param return_time: if set, also return the execution time (in seconds) :param qbsolv_params: parameters to pass to qbsolv's `sample_qubo` method :param logfile: path to a file. if set, all qbsolv output will be redirected to this file :param seed: the random seed for qbsolv. **MUST** be a 32-bits integer with entropy ! :return: a dimod response or a tuple (dimod response, exec_time) (see `dimod.Response <https://docs.ocean.dwavesys.com/projects/dimod/en/latest/reference/response.html>`_) """ if Q is None: Q = self.to_qubo() if seed is None: import random seed = random.randint(0, 1 << 31) # Instantiate a container to hold all qubo responses responsecontainer = ResponseContainer() # run qbsolv start_time = time.process_time() for qubo in Q.quboList: if bool(qubo.qubo): try: with capture_stdout(logfile): ##make dummy QBSOLV response = QBSolv().sample_qubo(qubo.qubo, seed=seed, **qbsolv_params) except: # fails if called from ipython notebook... response = QBSolv().sample_qubo(qubo.qubo, seed=seed, **qbsolv_params) exec_time = time.process_time() - start_time if bool(qubo.qubo): self.logger.info( f'QUBO of size {len(qubo.qubo)} sampled in {exec_time:.2f}s (seed {seed}).' ) responseSlice = ResponseSlice(r=response, eta=qubo.eta, phi=qubo.phi) responsecontainer.addResponse(r=responseSlice) traceback.extract_stack() return (responsecontainer, exec_time) if return_time else responsecontainer
def solve(self, verbose=False, num_repeats=100, target=None): if self.qubo is None: self.create_qubo() if self.mode == "np": # more memory intensive response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target) elif self.mode == "bqm": response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target) else: raise Exception(f"mode: {self.mode} cannot be solved yet") if verbose: print(response) energies = list(response.data_vectors['energy']) min_en = min(energies) ret_match = self.encode(list(response.samples())[energies.index(min_en)]) return Solution(self.matching, ret_match)
def solve_multi(self, verbose=True, num_repeats=100, target=None): if self.qubo is None: self.create_qubo() if self.mode == "np": # more memory intensive response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target) elif self.mode == "bqm": response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target) else: raise Exception(f"mode: {self.mode} cannot be solved yet") if verbose: print(response) n = self.matching.size stable_energy = -3 / 2 * self.p1 * (n - 1) * n energies = list(response.data_vectors['energy']) samples = enumerate(list(response.samples())) allowed_samples = [sample for idx, sample in samples if energies[idx] == stable_energy] return [Solution(self.matching, self.encode(sample)) for sample in allowed_samples]
def _get_raw_solutions(self, problem, **params): logger = logging.getLogger(__name__) solver_params = self._extract_kwargs(params, self.DEFAULT_SOLVER_PARAMS) qubo_params = self._extract_kwargs(params, self.DEFAULT_QUBO_PARAMS) logger.debug('Using solver parameters: %s', solver_params) logger.debug('Using qubo parameters: %s', qubo_params) response = QBSolv().sample_qubo(problem.get_qubo_dict(**qubo_params), solver='tabu') return response
def solve_tsp(self): #response = EmbeddingComposite(DWaveSampler(token=self.sapi_token, endpoint=self.url, solver='DW_2000Q_5')).sample_qubo(self.qubo_dict, chain_strength=self.chainstrength, num_reads=self.numruns) #sampler = EmbeddingComposite(DWaveSampler(token=self.sapi_token, endpoint=self.url, solver='DW_2000Q_5')) #response = QBSolv().sample_qubo(Q, solver=sampler, solver_limit=subqubo_size) subqubo_size = 6 response = QBSolv().sample_qubo(self.qubo_dict, chain_strength=self.chainstrength, num_reads=self.numruns, solver_limit=subqubo_size) self.decode_solution(response) return self.solution, self.distribution
def solve_tsp_Qbsolv_c(Q, G): response = QBSolv().sample_qubo(Q) sample = response.first.sample adj_mat = [None] * len(G) for (u, v), val in sample.items(): if val: adj_mat[u] = v cost = calculate_cost(nx.to_numpy_array(G), adj_mat=adj_mat) return (adj_mat, cost)
def qb(dets, thresh=None, confidence=None, ax=None): from dwave_qbsolv import QBSolv x1 = dets[:, 0] y1 = dets[:, 1] x2 = dets[:, 2] y2 = dets[:, 3] scores = dets[:, 4] if len(scores) == 0: return [] elif len(scores) == 1: return [0] areas = (x2 - x1 + 1) * (y2 - y1 + 1) ious = {} #np.zeros([len(x1), len(x1)]) w2 = 0.4 for i in range(len(x1)): xx1 = np.maximum(x1[i], x1) yy1 = np.maximum(y1[i], y1) xx2 = np.minimum(x2[i], x2) yy2 = np.minimum(y2[i], y2) w = np.maximum(0.0, xx2 - xx1 + 1) h = np.maximum(0.0, yy2 - yy1 + 1) inter = w * h ovr = inter / (areas[i] + areas - inter) for j in range(len(ovr)): if i == j: ious[i, i] = -(1 - w2) * scores[i] ious[i, j] += w2 * ovr[j] else: ious[i, j] = w2 * ovr[j] response = QBSolv().sample_qubo(ious, verbosity=0) samples = list(response.samples())[0] keep = [] for i in range(len(x1)): if samples[i] == 1: keep.append(i) #if len(keep) == 0: # keep_dets = np.ndarray((0, 4)) #else: # keep_dets = dets[keep] ## print(keep_dets) #return keep_dets return keep
def QBSolve_QC_solution(Qdict, token="DEV-3fd7a21d8cf1afa9655ac1d7e9cb809bc3d7f7dc", print_energy=False): """This function use QC to get solution dictionary""" endpoint = 'https://cloud.dwavesys.com/sapi' sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=endpoint)) response = QBSolv().sample_qubo(Qdict, solver=sampler) if print_energy: print("energies=" + str(list(response.data_vectors['energy']))) qb_solution = list(response.samples()) print("\n\nqb_solution: ", qb_solution) return qb_solution
def QBSolve_classical_solution(Qdict, print_energy=False): """This function use classical QBSolve to get solution dictionary""" start = time.clock() response = QBSolv().sample_qubo(Qdict) qb_solution = list(response.samples()) if print_energy: print("energies=" + str(list(response.data_vectors['energy']))) end = time.clock() time_taken = end - start print("Time taken by classical QBSolv: ", time_taken) return qb_solution
def qbsolve(Q, size=30): q_min = 0 a_min = [] response = QBSolv().sample_qubo(Q) for res in response.samples(): a = np.empty(size) for key in res: a[key] = res[key] #------------------------------------------ q = 0 for i in xrange(size): for j in xrange(size): if (i, j) in Q: q += Q[(i, j)] * a[i] * a[j] if q < q_min: q_min = q a_min = a return a_min, q_min
def get_solver(solver_type): solver = None if solver_type == 'standard': solver = EmbeddingComposite(DWaveSampler()) if solver_type == 'hybrid': solver = hybrid_solver() if solver_type == 'kerberos': solver = KerberosSampler() if solver_type == 'qbsolv': solver = QBSolv() return solver
def solve(self, verbose=False, num_repeats=50, target=None, debug=False): if self.qubo is None: self.pre_process() if verbose: print("Solving MAX-SMTI with Qbsolv") if self.qubo_size == 0 or self.qubo_size == 1: if debug: return None return Solution(self.matching, self.pre_evaluated_solution) if self.mode == "np": # more memory intensive response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats, target=target) elif self.mode == "bqm": response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target) else: raise Exception(f"mode: {self.mode} cannot be solved yet") if debug: return response if verbose: print(response) for index, sample in enumerate(list(response.samples())): match, valid = self.encode(sample) print(index, ":", Solution(self.matching, match).is_stable(), match, valid) energies = list(response.data_vectors['energy']) min_en = min(energies) ret_match, valid = self.encode(list(response.samples())[energies.index(min_en)]) return Solution(self.matching, ret_match, energy=min_en)
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 solve_qbsolv(Q, logfile=None, seed=None, **kwargs): from hepqpr.qallse.other.stdout_redirect import capture_stdout from dwave_qbsolv import QBSolv # generate seed for logging purpose if seed is None: import random seed = random.randint(0, 1 << 31) # run qbsolv logger.debug('Running qbsolv with extra arguments: %s', kwargs) start_time = time.process_time() if logfile is not None: logger.debug( f'Writting qbsolv output to {logfile}. If you see an output in stdout, run "export PYTHONUNBUFFERED=1".' ) with capture_stdout(logfile): response = QBSolv().sample_qubo(Q, seed=seed, **kwargs) else: response = QBSolv().sample_qubo(Q, seed=seed, **kwargs) exec_time = time.process_time() - start_time logger.info( f'QUBO of size {len(Q)} sampled in {exec_time:.2f}s (QBSOLV, seed={seed}).' ) return response
def sample_qubo(self, Q: TQubo = None, return_time=False, logfile: str = None, seed: int = None, **qbsolv_params) -> Union[object, Tuple[object, float]]: """ Submit a QUBO to (see `qbsolv <https://github.com/dwavesystems/qbsolv>`_). :param Q: the QUBO. If not defined, :py:meth:~`to_qubo` will be called. :param return_time: if set, also return the execution time (in seconds) :param qbsolv_params: parameters to pass to qbsolv's `sample_qubo` method :param logfile: path to a file. if set, all qbsolv output will be redirected to this file :param seed: the random seed for qbsolv. **MUST** be a 32-bits integer with entropy ! :return: a dimod response or a tuple (dimod response, exec_time) (see `dimod.Response <https://docs.ocean.dwavesys.com/projects/dimod/en/latest/reference/response.html>`_) """ if Q is None: Q = self.to_qubo() if seed is None: import random seed = random.randint(0, 1 << 31) # run qbsolv start_time = time.process_time() try: with capture_stdout(logfile): response = QBSolv().sample_qubo(Q, seed=seed, **qbsolv_params) except: # fails if called from ipython notebook... response = QBSolv().sample_qubo(Q, seed=seed, **qbsolv_params) exec_time = time.process_time() - start_time self.logger.info( f'QUBO of size {len(Q)} sampled in {exec_time:.2f}s (seed {seed}).' ) return (response, exec_time) if return_time else response
def do_calculation(simul): if simul == "dwave": _sampler = EmbeddingComposite(DWaveSampler()) _response = QBSolv().sample_qubo(qubo, num_repeats=NUM_REPEATS, verbosity=VERBOSITY_LEVEL, solver=_sampler) elif simul == "dimod": _sampler = dimod.ExactSolver() _response = QBSolv().sample_qubo(qubo, num_repeats=NUM_REPEATS, verbosity=VERBOSITY_LEVEL, solver=_sampler) elif simul == "neal": _sampler = neal.SimulatedAnnealingSampler() _response = QBSolv().sample_qubo(qubo, num_repeats=NUM_REPEATS, verbosity=VERBOSITY_LEVEL, solver=_sampler) else: _response = QBSolv().sample_qubo(qubo, num_repeats=NUM_REPEATS, verbosity=VERBOSITY_LEVEL) return _response
def solve_qubo(qubo, solver_type='qbsolv', limit=1, num_reads=50): sampler = get_solver(solver_type) response = None if solver_type == 'hybrid': response = sampler.sample_qubo(qubo.dict) elif solver_type == 'qbsolv': response = sampler.sample_qubo(qubo.dict, num_reads=num_reads) elif solver_type == 'standard': response = QBSolv().sample_qubo(qubo.dict, solver=sampler, chain_strength=800, num_reads=num_reads) else: response = sampler.sample_qubo(qubo.dict, num_reads=num_reads) return list(response)[:limit]
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 pyqubo_response(df, param_a, param_b, param_c, num_reads, do_qbsolve): t_list = calc_marginals(df) #make H N = len(df) Y = Array.create('Y', shape=N, vartype='BINARY') ysum = sum(y for y in Y) H_0 = (ysum - t_list[0])**2 sex = df['SEX'].values.tolist() sex_array = sum(s * y for s, y in zip(sex, Y)) H_1 = (sex_array - t_list[1])**2 aop = df['AOP'].values.tolist() aop_array = sum(a * y for a, y in zip(aop, Y)) H_2 = (aop_array - t_list[2])**2 alpha = Placeholder("alpha") beta = Placeholder("beta") gamma = Placeholder("gamma") H = alpha * H_0 + beta * H_1 + gamma * H_2 #パラメータ feed_dict = {'alpha': param_a, 'beta': param_b, 'gamma': param_c} #QUBOのコンパイル model = H.compile() qubo, offset = model.to_qubo(feed_dict=feed_dict) if do_qbsolve == True: res = QBSolv().sample_qubo(qubo, num_reads=num_reads) else: s3_destination_folder = ('amazon-braket-ecc806acea4c', 'qaExactLogisticRegression_ssato') dw = BraketDWaveSampler( s3_destination_folder, device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6') qa_sampler = AutoEmbeddingComposite(dw) res = qa_sampler.sample(bqm, chain_strength=chain_strength, auto_scale=True, chain_break_fraction=True, num_reads=num_reads) return res
def get_ocean_qubo_re(traveling_cost_qubo, traveling_qubo, B, cities_size): # solver = client.get_solver() p_qubo = traveling_qubo + traveling_cost_qubo * B keys = [] for i in range(len(p_qubo[0])): for j in range(len(p_qubo[1])): keys.append((i, j)) Q = {key: val for key, val in zip(keys, p_qubo.reshape(-1))} # sampler = neal.SimulatedAnnealingSampler() sampler = EmbeddingComposite(DWaveSampler()) # print(Q) result = QBSolv(qpu_reads = 1000).sample_qubo(Q, num_reads=10, qpu_sampler=sampler) result_dw = result.first.sample # result = sampler.sample_qubo(Q,num_reads=10) # for sample in computation.samples: # result = sample print(result_dw) return result_dw
def create_sampler(self): if None == self.sampler: composite = None _inner_sampler = None if self.mode == self.op_mode_quantum: _inner_sampler = self.base_sampler elif self.mode == self.op_mode_simulated_annealing: _inner_sampler = SimulatedAnnealingSampler() elif self.mode == self.op_mode_qbsolv: _inner_sampler = QBSolv() else: raise ValueError( "op_mode {} is not known. (only 1,2,3)".format(self.mode)) composite = StructureComposite(_inner_sampler, self.base_sampler.nodelist, self.base_sampler.edgelist) self.sampler = FixedEmbeddingComposite(composite, self.embedding)