def test_qpu_request_encoding(self):
solver = get_solver()
linear = {index: 1 for index in solver.nodes}
quadratic = {key: -1 for key in solver.undirected_edges}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
self.assertEqual(request['lin'], 'AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8=')
self.assertEqual(request['quad'], 'AAAAAAAA8L8AAAAAAADwvwAAAAAAAPC/AAAAAAAA8L8=')
def test_qpu_request_encoding_all_qubits(self):
"""Test biases and coupling strengths are properly encoded (base64 little-endian doubles)."""
solver = get_solver()
linear = {index: 1 for index in solver.nodes}
quadratic = {key: -1 for key in solver.undirected_edges}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
self.assertEqual(request['lin'], self.encode_doubles([1, 1, 1, 1]))
self.assertEqual(request['quad'], self.encode_doubles([-1, -1, -1,
-1]))
def test_qpu_request_encoding_sub_qubits_implicit_couplings(self):
"""Couplings should be zero for active qubits, if not specified."""
solver = get_solver()
linear = {0: 0, 3: 0}
quadratic = {}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
# [0, NaN, NaN, 0]
self.assertEqual(request['lin'],
self.encode_doubles([0, self.nan, self.nan, 0]))
# [0]
self.assertEqual(request['quad'], self.encode_doubles([0]))
def test_qpu_request_encoding_sub_qubits_implicit_biases(self):
"""Biases don't have to be specified for qubits to be active."""
solver = get_solver()
linear = {}
quadratic = {(0, 3): -1}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
# [0, NaN, NaN, 0]
self.assertEqual(request['lin'],
self.encode_doubles([0, self.nan, self.nan, 0]))
# [-1]
self.assertEqual(request['quad'], self.encode_doubles([-1]))
def test_qpu_request_encoding_missing_qubits(self):
"""Qubits don't have to be specified with biases only, but also with couplings."""
solver = get_solver()
linear = {}
quadratic = {(0, 1): -1}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
# [0, 0, NaN, NaN]
self.assertEqual(request['lin'],
self.encode_doubles([0, 0, self.nan, self.nan]))
# [-1]
self.assertEqual(request['quad'], self.encode_doubles([-1]))
def test_qpu_request_encoding_sub_qubits(self):
"""Inactive qubits should be encoded as NaNs. Inactive couplers should be omitted."""
solver = get_solver()
linear = {index: 1 for index in sorted(list(solver.nodes))[:2]}
quadratic = {
key: -1
for key in sorted(list(solver.undirected_edges))[:1]
}
request = encode_bqm_as_qp(solver, linear, quadratic)
self.assertEqual(request['format'], 'qp')
# [1, 1, NaN, NaN]
self.assertEqual(request['lin'],
self.encode_doubles([1, 1, self.nan, self.nan]))
# [-1]
self.assertEqual(request['quad'], self.encode_doubles([-1]))
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))
# transform some of the parameters in-place
self._format_params(type_, combined_params)
body = json.dumps({
'solver': self.id,
'data': encode_bqm_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,
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, 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