def get_solver(solver_type: str, solver_name: str, token):
filters = {}
if solver_type.endswith("QPU") and solver_name in QPU_SOLVER_NAME_LIST:
filters[
"topology__type"] = "pegasus" if solver_name == "ADVANTAGE" else "chimera"
filters[
"name__contains"] = "Advantage_system" if solver_name == "ADVANTAGE" else "DW_2000Q"
if solver_type.endswith(
"HYBRID") and solver_name in HYBRID_SOLVER_NAME_LIST:
filters[
"name__contains"] = "version2" if solver_name == "HYBRID_V2" else "v1"
if solver_type == "SA":
solver = neal.SimulatedAnnealingSampler()
elif solver_type == "QPU":
solver = DWaveSampler(client="qpu", solver=filters, token=token)
solver = EmbeddingComposite(solver)
elif solver_type == "HYBRID":
solver = LeapHybridSampler(solver=filters, token=token)
elif solver_type == "FIXED_QPU":
solver = DWaveSampler(client="qpu", solver=filters, token=token)
solver = LazyFixedEmbeddingComposite(solver)
elif solver_type == "CLIQUE_FIXED_QPU":
solver = DWaveCliqueSampler(client="qpu", solver=filters, token=token)
else:
raise NotImplementedError(
"Solver {} is not implemented".format(solver_type))
return solver
def test_sample_bqm(self, mock_client):
mock_client.from_config.side_effect = MockClient
bqm = dimod.BinaryQuadraticModel({'a': -1, 'b': 1, 'c': 1},
{'ab': -0.8, 'ac': -0.7, 'bc': -1}, 0, dimod.SPIN)
sampler = LeapHybridSampler()
response = sampler.sample(bqm)
rows, cols = response.record.sample.shape
self.assertEqual(cols, 3)
self.assertFalse(np.any(response.record.sample == 0))
self.assertIs(response.vartype, dimod.SPIN)
self.assertIn('num_occurrences', response.record.dtype.fields)
def test_sample_ising_variables(self, mock_client):
mock_client.from_config.side_effect = MockClient
sampler = LeapHybridSampler()
response = sampler.sample_ising({0: -1, 1: 1}, {})
rows, cols = response.record.sample.shape
self.assertEqual(cols, 2)
response = sampler.sample_ising({}, {(0, 4): 1})
rows, cols = response.record.sample.shape
self.assertEqual(cols, 2)
self.assertFalse(np.any(response.record.sample == 0))
self.assertIs(response.vartype, dimod.SPIN)
def test_sample_qubo_variables(self, mock_client):
mock_client.from_config.side_effect = MockClient
sampler = LeapHybridSampler()
response = sampler.sample_qubo({(0, 0): -1, (1, 1): 1})
rows, cols = response.record.sample.shape
self.assertEqual(cols, 2)
response = sampler.sample_qubo({(0, 0): -1, (1, 1): 1})
rows, cols = response.record.sample.shape
self.assertEqual(cols, 2)
self.assertTrue(np.all(response.record.sample >= 0))
self.assertIs(response.vartype, dimod.BINARY)
def solve_tsp_hybrid(Q, G):
bqm = BinaryQuadraticModel.from_qubo(Q)
response = LeapHybridSampler().sample(bqm, time_limit=40)
sample = response.first.sample
route = [None] * len(G)
for (city, time), val in sample.items():
if val:
route[time] = city
cost = calculate_cost(nx.to_numpy_array(G), route)
return (route, cost)
def run_annealer_hybrid(theta):
sampler = LeapHybridSampler()
response = sampler.sample_qubo(theta)
response = response.first.sample.values()
return np.atleast_2d(list(response)).T
def test_solver_init(self, mock_client):
mock_client.from_config.side_effect = MockClient
# Default call
mock_client.reset_mock()
LeapHybridSampler()
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=True,
solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
# Non-hybrid client setting
mock_client.reset_mock()
with self.assertRaises(SolverNotFoundError):
LeapHybridSampler(client='qpu')
# Explicitly set category to hybrid
mock_client.reset_mock()
LeapHybridSampler(solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm'
})
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=True,
solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
# Explicitly set category to not hybrid
with self.assertRaises(ValueError):
LeapHybridSampler(solver={'category': 'not hybrid'})
# Set irrelevant paremeters
mock_client.reset_mock()
LeapHybridSampler(solver={'qpu': True})
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=True,
solver={
'qpu': True,
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
mock_client.reset_mock()
LeapHybridSampler(solver={'qpu': True, 'anneal_schedule': False})
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=True,
solver={
'anneal_schedule': False,
'qpu': True,
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
# Named solver: hybrid
mock_client.reset_mock()
LeapHybridSampler(solver="hybrid_solver")
mock_client.from_config.assert_called_once_with(client='hybrid',
connection_close=True,
solver="hybrid_solver")
mock_client.reset_mock()
LeapHybridSampler(connection_close=False, solver="hybrid_solver")
mock_client.from_config.assert_called_once_with(client='hybrid',
connection_close=False,
solver="hybrid_solver")
# Named solver: non-hybrid
with self.assertRaises(ValueError):
LeapHybridSampler(solver="not_hybrid_solver")
# Set connection_close to False
mock_client.reset_mock()
LeapHybridSampler(connection_close=False)
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=False,
solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
mock_client.reset_mock()
LeapHybridSampler(connection_close=False,
solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm'
})
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=False,
solver={
'category': 'hybrid',
'supported_problem_types__contains': 'bqm',
'order_by': '-version'
})
def test_solver_init(self, mock_client):
mock_client.from_config.side_effect = MockClient
# Default call
mock_client.reset_mock()
LeapHybridSampler()
mock_client.from_config.assert_called_once_with(
connection_close=True, solver={'category': 'hybrid'})
# Explicitly set category to hybrid
mock_client.reset_mock()
LeapHybridSampler(solver={'category': 'hybrid'})
mock_client.from_config.assert_called_once_with(
connection_close=True, solver={'category': 'hybrid'})
# Explicitly set category to not hybrid
with self.assertRaises(ValueError):
LeapHybridSampler(solver={'category': 'not hybrid'})
# Set irrelevant paremeters
mock_client.reset_mock()
LeapHybridSampler(solver={'qpu': True})
mock_client.from_config.assert_called_once_with(connection_close=True,
solver={
'qpu': True,
'category':
'hybrid'
})
mock_client.reset_mock()
LeapHybridSampler(solver={'qpu': True, 'anneal_schedule': False})
mock_client.from_config.assert_called_once_with(connection_close=True,
solver={
'anneal_schedule':
False,
'qpu': True,
'category':
'hybrid'
})
# Named solver: hybrid
mock_client.reset_mock()
LeapHybridSampler(solver="hybrid_solver")
mock_client.from_config.assert_called_once_with(connection_close=True,
solver="hybrid_solver")
mock_client.reset_mock()
LeapHybridSampler(connection_close=False, solver="hybrid_solver")
mock_client.from_config.assert_called_once_with(connection_close=False,
solver="hybrid_solver")
# Named solver: non-hybrid
with self.assertRaises(ValueError):
LeapHybridSampler(solver="not_hybrid_solver")
# Set connection_close to False
mock_client.reset_mock()
LeapHybridSampler(connection_close=False)
mock_client.from_config.assert_called_once_with(
connection_close=False, solver={'category': 'hybrid'})
mock_client.reset_mock()
LeapHybridSampler(connection_close=False,
solver={'category': 'hybrid'})
mock_client.from_config.assert_called_once_with(
connection_close=False, solver={'category': 'hybrid'})
config = sigma_is_one_constraints(G.number_of_nodes())
for node in G.nodes():
variables = [str(node) + str(pos) for pos in G.nodes()]
csp.add_constraint(config, variables)
for pos in G.nodes():
variables = [str(node) + str(pos) for node in G.nodes()]
csp.add_constraint(config, variables)
bqm = dwavebinarycsp.stitch(csp, max_graph_size=15)
#%%
sampler = LeapHybridSampler()
response = sampler.sample(bqm)
# %%
from collections import defaultdict
data = create_tsp_data_model(5)
G = nx.from_numpy_matrix(data["distance_matrix_numpy"])
time_window = defaultdict(bool)
i = 0
for node in range(5):
i += 1
for pos in range(5):
if pos < i:
time_window[(4 - node, pos)] = True
def test_solver_init(self, mock_client):
mock_client.from_config.side_effect = MockClient
default_solver = dict(
supported_problem_types__contains='bqm',
order_by='-properties.version')
self.assertEqual(LeapHybridSampler.default_solver, default_solver)
defaults = dict(solver=default_solver)
# Default call
mock_client.reset_mock()
LeapHybridSampler()
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=True,
defaults=defaults)
# Non-hybrid client setting
mock_client.reset_mock()
with self.assertRaises(SolverNotFoundError):
LeapHybridSampler(client='qpu')
# Explicitly set solver def
mock_client.reset_mock()
LeapHybridSampler(solver={'supported_problem_types__contains': 'bqm'})
mock_client.from_config.assert_called_once_with(
client='hybrid',
solver={'supported_problem_types__contains': 'bqm'},
connection_close=True,
defaults=defaults)
# Named solver
solver_name = 'hybrid-solver-name'
mock_client.reset_mock()
LeapHybridSampler(solver=solver_name)
mock_client.from_config.assert_called_once_with(
client='hybrid',
solver=solver_name,
connection_close=True,
defaults=defaults)
# Named solver: non-hybrid
with self.assertRaises(ValueError):
LeapHybridSampler(solver='not_hybrid_solver')
# Set connection_close to False
mock_client.reset_mock()
LeapHybridSampler(connection_close=False)
mock_client.from_config.assert_called_once_with(
client='hybrid',
connection_close=False,
defaults=defaults)
mock_client.reset_mock()
LeapHybridSampler(connection_close=False, solver=solver_name)
mock_client.from_config.assert_called_once_with(
client='hybrid',
solver=solver_name,
connection_close=False,
defaults=defaults)
