def __init__(self, child_sampler, bqm=None, h=None, J=None, offset=0,
scalar=None, bias_range=1, quadratic_range=None,
ignored_variables=None, ignored_interactions=None,
ignore_offset=False, **other_params):
scale_options = dict(scalar=scalar,
bias_range=bias_range,
quadratic_range=quadratic_range,
ignored_variables=ignored_variables,
ignored_interactions=ignored_interactions,
ignore_offset=ignore_offset)
self.child = child_sampler
if bqm is not None:
self.bqm, _ = _scaled_bqm(bqm, **scale_options)
elif h is not None and J is not None:
if max(map(len, J.keys())) == 2:
bqm = BinaryQuadraticModel.from_ising(h, J, offset=offset)
self.bqm, _ = _scaled_bqm(bqm, **scale_options)
else:
h_sc, J_sc, offset_sc = _scaled_hubo(h, J, offset=offset,
**scale_options)
self.h = h_sc
self.J = J_sc
self.offset = offset_sc
def test_sample_bias_range(self):
linear = {'a': -4.0, 'b': -4.0}
quadratic = {('a', 'b'): 3.2}
ignored_variables, ignored_interactions = _check_params(None, None)
bqm = BinaryQuadraticModel.from_ising(linear, quadratic)
comp_parameters = dict(ignored_interactions=ignored_interactions,
ignored_variables=ignored_variables,
bias_range=2.)
sampler = ScaleComposite(
ScalingChecker(ExactSolver(), bqm=bqm, **comp_parameters))
response = sampler.sample(bqm, **comp_parameters)
self.assertAlmostEqual(response.first.energy, -4.8)
def test_info_propagation(self):
bqm = BinaryQuadraticModel.from_ising({}, {})
class MySampler:
@staticmethod
def sample(bqm):
return dimod.SampleSet.from_samples_bqm([],
bqm,
info=dict(a=1))
sampleset = ClipComposite(MySampler).sample(bqm)
self.assertEqual(sampleset.info, {'a': 1})
def test_roof_duality_triangle(self):
bqm = BinaryQuadraticModel.from_ising({}, {
'ab': -1,
'bc': -1,
'ac': -1
})
# two equally good solutions
sampler = FixVariablesComposite(ExactSolver(),
algorithm='roof_duality')
sampleset = sampler.sample(bqm)
self.assertEqual(set(sampleset.variables), set('abc'))
dtest.assert_response_energies(sampleset, bqm)
def test_roof_duality_triangle_not_strict(self):
bqm = BinaryQuadraticModel.from_ising({}, {
'ab': -1,
'bc': -1,
'ac': -1
})
# two equally good solutions, but with strict=False, it will pick one
sampler = FixVariablesComposite(ExactSolver(),
algorithm='roof_duality')
sampleset = sampler.sample(bqm, strict=False)
self.assertEqual(set(sampleset.variables), set('abc'))
self.assertEqual(len(sampleset), 1) # all should be fixed
dtest.assert_response_energies(sampleset, bqm)
def test_sample_ignore_variables(self):
linear = {'a': -4.0, 'b': -4.0}
quadratic = {('a', 'b'): 3.2}
offset = 5
bqm = BinaryQuadraticModel.from_ising(linear, quadratic, offset=offset)
ignored_variables, ignored_interactions = _check_params(
['a'], None)
comp_parameters = dict(ignored_interactions=ignored_interactions,
ignored_variables=ignored_variables,
ignore_offset=True,
scalar=0.5)
sampler = ScaleComposite(ScalingChecker(ExactSolver(), h=linear,
J=quadratic, offset=offset,
**comp_parameters))
response = sampler.sample(bqm, **comp_parameters)
self.assertAlmostEqual(response.first.energy, 0.2)
def test_scaling_bqm(self):
linear = {'a': -4.0, 'b': -4.0}
quadratic = {('a', 'b'): 3.2}
ignored_variables, ignored_interactions = _check_params(None, None)
bqm = BinaryQuadraticModel.from_ising(linear, quadratic, offset=5.0)
scalar = None
quadratic_range = None
ignore_offset = False
bqm_new = _scaled_bqm(bqm, scalar, 2, quadratic_range,
ignored_variables, ignored_interactions,
ignore_offset)
sc = 2.
hsc = {
k: v / sc if k not in ignored_variables else v
for k, v in linear.items()
}
Jsc = {
k: v / sc if k not in ignored_interactions else v
for k, v in quadratic.items()
}
bqm_scaled = BinaryQuadraticModel.from_ising(hsc, Jsc, offset=5.0 / 2.)
self.assertEqual(bqm_scaled, bqm_new)
ignored_variables, ignored_interactions = _check_params(None, None)
bqm = BinaryQuadraticModel.from_ising(linear, quadratic, offset=5.0)
bqm_new = _scaled_bqm(bqm, scalar, 2, quadratic_range,
ignored_variables, ignored_interactions, True)
sc = 2.
hsc = {
k: v / sc if k not in ignored_variables else v
for k, v in linear.items()
}
Jsc = {
k: v / sc if k not in ignored_interactions else v
for k, v in quadratic.items()
}
bqm_scaled = BinaryQuadraticModel.from_ising(hsc, Jsc, offset=5.0)
self.assertEqual(bqm_scaled, bqm_new)
bqm_new = _scaled_bqm(bqm, scalar, 1, (-1, 0.4), ignored_variables,
ignored_interactions, ignore_offset)
sc = 3.2 / 0.4
hsc = {
k: v / sc if k not in ignored_variables else v
for k, v in linear.items()
}
Jsc = {
k: v / sc if k not in ignored_interactions else v
for k, v in quadratic.items()
}
bqm_scaled = BinaryQuadraticModel.from_ising(hsc, Jsc, offset=5.0 / sc)
self.assertEqual(bqm_scaled, bqm_new)
ignored_variables = ['a', 'b']
ignored_interactions = None
ignored_variables, ignored_interactions = _check_params(
ignored_variables, ignored_interactions)
bqm = BinaryQuadraticModel.from_ising(linear, quadratic)
bqm_new = _scaled_bqm(bqm, scalar, (2, 2), quadratic_range,
ignored_variables, ignored_interactions,
ignore_offset)
sc = 3.2 / 2.
hsc = {
k: v / sc if k not in ignored_variables else v
for k, v in linear.items()
}
Jsc = {
k: v / sc if k not in ignored_interactions else v
for k, v in quadratic.items()
}
bqm_scaled = BinaryQuadraticModel.from_ising(hsc, Jsc, offset=0)
self.assertEqual(bqm_scaled, bqm_new)
ignored_variables = None
ignored_interactions = [('a', 'b')]
ignored_variables, ignored_interactions = _check_params(
ignored_variables, ignored_interactions)
bqm = BinaryQuadraticModel.from_ising(linear, quadratic)
bqm_new = _scaled_bqm(bqm, scalar, 1, 0.5, ignored_variables,
ignored_interactions, ignore_offset)
sc = 4.
hsc = {
k: v / sc if k not in ignored_variables else v
for k, v in linear.items()
}
Jsc = {
k: v / sc if k not in ignored_interactions else v
for k, v in quadratic.items()
}
bqm_scaled = BinaryQuadraticModel.from_ising(hsc, Jsc, offset=0)
self.assertEqual(bqm_scaled, bqm_new)
