def sample_bqm(self, bqm, **params): """Sample from the specified :term:`BQM`. Args: bqm (:class:`~dimod.BinaryQuadraticModel`/str): A binary quadratic model, or a reference to one (Problem ID returned by `.upload_bqm` method). **params: Parameters for the sampling method, solver-specific. Returns: :class:`~dwave.cloud.computation.Future` Note: To use this method, dimod package has to be installed. """ # encode the request body = json.dumps({ 'solver': self.id, 'data': encode_problem_as_bq(bqm), 'type': 'bqm', 'params': params }) logger.trace("Encoded sample request: %s", body) future = Future(solver=self, id_=None, return_matrix=self.return_matrix) logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, future) return future
def sample_bqm(self, bqm, **params): """Sample from the specified :term:`BQM`. Args: bqm (:class:`~dimod.BinaryQuadraticModel`/str): A binary quadratic model, or a reference to one (Problem ID returned by `.upload_bqm` method). **params: Parameters for the sampling method, solver-specific. Returns: :class:`~dwave.cloud.computation.Future` Note: To use this method, dimod package has to be installed. """ # encode the request (body as future) body = self.client._encode_problem_executor.submit( self._encode_any_problem_as_bqm_ref, problem=bqm, params=params) # computation future holds a reference to the remote job computation = Future(solver=self, id_=None, return_matrix=self.return_matrix) logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, computation) return computation
def retrieve_problem(self, id_): """Resume polling for a problem previously submitted. Args: id_: Identification of the query. Returns: :obj: `Future` """ future = Future(self, id_, self.return_matrix, None) self.client._poll(future) return future
def _retrieve_problem(self, id_): """Resume polling for a problem previously submitted. Args: id_: Identification of the query. Returns: :class:`~dwave.cloud.computation.Future` """ future = Future(self, id_, self.return_matrix) self.client._poll(future) return future
def test_sampleset_id(self): f = Future(solver=None, id_=None) # f.id should be None self.assertIsNone(f.id) with self.assertRaises(TimeoutError): f.sampleset.wait_id(timeout=1) # set it submission_id = 'test-id' f.id = submission_id # validate it's available self.assertEqual(f.sampleset.wait_id(), submission_id) self.assertEqual(f.sampleset.wait_id(timeout=1), submission_id)
def sample_problem(self, problem, problem_type=None, label=None, **params): """Sample from the specified problem. Args: problem (dimod-model-like/str): A quadratic model (e.g. :class:`dimod.BQM`/:class:`dimod.CQM`/:class:`dimod.DQM`), or a reference to one (Problem ID returned by :meth:`.upload_problem` method). problem_type (str, optional): Problem type, one of the handled problem types by the solver. If not specified, the first handled problem type is used. label (str, optional): Problem label you can optionally tag submissions with for ease of identification. **params: Parameters for the sampling method, solver-specific. Returns: :class:`~dwave.cloud.computation.Future` """ # infer problem_type; for now just the the first handled (always just one) if problem_type is None: problem_type = next(iter(self._handled_problem_types)) # encode the request (body as future) body = self.client._encode_problem_executor.submit( self._encode_problem_for_submission, problem=problem, problem_type=problem_type, params=params, label=label) # computation future holds a reference to the remote job computation = Future(solver=self, id_=None, return_matrix=self.return_matrix) logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, computation) return computation
def _sample(self, type_, linear, quadratic, params): """Internal method for `sample_ising` and `sample_qubo`. Args: linear (list/dict): Linear terms of the model. quadratic (dict[(int, int), float]): Quadratic terms of the model. **params: Parameters for the sampling method, solver-specific. Returns: :class:`Future` """ # Check the problem if not self.check_problem(linear, quadratic): raise InvalidProblemError("Problem graph incompatible with solver.") # Mix the new parameters with the default parameters combined_params = dict(self._params) combined_params.update(params) # Check the parameters before submitting for key in combined_params: if key not in self.parameters and not key.startswith('x_'): raise KeyError("{} is not a parameter of this solver.".format(key)) # transform some of the parameters in-place self._format_params(type_, combined_params) body = json.dumps({ 'solver': self.id, 'data': encode_problem_as_qp(self, linear, quadratic), 'type': type_, 'params': combined_params }) logger.trace("Encoded sample request: %s", body) future = Future(solver=self, id_=None, return_matrix=self.return_matrix) logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, future) return future
def test_id_getter_setter(self): """Future.get_id/get_id works in isolation as expected.""" f = Future(solver=None, id_=None) # f.id should be None self.assertIsNone(f.id) with self.assertRaises(TimeoutError): f.wait_id(timeout=1) # set it submission_id = 'test-id' f.id = submission_id # validate it's available self.assertEqual(f.wait_id(), submission_id) self.assertEqual(f.wait_id(timeout=1), submission_id) self.assertEqual(f.id, submission_id)
def _sample(self, type_, linear, quadratic, params, reuse_future=None): """Internal method for both sample_ising and sample_qubo. Args: linear (list/dict): Linear terms of the model. quadratic (dict of (int, int):float): Quadratic terms of the model. **params: Parameters for the sampling method, specified per solver. Returns: :obj: `Future` """ # Check the problem if not self.check_problem(linear, quadratic): raise ValueError("Problem graph incompatible with solver.") # Mix the new parameters with the default parameters combined_params = dict(self._params) combined_params.update(params) # Check the parameters before submitting for key in combined_params: if key not in self.parameters and key != self._PARAMETER_ENABLE_HARDWARE: raise KeyError("{} is not a parameter of this solver.".format(key)) body = json.dumps({ 'solver': self.id, 'data': encode_bqm_as_qp(self, linear, quadratic), 'type': type_, 'params': params }) # Construct where we will put the result when we finish, submit the query if reuse_future is not None: future = reuse_future future.__init__(self, None, self.return_matrix, (type_, linear, quadratic, params)) else: future = Future(self, None, self.return_matrix, (type_, linear, quadratic, params)) _LOGGER.debug("Submitting new problem to: %s", self.id) self.client._submit(body, future) return future
def _sample(self, type_, linear, quadratic, params): """Internal method for both sample_ising and sample_qubo. Args: linear (list/dict): Linear terms of the model. quadratic (dict of (int, int):float): Quadratic terms of the model. **params: Parameters for the sampling method, specified per solver. Returns: :obj: `Future` """ # Check the problem if not self.check_problem(linear, quadratic): raise ValueError("Problem graph incompatible with solver.") # Mix the new parameters with the default parameters combined_params = dict(self._params) combined_params.update(params) # Check the parameters before submitting for key in combined_params: if key not in self.parameters and not key.startswith('x_'): raise KeyError( "{} is not a parameter of this solver.".format(key)) body = json.dumps({ 'solver': self.id, 'data': encode_bqm_as_qp(self, linear, quadratic), 'type': type_, 'params': params }) _LOGGER.trace("Encoded sample request: %s", body) future = Future(solver=self, id_=None, return_matrix=self.return_matrix, submission_data=(type_, linear, quadratic, params)) _LOGGER.debug("Submitting new problem to: %s", self.id) self.client._submit(body, future) return future
def _sample(self, type_, linear, quadratic, offset, params, label=None, undirected_biases=False): """Internal method for `sample_ising`, `sample_qubo` and `sample_bqm`. Args: linear (list/dict): Linear terms of the model. quadratic (dict[(int, int), float]): Quadratic terms of the model. offset (number): Constant offset applied to the model. params (dict): Parameters for the sampling method, solver-specific. label (str, optional): Problem label. undirected_biases (boolean, default=False): Are (quadratic) biases specified on undirected edges? For triangular or symmetric matrix of quadratic biases set it to ``True``. Returns: :class:`~dwave.cloud.computation.Future` """ # Check the problem if not self.check_problem(linear, quadratic): raise ProblemStructureError( f"Problem graph incompatible with {self.id} solver") # Mix the new parameters with the default parameters combined_params = dict(self._params) combined_params.update(params) # Check the parameters before submitting for key in combined_params: if key not in self.parameters and not key.startswith('x_'): raise KeyError("{} is not a parameter of this solver.".format(key)) # transform some of the parameters in-place self._format_params(type_, combined_params) body_dict = { 'solver': self.id, 'data': encode_problem_as_qp(self, linear, quadratic, offset, undirected_biases=undirected_biases), 'type': type_, 'params': combined_params } if label is not None: body_dict['label'] = label body_data = json.dumps(body_dict) logger.trace("Encoded sample request: %s", body_data) body = Present(result=body_data) computation = Future(solver=self, id_=None, return_matrix=self.return_matrix) # XXX: offset is carried on Future until implemented in SAPI computation._offset = offset logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, computation) return computation
def _sample(self, type_, linear, quadratic, params, undirected_biases=False): """Internal method for `sample_ising`, `sample_qubo` and `sample_bqm`. Args: linear (list/dict): Linear terms of the model. quadratic (dict[(int, int), float]): Quadratic terms of the model. params (dict): Parameters for the sampling method, solver-specific. undirected_biases (boolean, default=False): Are (quadratic) biases specified on undirected edges? For triangular or symmetric matrix of quadratic biases set it to ``True``. Returns: :class:`Future` """ args = dict(type_=type_, linear=linear, quadratic=quadratic, params=params) dispatch_event('before_sample', obj=self, args=args) # Check the problem if not self.check_problem(linear, quadratic): raise InvalidProblemError( "Problem graph incompatible with solver.") # Mix the new parameters with the default parameters combined_params = dict(self._params) combined_params.update(params) # Check the parameters before submitting for key in combined_params: if key not in self.parameters and not key.startswith('x_'): raise KeyError( "{} is not a parameter of this solver.".format(key)) # transform some of the parameters in-place self._format_params(type_, combined_params) body_data = json.dumps({ 'solver': self.id, 'data': encode_problem_as_qp(self, linear, quadratic, undirected_biases=undirected_biases), 'type': type_, 'params': combined_params }) logger.trace("Encoded sample request: %s", body_data) body = Present(result=body_data) computation = Future(solver=self, id_=None, return_matrix=self.return_matrix) logger.debug("Submitting new problem to: %s", self.id) self.client._submit(body, computation) dispatch_event('after_sample', obj=self, args=args, return_value=computation) return computation