def test_tile_around_edge_defects_pegasus(self):
pegasus_shape = [5]
# P5 structured sampler with one missing external edge that does not p
# prevent tesselation of 2x2 blocks (12 tiles, equivalent to full yield)
broken_edges_nice_coordinates = [(0, 1, 0, 0, 0), (0, 2, 0, 0, 0)]
broken_edges = [
tuple(
dnx.pegasus_coordinates(pegasus_shape[0]).nice_to_linear(coord)
for coord in broken_edges_nice_coordinates)
]
mock_sampler = MockDWaveSampler(topology_type='pegasus',
topology_shape=pegasus_shape,
broken_edges=broken_edges)
sampler = TilingComposite(mock_sampler, 2, 2, 4)
self.assertTrue(len(sampler.embeddings) == 12)
# P5 structured sampler with one missing internal edge that prevents
# tesselation of 2x2 blocks (otherwise 12 tiles, with edge defect 11)
broken_edge_nice_coordinates = [(0, 0, 0, 0, 0), (0, 0, 0, 1, 0)]
broken_edges = [
tuple(
dnx.pegasus_coordinates(pegasus_shape[0]).nice_to_linear(coord)
for coord in broken_edge_nice_coordinates)
]
mock_sampler = MockDWaveSampler(topology_type='pegasus',
topology_shape=pegasus_shape,
broken_edges=broken_edges)
sampler = TilingComposite(mock_sampler, 2, 2, 4)
self.assertTrue(len(sampler.embeddings) == 11)
def test_smoke(self):
child_sampler = MockDWaveSampler()
sampler = VirtualGraphComposite(child_sampler, {'a': [0]},
flux_bias_num_reads=1)
# depending on how recenlty flux bias data was gathered, this may be true
child_sampler.flux_biases_flag = False
if sampler.flux_biases:
sampler.sample_ising({'a': -1}, {})
self.assertTrue(
child_sampler.flux_biases_flag
) # true when some have been provided to sample_ising
def test_pegasus_multi_cell(self):
#Test case of 2x3 cell embedding over defect free
mock_sampler = MockDWaveSampler(
topology_type='pegasus',
topology_shape=[8]) # P8 structured sampler
self.assertTrue('topology' in mock_sampler.properties
and 'type' in mock_sampler.properties['topology'])
self.assertTrue(
mock_sampler.properties['topology']['type'] == 'pegasus'
and 'shape' in mock_sampler.properties['topology'])
sampler = TilingComposite(mock_sampler, 1, 1)
h = {
node: random.uniform(-1, 1)
for node in sampler.structure.nodelist
}
J = {(u, v): random.uniform(-1, 1)
for u, v in sampler.structure.edgelist}
m_sub = 2
n_sub = 3
sampler = TilingComposite(mock_sampler, m_sub, n_sub)
h = {
node: random.uniform(-1, 1)
for node in sampler.structure.nodelist
}
J = {(u, v): random.uniform(-1, 1)
for u, v in sampler.structure.edgelist}
m = n = mock_sampler.properties['topology']['shape'][0] - 1
expected_number_of_cells = (m // m_sub) * (n // 3) * 3
num_reads = 1
response = sampler.sample_ising(h, J, num_reads=num_reads)
self.assertTrue(
sum(response.record.num_occurrences) == expected_number_of_cells *
num_reads)
def test_tile_around_hole(self):
# Create a chimera graph with the following structure:
# OOOX
# OOOO
# OOOO
# OOOO
# where O: complete cell, X: incomplete cell
mock_sampler = MockDWaveSampler(broken_nodes=[8 * 3]) # C4 structured sampler with a node missing
hardware_graph = dnx.chimera_graph(4) # C4
sampler = TilingComposite(mock_sampler, 2, 2, 4)
# Given the above chimera graph, check that the embeddings are as follows:
# 00XX
# 0011
# 2211
# 22XX
# where 0,1,2: belongs to correspoding embedding, X: not used in any embedding
self.assertSetEqual({v for s in sampler.embeddings[0].values() for v in s},
{linear_index for linear_index, (i, j, u, k)
in hardware_graph.nodes(data='chimera_index')
if i in (0, 1) and j in (0, 1)})
self.assertSetEqual({v for s in sampler.embeddings[1].values() for v in s},
{linear_index for linear_index, (i, j, u, k)
in hardware_graph.nodes(data='chimera_index')
if i in (1, 2) and j in (2, 3)})
self.assertSetEqual({v for s in sampler.embeddings[2].values() for v in s},
{linear_index for linear_index, (i, j, u, k)
in hardware_graph.nodes(data='chimera_index')
if i in (2, 3) and j in (0, 1)})
def test_max_cut(self):
sampler = EmbeddingComposite(MockDWaveSampler())
m = 2
n = 2
t = 2
hoff = 2 * t
voff = n * hoff
mi = m * voff
ni = n * hoff
edges = []
# tile edges
edges.extend((k0, k1) for i in range(0, ni, hoff)
for j in range(i, mi, voff) for k0 in range(j, j + t)
for k1 in range(j + t, j + 2 * t))
# horizontal edges
edges.extend((k, k + hoff) for i in range(t, 2 * t)
for j in range(i, ni - hoff, hoff)
for k in range(j, mi, voff))
# vertical edges
edges.extend((k, k + voff) for i in range(t)
for j in range(i, ni, hoff)
for k in range(j, mi - voff, voff))
J = {edge: 1 for edge in edges}
h = {v: 0 for v in set().union(*J)}
response = sampler.sample_ising(h, J)
def test_sample_instantiation(self):
# Check that graph related values have not been instantiated
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
self.assertIsNone(sampler.embedding)
self.assertIsNone(sampler.nodelist)
self.assertIsNone(sampler.edgelist)
self.assertIsNone(sampler.adjacency)
# Set up an and_gate BQM and sample
Q = {
('a', 'a'): 0.0,
('c', 'c'): 6.0,
('b', 'b'): 0.0,
('b', 'a'): 2.0,
('c', 'a'): -4.0,
('c', 'b'): -4.0
}
sampler.sample_qubo(Q)
# Check that values have been populated
self.assertIsNotNone(sampler.embedding)
self.assertEqual(sampler.nodelist, ['a', 'b', 'c'])
self.assertEqual(sampler.edgelist, [('a', 'b'), ('a', 'c'),
('b', 'c')])
self.assertEqual(sampler.adjacency, {
'a': {'b', 'c'},
'b': {'a', 'c'},
'c': {'a', 'b'}
})
def test_tile_around_node_defects_pegasus(self):
pegasus_shape = [5]
# Create a pegasus P5 structured solver subject to node defects with the
# following (nice-coordinate) 3x4x4 cell-level structure:
# OOOX OOOO OOOO
# OOOO OOOO OOOO
# OOOO OOOO OOOO
# OOOO OOOO OOOX
# where O: complete cell, X: incomplete cell
broken_node_nice_coordinates = [(0, 0, 3, 0, 1), (2, 3, 3, 1, 3)]
broken_node_linear_coordinates = [
dnx.pegasus_coordinates(pegasus_shape[0]).nice_to_linear(coord)
for coord in broken_node_nice_coordinates
]
mock_sampler = MockDWaveSampler(
topology_type='pegasus',
topology_shape=pegasus_shape,
broken_nodes=broken_node_linear_coordinates)
# Tile with 2x2 cells:
sampler = TilingComposite(mock_sampler, 2, 2, 4)
# Given the above pegasus graph, check that the embeddings are as
# follows:
# 00XX 3344 7788
# 0011 3344 7788
# 2211 5566 99XX
# 22XX 5566 99XX
# Check correct number of embeddings and size of each is sufficient,
# given chimera test checks detailed position:
self.assertTrue(len(sampler.embeddings) == 10)
self.assertFalse(any([len(emb) != 32 for emb in sampler.embeddings]))
def test_pegasus_topology(self):
grid_parameter = 4
sampler = MockDWaveSampler(topology_type='pegasus',
topology_shape=[grid_parameter])
# P4 fabric only has 264 nodes
self.assertTrue(len(sampler.nodelist) == 264)
dit.assert_sampler_api(sampler)
dit.assert_structured_api(sampler)
def test_ising_sample(self):
h = {'a': 1, 'b': -2}
J = {('a', 'b'): -3}
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
response = sampler.sample_ising(h, J)
# Check that at least one response was found
self.assertGreaterEqual(len(response), 1)
def test_instantiation_triangle(self):
embedding = {'a': [0, 4], 'b': [1, 5], 'c': [2, 6]}
sampler = FixedEmbeddingComposite(MockDWaveSampler(), embedding)
self.assertEqual(embedding, sampler.embedding)
dtest.assert_sampler_api(sampler) # checks adj consistent with nodelist/edgelist
self.assertEqual(sampler.nodelist, ['a', 'b', 'c'])
self.assertEqual(sampler.edgelist, [('a', 'b'), ('a', 'c'), ('b', 'c')])
def test_instantiation_empty_adjacency(self):
sampler = FixedEmbeddingComposite(MockDWaveSampler(), source_adjacency={})
dtest.assert_sampler_api(sampler) # checks for attributes needed in a sampler
self.assertEqual(sampler.edgelist, [])
self.assertTrue(hasattr(sampler, 'embedding'))
self.assertIn('embedding', sampler.properties)
def test_instantiation_empty_embedding(self):
sampler = FixedEmbeddingComposite(MockDWaveSampler(), {})
dtest.assert_sampler_api(sampler) # checks adj consistent with nodelist/edgelist
self.assertEqual(sampler.edgelist, [])
self.assertTrue(hasattr(sampler, 'embedding'))
self.assertIn('embedding', sampler.properties)
def test_sample_ising(self):
mock_sampler = MockDWaveSampler() # C4 structured sampler
sampler = TilingComposite(mock_sampler, 2, 2)
h = {node: random.uniform(-1, 1) for node in sampler.structure.nodelist}
J = {(u, v): random.uniform(-1, 1) for u, v in sampler.structure.edgelist}
response = sampler.sample_ising(h, J)
def test_basic_operation(self):
bqm = dimod.BinaryQuadraticModel({}, {
'ab': 1,
'bc': 1,
'ca': 1
}, 0, dimod.SPIN)
sampleset = KerberosSampler().sample(bqm,
qpu_sampler=MockDWaveSampler(),
max_subproblem_size=1)
def test_singleton_variables(self):
sampler = EmbeddingComposite(MockDWaveSampler())
h = {0: -1., 4: 2}
J = {}
response = sampler.sample_ising(h, J)
# nothing failed and we got at least one response back
self.assertGreaterEqual(len(response), 1)
def test_sample_bqm_triangle(self):
sampler = FixedEmbeddingComposite(MockDWaveSampler(), {
'a': [0, 4],
'b': [1, 5],
'c': [2, 6]
})
resp = sampler.sample_ising({'a': 1, 'b': 1, 'c': 0}, {})
self.assertEqual(set(resp.variables), {'a', 'b', 'c'})
def test_adjacency(self):
square_adj = {1: [2, 3], 2: [1, 4], 3: [1, 4], 4: [2, 3]}
sampler = FixedEmbeddingComposite(MockDWaveSampler(), source_adjacency=square_adj)
self.assertTrue(hasattr(sampler, 'adjacency'))
self.assertTrue(hasattr(sampler, 'embedding'))
self.assertIn('embedding', sampler.properties)
self.assertEqual(sampler.nodelist, [1, 2, 3, 4])
self.assertEqual(sampler.edgelist, [(1, 2), (1, 3), (2, 4), (3, 4)])
def test_deprecation_raise(self):
# Temporarily mutate warnings filter
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always") # Cause all warnings to always be triggered.
LazyEmbeddingComposite(MockDWaveSampler()) # Trigger warning
# Verify deprecation warning
assert len(w) == 1
assert issubclass(w[-1].category, DeprecationWarning)
assert "renamed" in str(w[-1].message)
def test_structured_child_sampler(self):
q = QPUSubproblemAutoEmbeddingSampler(qpu_sampler=MockDWaveSampler())
# test sampler is converted to unstructured
self.assertFalse(isinstance(q.sampler, dimod.Structured))
# test sampling works
bqm = dimod.BinaryQuadraticModel({'a': 1}, {}, 0, 'SPIN')
init = State.from_subsample({'a': 1}, bqm)
res = q.run(init).result()
self.assertEqual(res.subsamples.first.energy, -1)
def test_with_embedding_and_adjacency(self):
self.assertRaises(
TypeError, lambda: FixedEmbeddingComposite(MockDWaveSampler(), {
'a': [0, 4],
'b': [1],
'c': [5]
}, {
'a': ['b', 'c'],
'b': ['a', 'c'],
'c': ['a', 'b']
}))
def test_chimera_topology(self):
grid_parameter = 5
tile_parameter = 2
sampler = MockDWaveSampler(
topology_type='chimera',
topology_shape=[grid_parameter, grid_parameter, tile_parameter])
# C5 (shore 2) fabric only has 200 nodes
self.assertTrue(
len(sampler.nodelist) == grid_parameter * grid_parameter *
tile_parameter * 2)
dit.assert_sampler_api(sampler)
dit.assert_structured_api(sampler)
def test_problem_labelling(self):
sampler = self.embedding_composite_class(MockDWaveSampler())
self.assertIn('label', sampler.parameters)
ss = sampler.sample_ising({}, {(0, 1): -1})
self.assertNotIn('problem_label', ss.info)
label = 'problem label'
ss = sampler.sample_ising({}, {(0, 1): -1}, label=label)
self.assertIn('problem_label', ss.info)
self.assertEqual(ss.info['problem_label'], label)
def test_zephyr_topology(self):
grid_parameter = 3
tile_parameter = 4
sampler = MockDWaveSampler(
topology_type='zephyr',
topology_shape=[grid_parameter, tile_parameter])
# P4 fabric only has 264 nodes
self.assertTrue(
len(sampler.nodelist) == tile_parameter * grid_parameter *
(8 * grid_parameter + 4))
dit.assert_sampler_api(sampler)
dit.assert_structured_api(sampler)
def test_concrete_runnables(self):
# composers
self.assertEqual(self.children(IdentityComposer()), [])
self.assertEqual(self.children(SplatComposer()), [])
# sample of samplers
self.assertEqual(self.children(QPUSubproblemAutoEmbeddingSampler(qpu_sampler=MockDWaveSampler())), [])
self.assertEqual(self.children(SimulatedAnnealingSubproblemSampler()), [])
self.assertEqual(self.children(TabuProblemSampler()), [])
# sample of decomposers
self.assertEqual(self.children(IdentityDecomposer()), [])
self.assertEqual(self.children(EnergyImpactDecomposer(size=1)), [])
self.assertEqual(self.children(RandomSubproblemDecomposer(size=1)), [])
def test_chain_break_method_customization(self):
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
with mock.patch('dwave.system.composites.embedding.unembed_sampleset'
) as mock_unembed:
sampler.sample_ising({'a': 1}, {},
chain_break_method=chain_breaks.discard)
# assert chain_break_method propagated to unembed_sampleset
__, kwargs = mock_unembed.call_args
self.assertEqual(kwargs['chain_break_method'],
chain_breaks.discard)
def test_sparse_qubo(self):
# There is no relationship between nodes 2 and 3
Q = {(1, 1): 1, (2, 2): 2, (3, 3): 3, (1, 2): 4, (1, 3): 6}
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
response = sampler.sample_qubo(Q)
# Check embedding
self.assertIsNotNone(sampler.embedding)
self.assertEqual(sampler.nodelist, [1, 2, 3])
self.assertEqual(sampler.edgelist, [(1, 2), (1, 3)])
# Check that at least one response was found
self.assertGreaterEqual(len(response), 1)
def test_qubo(self):
Q = {(1, 1): 1, (2, 2): 2, (3, 3): 3, (1, 2): 4, (2, 3): 5, (1, 3): 6}
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
response = sampler.sample_qubo(Q)
# Check embedding
self.assertIsNotNone(sampler.embedding)
self.assertEqual(sampler.nodelist, [1, 2, 3])
self.assertEqual(sampler.edgelist, [(1, 2), (1, 3), (2, 3)])
self.assertEqual(sampler.adjacency, {1: {2, 3}, 2: {1, 3}, 3: {1, 2}})
# Check that at least one response was found
self.assertGreaterEqual(len(response), 1)
def test_too_many_nodes(self):
mock_sampler = MockDWaveSampler() # C4 structured sampler
sampler = TilingComposite(mock_sampler, 2, 2)
h = {0: -1, 1: 1}
J = {}
response = sampler.sample_ising(h, J)
__, num_columns = response.record.sample.shape
self.assertEqual(num_columns, 2)
def test_ising(self):
h = {0: 11, 5: 2}
J = {(0, 5): -8}
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
response = sampler.sample_ising(h, J)
# Check embedding
self.assertIsNotNone(sampler.embedding)
self.assertEqual(sampler.nodelist, [0, 5])
self.assertEqual(sampler.edgelist, [(0, 5)])
self.assertEqual(sampler.adjacency, {0: {5}, 5: {0}})
# Check that at least one response was found
self.assertGreaterEqual(len(response), 1)
def test_chain_break_method_customization(self):
sampler = LazyFixedEmbeddingComposite(MockDWaveSampler())
def mock_unembed(*args, **kwargs):
self.assertIn('chain_break_method', kwargs)
self.assertEqual(kwargs['chain_break_method'], chain_breaks.discard)
mock_unembed.call_count += 1
return dwave.embedding.unembed_sampleset(*args, **kwargs)
mock_unembed.call_count = 0
with mock.patch('dwave.system.composites.embedding.unembed_sampleset', mock_unembed):
sampler.sample_ising({'a': 1}, {}, chain_break_method=chain_breaks.discard).resolve()
self.assertEqual(mock_unembed.call_count, 1)
