def solve(self, matrix, initial=()): ''' returns: a solution solution is a tuple (dict, float) representing sample and energy. ''' if bool(initial): initial_sample = list(initial[0].values()) print("initial sample: ",initial_sample) print("solver starts the process...") mtx = matrix.copy() print("converting to upper triangular...") mtx = mt.to_upper_triangular(mtx) print("matrix has %d zeros out of %d" % (np.count_nonzero(mtx==0), mtx.shape[0]*mtx.shape[1])) np.savetxt("mtx.txt", mtx, fmt='%d') Q = {} size = mtx.shape[0] for i,j in itertools.product(range(size),range(size)): if i==j: if mtx[i][i]: Q[(i,i)] = mtx[i][i] elif i<j: if mtx[i][j]: Q[(i,j)] = mtx[i][j] else: pass print("Solver engages Dwave quantum hardware!") sampler = dimod.ScaleComposite(EmbeddingComposite(DWaveSampler())) anneal_schedule = [(0,1),(4,0.5),(14,0.5),(20,1)] if bool(initial): print(initial) initial_state_dict = initial[0] response = sampler.sample_qubo(Q,num_reads=50, anneal_schedule=anneal_schedule, initial_state=initial_state_dict) else: response = sampler.sample_qubo(Q,num_reads=50, annealing_time=20) timing_iter = (response.info['timing']['qpu_sampling_time'] / 1000000) self.timing += timing_iter print(timing_iter) print(response.info) for datum in response.data(fields=['sample','energy','num_occurrences']): print(datum) break return (response.first.sample, response.first.energy)
def test_scale_aware_scale_composite(self): nodelist = [0, 1, 2] edgelist = [(0, 1), (1, 2), (0, 2)] embedding = {'a': [0], 'b': [1, 2]} sampler = FixedEmbeddingComposite(dimod.TrackingComposite( dimod.ScaleComposite( dimod.StructureComposite(dimod.NullSampler(), nodelist, edgelist))), embedding=embedding, scale_aware=True) _ = sampler.sample_ising({'a': 100, 'b': -100}, {'ab': 300}) self.assertIn('ignored_interactions', sampler.child.input) ignored = sampler.child.input['ignored_interactions'] self.assertTrue(ignored == [(1, 2)] or ignored == [(2, 1)])
def sample(self, bqm, chain_strength=None, **kwargs): """Sample from the specified binary quadratic model. Args: bqm (:class:`~dimod.BinaryQuadraticModel`): Any binary quadratic model with up to :attr:`.largest_clique_size` variables. This BQM is embedded using a dense clique embedding. chain_strength (float, optional): The (relative) chain strength to use in the embedding. By default a chain strength of `1.5sqrt(N)` where `N` is the size of the largest clique, as returned by :attr:`.largest_clique_size`. **kwargs: Optional keyword arguments for the sampling method, specified per solver in :attr:`.DWaveCliqueSampler.parameters`. D-Wave System Documentation's `solver guide <https://docs.dwavesys.com/docs/latest/doc_solver_ref.html>`_ describes the parameters and properties supported on the D-Wave system. Note that `auto_scale` is not supported by this sampler, because it scales the problem as part of the embedding process. """ # some arguments should not be overwritten if 'auto_scale' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'auto_scale'") if 'bias_range' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'bias_range'") if 'quadratic_range' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'quadratic_range'") # handle circular import. todo: fix from dwave.system.composites.embedding import FixedEmbeddingComposite # get the embedding embedding = find_clique_embedding(bqm.variables, self.target_graph, use_cache=True) # returns an empty embedding when the BQM is too large if not embedding and bqm.num_variables: raise ValueError("Cannot embed given BQM (size {}), sampler can " "only handle problems of size {}".format( len(bqm.variables), self.largest_clique_size)) assert bqm.num_variables == len(embedding) # sanity check if chain_strength is None: # chain length determines chain strength if embedding and bqm.num_interactions > 0: squared_j = (j ** 2 for j in bqm.quadratic.values()) rms = math.sqrt(sum(squared_j)/bqm.num_interactions) chain_strength = 1.5 * rms * math.sqrt(bqm.num_variables) else: chain_strength = 1 # doesn't matter # scaling only make sense in Ising space original_bqm = bqm if bqm.vartype is not dimod.SPIN: bqm = bqm.change_vartype(dimod.SPIN, inplace=False) sampler = FixedEmbeddingComposite( dimod.ScaleComposite(self.child), embedding) if 'auto_scale' in self.child.parameters: kwargs['auto_scale'] = False sampleset = sampler.sample(bqm, bias_range=self.qpu_linear_range, quadratic_range=self.qpu_quadratic_range, chain_strength=chain_strength, **kwargs ) # change_vartype is non-blocking return sampleset.change_vartype(original_bqm.vartype)
def sample(self, bqm, chain_strength=None, **kwargs): """Sample from the specified binary quadratic model. Args: bqm (:class:`~dimod.BinaryQuadraticModel`): Any binary quadratic model with up to :attr:`.largest_clique_size` variables. This BQM is embedded using a clique embedding. chain_strength (float/mapping/callable, optional): Sets the coupling strength between qubits representing variables that form a :term:`chain`. Mappings should specify the required chain strength for each variable. Callables should accept the BQM and embedding and return a float or mapping. By default, `chain_strength` is calculated with :func:`~dwave.embedding.chain_strength.uniform_torque_compensation`. **kwargs: Optional keyword arguments for the sampling method, specified per solver in :attr:`.parameters`. D-Wave System Documentation's `solver guide <https://docs.dwavesys.com/docs/latest/doc_solver_ref.html>`_ describes the parameters and properties supported on the D-Wave system. Note that `auto_scale` is not supported by this sampler, because it scales the problem as part of the embedding process. """ # some arguments should not be overwritten if 'auto_scale' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'auto_scale'") if 'bias_range' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'bias_range'") if 'quadratic_range' in kwargs: raise TypeError("sample() got an unexpected keyword argument " "'quadratic_range'") # handle circular import. todo: fix from dwave.system.composites.embedding import FixedEmbeddingComposite # get the embedding embedding = find_clique_embedding(bqm.variables, self.target_graph, use_cache=True) # returns an empty embedding when the BQM is too large if not embedding and bqm.num_variables: raise ValueError("Cannot embed given BQM (size {}), sampler can " "only handle problems of size {}".format( len(bqm.variables), self.largest_clique_size)) assert bqm.num_variables == len(embedding) # sanity check # scaling only make sense in Ising space original_bqm = bqm if bqm.vartype is not dimod.SPIN: bqm = bqm.change_vartype(dimod.SPIN, inplace=False) sampler = FixedEmbeddingComposite(dimod.ScaleComposite(self.child), embedding) if 'auto_scale' in self.child.parameters: kwargs['auto_scale'] = False sampleset = sampler.sample(bqm, bias_range=self.qpu_linear_range, quadratic_range=self.qpu_quadratic_range, chain_strength=chain_strength, **kwargs) # change_vartype is non-blocking return sampleset.change_vartype(original_bqm.vartype)