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_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 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 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 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
from dwave.cloud.qpu import Client
from dwave.cloud.computation import Future
# setup local logger
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
with Client.from_config(profile='prod') as client:
solvers = client.get_solvers()
logger.info("Solvers available: %r", solvers)
solver = client.get_solver()
comps = [solver.sample_qubo({}, num_reads=1) for _ in range(20)]
for comp in Future.as_completed(comps):
try:
result = comp.result()
except Exception as e:
logger.info("Computation %s failed: %r", comp.id, e)
logger.info("Computation %s succeeded:", comp.id)
logger.info(" - time received: %s", comp.time_received)
logger.info(" - time solved: %s", comp.time_solved)
logger.info(" - parse time: %s", comp.parse_time)
logger.info(" - remote status: %s", comp.remote_status)
