def test_vartype_dimod_smoke(self): StructuredSolver.reformat_parameters('SPIN', {}, {}) StructuredSolver.reformat_parameters('BINARY', {}, {}) StructuredSolver.reformat_parameters(dimod.BINARY, {}, {}) StructuredSolver.reformat_parameters(dimod.SPIN, {}, {}) with self.assertRaises(ValueError): StructuredSolver.reformat_parameters("INTEGER", {}, {})
def test_initial_states(self): doc = {'initial_state': {0: 0, 4: 1}} self.assertEqual(StructuredSolver.reformat_parameters('ising', doc, dict(num_qubits=9)), dict(initial_state=[-1, 3, 3, 3, 1, 3, 3, 3, 3])) self.assertEqual(StructuredSolver.reformat_parameters('qubo', doc, dict(num_qubits=9)), dict(initial_state=[0, 3, 3, 3, 1, 3, 3, 3, 3])) if dimod: self.assertEqual(StructuredSolver.reformat_parameters('SPIN', doc, dict(num_qubits=9)), dict(initial_state=[-1, 3, 3, 3, 1, 3, 3, 3, 3])) self.assertEqual(StructuredSolver.reformat_parameters('BINARY', doc, dict(num_qubits=9)), dict(initial_state=[0, 3, 3, 3, 1, 3, 3, 3, 3])) self.assertEqual(doc, {'initial_state': {0: 0, 4: 1}})
def setUp(self): # mock client self.client = Client(endpoint='e', token='t', solver=dict(name__contains='test')) self.client._fetch_solvers = lambda **kw: self.solvers self.client._submit = lambda *pa, **kw: None self.client.upload_problem_encoded = lambda *pa, **kw: Present( result=mock_problem_id) # mock solvers self.structured_solver = StructuredSolver( client=self.client, data={ "properties": { "supported_problem_types": ["qubo", "ising"], "qubits": [0, 1, 2], "couplers": [[0, 1], [0, 2], [1, 2]], "num_qubits": 3, "num_reads_range": [0, 100], "parameters": { "num_reads": "Number of samples to return.", "postprocess": "either 'sampling' or 'optimization'" }, "topology": { "type": "chimera", "shape": [16, 16, 4] }, "category": "qpu", "tags": ["lower_noise"] }, "id": "test-qpu-solver", "description": "A test solver 1", "status": "online" }) self.unstructured_solver = UnstructuredSolver( client=self.client, data={ "properties": { "supported_problem_types": ["bqm"], "parameters": { "num_reads": "Number of samples to return." }, "category": "hybrid", }, "id": "test-unstructured-solver", "description": "A test unstructured solver" }) self.solvers = [self.structured_solver] # we can't use unstructured solvers without dimod installed, # so don't even try testing it if dimod: self.solvers.append(self.unstructured_solver) # reset all event handlers from dwave.cloud.events import _client_event_hooks_registry as reg reg.update({k: [] for k in reg})
def __init__(self, **kwargs): kwargs.setdefault( 'solver', StructuredSolver(client=None, data=qpu_clique_solver_data(5))) kwargs.setdefault( 'problem', generate_const_ising_problem(kwargs['solver'], h=1, j=-1)) kwargs.setdefault('problem_type', 'ising') kwargs.setdefault('answer', self._problem_answer()) super().__init__(**kwargs)
def get_structured_solver(): data = { "properties": { "supported_problem_types": ["qubo", "ising"], "qubits": [0, 1, 2, 3], "couplers": [(0, 1), (1, 2), (2, 3), (3, 0)], "num_qubits": 4, "parameters": {"num_reads": "Number of samples to return."} }, "id": "test-structured-solver", "description": "A test structured solver" } return StructuredSolver(client=None, data=data)
def setUp(self): # mock solvers self.qpu1 = StructuredSolver( client=None, data={ "properties": { "supported_problem_types": ["qubo", "ising"], "qubits": [0, 1, 2], "couplers": [[0, 1], [0, 2], [1, 2]], "num_qubits": 3, "num_reads_range": [0, 100], "parameters": { "num_reads": "Number of samples to return.", "postprocess": "either 'sampling' or 'optimization'" }, "topology": { "type": "chimera", "shape": [16, 16, 4] }, "category": "qpu", "tags": ["lower_noise"] }, "id": "qpu1", "description": "QPU Chimera solver", "status": "online", "avg_load": 0.1 }) self.qpu2 = StructuredSolver( client=None, data={ "properties": { "supported_problem_types": ["qubo", "ising"], "qubits": [0, 1, 2, 3, 4], "couplers": [[0, 1], [0, 2], [1, 2], [2, 3], [3, 4]], "num_qubits": 5, "num_reads_range": [0, 200], "parameters": { "num_reads": "Number of samples to return.", "flux_biases": "Supported ...", "anneal_schedule": "Supported ..." }, "topology": { "type": "pegasus", "shape": [6, 6, 12] }, "category": "qpu", "vfyc": True }, "id": "qpu2", "description": "QPU Pegasus solver", "avg_load": 0.2 }) self.software = StructuredSolver( client=None, data={ "properties": { "supported_problem_types": ["qubo", "ising"], "qubits": [0, 1], "couplers": [[0, 1]], "num_qubits": 7, "num_reads_range": [0, 1000], "parameters": { "num_reads": "Number of samples to return." }, "vfyc": False, "topology": { "type": "chimera", "shape": [4, 4, 4] }, "category": "software", # the following are only present in this solver "some_set": [1, 2], "some_range": [1, 2], "some_string": "x", "tags": ["tag"] }, "id": "sw_solver1", "description": "Software solver", "avg_load": 0.7 }) self.hybrid = UnstructuredSolver(client=None, data={ "properties": { "supported_problem_types": ["bqm"], "maximum_number_of_variables": 10000, "maximum_time_limit_hrs": 24.0, "minimum_time_limit": [[1, 3.0], [1024, 3.0], [4096, 10.0], [10000, 40.0]], "quota_conversion_rate": 20, "parameters": { "time_limit": "" }, "category": "hybrid", }, "id": "hybrid_v1", "description": "Hybrid solver" }) self.qpu_solvers = [self.qpu1, self.qpu2] self.software_solvers = [self.software] self.hybrid_solvers = [self.hybrid] self.structured_solvers = self.qpu_solvers + self.software_solvers self.unstructured_solvers = self.hybrid_solvers self.solvers = self.structured_solvers + self.unstructured_solvers # mock client self.client = Client('endpoint', 'token') self.client._fetch_solvers = lambda **kw: self.solvers
def test_initial_states_sequence(self): doc = {'initial_state': [-1, 3, 3, 3, 1, 3, 3, 3, 3]} self.assertEqual(StructuredSolver.reformat_parameters('ising', doc, dict(num_qubits=9)), dict(initial_state=[-1, 3, 3, 3, 1, 3, 3, 3, 3]))
def test_initial_states_inplace(self): doc = {'initial_state': {0: 0, 4: 1}} StructuredSolver.reformat_parameters('ising', doc, dict(num_qubits=9), inplace=True) self.assertEqual(doc, dict(initial_state=[-1, 3, 3, 3, 1, 3, 3, 3, 3]))
def test_empty(self): self.assertEqual(StructuredSolver.reformat_parameters('ising', {}, {}), {})
def setUpClass(cls): try: cls.solver_mock = StructuredSolver(data=mocks.qpu_pegasus_solver_data(16, problem_timing_data=mocks.qpu_problem_timing_data(qpu='advantage')), client=None) except RuntimeError: raise cls.skipTest(cls, "structured solver mock not available")
def test_vartype_smoke(self): for vt in StructuredSolver._handled_problem_types: StructuredSolver.reformat_parameters(vt, {}, {}) with self.assertRaises(ValueError): StructuredSolver.reformat_parameters('not a type', {}, {})
import copy import networkx as nx from parameterized import parameterized, parameterized_class try: import dimod except ImportError: dimod = None from dwave.cloud.client import Client from dwave.cloud.solver import StructuredSolver from dwave.cloud.testing import mocks try: C16 = StructuredSolver(data=mocks.qpu_chimera_solver_data(16), client=None) P16 = StructuredSolver(data=mocks.qpu_pegasus_solver_data(16), client=None) solvers = [(C16,), (P16,)] except RuntimeError: solvers = [] from tests import config @parameterized_class(("solver", ), solvers) @unittest.skipUnless(dimod, "dimod not installed") class TestCheckProblem(unittest.TestCase): def test_identity(self): # NOTE: cast to list can be removed once we drop support for dimod 0.8.x bqm = dimod.generators.ran_r(1, list(self.solver.edges)) self.assertTrue(self.solver.check_problem(bqm.linear, bqm.quadratic))