def test_empty(self):
bqm = dimod.AdjVectorBQM('BINARY')
fixed = roof_duality(bqm, strict=True)
self.assertEqual(fixed, {})
fixed = roof_duality(bqm, strict=False)
self.assertEqual(fixed, {})
def test_all_zero(self):
num_vars = 3
bqm = dimod.AdjVectorBQM(num_vars, 'BINARY')
fixed = roof_duality(bqm, strict=True)
self.assertEqual(fixed, {})
fixed = roof_duality(bqm, strict=False)
self.assertEqual(len(fixed), num_vars)
for val in fixed.values():
self.assertEqual(val, 1)
def test_3path(self):
bqm = dimod.BinaryQuadraticModel.from_ising({'a': 10}, {
'ab': -1,
'bc': 1
})
fixed = roof_duality(bqm)
self.assertEqual(fixed, {'a': -1, 'b': -1, 'c': 1})
def test_preprocessing(self):
import dimod
from dwave.preprocessing.lower_bounds import roof_duality
from dwave.preprocessing.composites import ScaleComposite
bqm = dimod.BinaryQuadraticModel.from_ising({'a': 10}, {
'ab': -1,
'bc': 1
})
result = roof_duality(bqm)
self.assertFalse(bqm.variables - result)
sampler = ScaleComposite(dimod.ExactSolver())
result = sampler.sample(bqm, scalar=0.5)
self.assertIn('scalar', result.info)
def sample(self, bqm, **parameters):
"""Sample from the provided binary quadratic model.
Args:
bqm (:class:`dimod.BinaryQuadraticModel`):
Binary quadratic model to be sampled from.
fixed_variables (dict, optional, default=None):
A dictionary of variable assignments used when ``self.algorithm``
is 'explicit'.
strict (bool, optional, default=True):
Only used if ``self.algorithm`` is 'roof_duality'. If True, only
fixes variables for which assignments are true for all minimizing
points (strong persistency). If False, also fixes variables for
which the assignments are true for some but not all minimizing
points (weak persistency).
**parameters:
Parameters for the sampling method, specified by the child sampler.
Returns:
:class:`dimod.SampleSet`
"""
if self.algorithm == 'explicit':
fixed_variables = parameters.pop('fixed_variables', None)
if fixed_variables is None:
msg = (
"No fixed_variables passed in when algorithm is 'explicit'. "
"Passing problem to child sampler without fixing.")
warnings.warn(msg)
return self.child.sample(bqm, **parameters)
elif self.algorithm == 'roof_duality':
fixed_variables = roof_duality(bqm,
strict=parameters.pop(
'strict', True))
# make sure that we're shapeable and that we have a BQM we can mutate
bqm_copy = as_bqm(bqm, cls=[AdjVectorBQM, AdjDictBQM], copy=True)
bqm_copy.fix_variables(fixed_variables)
sampleset = self.child.sample(bqm_copy, **parameters)
def _hook(sampleset):
# make RoofDualityComposite non-blocking
if sampleset.variables:
if len(sampleset):
return append_variables(sampleset, fixed_variables)
else:
return sampleset.from_samples_bqm((np.empty(
(0, len(bqm))), bqm.variables),
bqm=bqm)
# there are only fixed variables, make sure that the correct number
# of samples are returned
samples = [fixed_variables] * max(len(sampleset), 1)
return sampleset.from_samples_bqm(samples, bqm=bqm)
return SampleSet.from_future(sampleset, _hook)