def test_input_checking_vartype(self):
"""Check that exceptions get thrown for broken inputs"""
# this biases values are themselves not important, so just choose them randomly
linear = {v: random.uniform(-2, 2) for v in range(10)}
quadratic = {(u, v): random.uniform(-1, 1)
for (u, v) in itertools.combinations(linear, 2)}
offset = random.random()
with self.assertRaises(TypeError):
pm.BinaryQuadraticModel(linear, quadratic, offset, 147)
with self.assertRaises(TypeError):
pm.BinaryQuadraticModel(linear, quadratic, offset,
'my made up type')
self.assertEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset,
pm.BINARY).vartype, pm.BINARY)
self.assertEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset,
{-1, 1}).vartype, pm.SPIN)
self.assertEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset,
'BINARY').vartype, pm.BINARY)
def test_not_equal(self):
# two equal models
model0 = pm.BinaryQuadraticModel({
0: 0,
1: 0,
2: 0,
3: 0
}, {
(1, 2): -1,
(0, 1): -1,
(2, 3): -1,
(0, 2): -1
}, 0.0, pm.Vartype.SPIN)
model1 = pm.BinaryQuadraticModel({
0: 0,
1: 0,
2: 0,
3: 0
}, {
(0, 1): -1,
(1, 2): -1,
(2, 3): -1,
(0, 2): -1
}, 0.0, pm.Vartype.SPIN)
self.assertFalse(model0 != model1)
self.assertTrue(model0 == model1)
def test_bad_energy_range(self):
graph = nx.path_graph(3)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
linear = {v: -3 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
with self.assertRaises(ValueError):
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
linear = {v: 0 for v in graph}
quadratic = {edge: 5 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
with self.assertRaises(ValueError):
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
def test_relabel_forwards_and_backwards(self):
graph = nx.path_graph(4)
graph.add_edge(0, 2)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
# make another one
graph = nx.path_graph(4)
graph.add_edge(0, 2)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
original_widget = pm.PenaltyModel.from_specification(
spec, model, 2., -2)
new_label_sets = [(10, 1), ('a', 'b'), (1, 'b'), ('1', '2', '3', '4'),
('a', 'b', 'c', 'd')]
new_label_sets.extend(itertools.permutations(graph))
for new in new_label_sets:
mapping = dict(enumerate(new))
inv_mapping = {u: v for v, u in mapping.items()}
# apply then invert with copy=False
widget.relabel_variables(mapping, copy=False)
widget.relabel_variables(inv_mapping, copy=False)
self.assertEqual(widget, original_widget)
# apply then invert with copy=True
copy_widget = widget.relabel_variables(mapping, copy=True)
inv_copy = copy_widget.relabel_variables(inv_mapping, copy=True)
self.assertEqual(inv_copy, original_widget)
def test_construction(self):
# build a specification
graph = nx.complete_graph(10)
decision_variables = (0, 4, 5)
feasible_configurations = {(-1, -1, -1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
# build a model
model = pm.BinaryQuadraticModel({v: 0
for v in graph},
{edge: 0
for edge in graph.edges},
0.0,
vartype=pm.Vartype.SPIN)
# build a PenaltyModel explicitly
pm0 = pm.PenaltyModel(graph, decision_variables,
feasible_configurations, pm.SPIN, model, .1, 0)
# build from spec
pm1 = pm.PenaltyModel.from_specification(spec, model, .1, 0)
# should result in equality
self.assertEqual(pm0, pm1)
def test_copy(self):
linear = {0: .5, 1: 1.3}
quadratic = {(0, 1): -.435}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
new_model = model.copy()
# everything should have a new id
self.assertNotEqual(id(model.linear), id(new_model.linear))
self.assertNotEqual(id(model.quadratic), id(new_model.quadratic))
self.assertNotEqual(id(model.adj), id(new_model.adj))
for v in model.linear:
self.assertNotEqual(id(model.adj[v]), id(new_model.adj[v]))
# values should all be equal
self.assertEqual(model.linear, new_model.linear)
self.assertEqual(model.quadratic, new_model.quadratic)
self.assertEqual(model.adj, new_model.adj)
for v in model.linear:
self.assertEqual(model.adj[v], new_model.adj[v])
self.assertEqual(model, new_model)
def test_penalty_model_insert_retrieve(self):
conn = self.clean_connection
graph = nx.path_graph(3)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph, decision_variables,
feasible_configurations, pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
with conn as cur:
pmc.insert_penalty_model(cur, widget)
with conn as cur:
pms = list(pmc.iter_penalty_model_from_specification(cur, spec))
self.assertEqual(len(pms), 1)
widget_, = pms
self.assertEqual(widget_, widget)
def test__eq__quadratic_ordering(self):
linear = {v: random.uniform(-2, 2) for v in range(11)}
quadratic = {(u, v): random.uniform(-1, 1)
for (u, v) in itertools.combinations(linear, 2)}
offset = random.random()
vartype = pm.SPIN
model0 = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
reversed_quadratic = {(v, u): bias
for (u, v), bias in quadratic.items()}
model1 = pm.BinaryQuadraticModel(linear, reversed_quadratic, offset,
vartype)
self.assertEqual(model1, model0)
def test_adj_construction_partial_quadratic(self):
"""bug was detected, test shows the exploration of causes and confirms that it was fixed"""
linear = {
0: 2.0,
1: 0.0,
2: 0.0,
3: 2.0,
4: 0.0,
5: 0.0,
6: 0.0,
7: 0.0
}
quadratic = {(0, 3): -4.0}
model = pm.BinaryQuadraticModel(linear, quadratic, -1.0,
pm.Vartype.BINARY)
# test that the model adj was created the way we expected
for v in linear:
self.assertIn(v, model.adj)
for (u, v), bias in quadratic.items():
self.assertIn(u, model.adj)
self.assertIn(v, model.adj[u])
self.assertEqual(model.adj[u][v], bias)
v, u = u, v
self.assertIn(u, model.adj)
self.assertIn(v, model.adj[u])
self.assertEqual(model.adj[u][v], bias)
for u in model.adj:
for v in model.adj[u]:
self.assertTrue((u, v) in quadratic or (v, u) in quadratic)
def test_construction_typical_binary(self):
linear = {0: 1, 1: -1, 2: .5}
quadratic = {(0, 1): .5, (1, 2): 1.5}
offset = 1.4
vartype = pm.BINARY
m = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
self.assertEqual(linear, m.linear)
self.assertEqual(quadratic, m.quadratic)
self.assertEqual(offset, m.offset)
for (u, v), bias in quadratic.items():
self.assertIn(u, m.adj)
self.assertIn(v, m.adj[u])
self.assertEqual(m.adj[u][v], bias)
v, u = u, v
self.assertIn(u, m.adj)
self.assertIn(v, m.adj[u])
self.assertEqual(m.adj[u][v], bias)
for u in m.adj:
for v in m.adj[u]:
self.assertTrue((u, v) in quadratic or (v, u) in quadratic)
def test__eq__(self):
linear = {v: random.uniform(-2, 2) for v in range(11)}
quadratic = {(u, v): random.uniform(-1, 1)
for (u, v) in itertools.combinations(linear, 2)}
offset = random.random()
vartype = pm.SPIN
self.assertEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset, vartype),
pm.BinaryQuadraticModel(linear, quadratic, offset, vartype))
# mismatched type
self.assertNotEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset, vartype), -1)
self.assertNotEqual(pm.BinaryQuadraticModel({}, {}, 0.0, pm.SPIN),
pm.BinaryQuadraticModel({}, {}, 0.0, pm.BINARY))
def test_relabel_typical(self):
linear = {0: .5, 1: 1.3}
quadratic = {(0, 1): -.435}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
mapping = {0: 'a', 1: 'b'}
newmodel = model.relabel_variables(mapping)
# check that new model is the same as old model
linear = {'a': .5, 'b': 1.3}
quadratic = {('a', 'b'): -.435}
offset = 1.2
vartype = pm.SPIN
testmodel = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
self.assertEqual(newmodel, testmodel)
def test_change_vartype(self):
linear = {0: 1, 1: -1, 2: .5}
quadratic = {(0, 1): .5, (1, 2): 1.5}
offset = 1.4
vartype = pm.BINARY
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
# should not change
new_model = model.change_vartype(pm.BINARY)
self.assertEqual(model, new_model)
self.assertNotEqual(id(model), id(new_model))
# change vartype
new_model = model.change_vartype(pm.SPIN)
# check all of the energies
for spins in itertools.product((-1, 1), repeat=len(linear)):
spin_sample = {v: spins[v] for v in linear}
binary_sample = {v: (spins[v] + 1) // 2 for v in linear}
self.assertAlmostEqual(model.energy(binary_sample),
new_model.energy(spin_sample))
linear = {0: 1, 1: -1, 2: .5}
quadratic = {(0, 1): .5, (1, 2): 1.5}
offset = -1.4
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
# should not change
new_model = model.change_vartype(pm.SPIN)
self.assertEqual(model, new_model)
self.assertNotEqual(id(model), id(new_model))
# change vartype
new_model = model.change_vartype(pm.BINARY)
# check all of the energies
for spins in itertools.product((-1, 1), repeat=len(linear)):
spin_sample = {v: spins[v] for v in linear}
binary_sample = {v: (spins[v] + 1) // 2 for v in linear}
self.assertAlmostEqual(model.energy(spin_sample),
new_model.energy(binary_sample))
def test_relabel(self):
graph = nx.path_graph(3)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
# now set up the same widget with 0 relabelled to 'a'
graph = nx.path_graph(3)
graph = nx.relabel_nodes(graph, {0: 'a'})
decision_variables = ('a', 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
test_widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
# without copy
new_widget = widget.relabel_variables({0: 'a'}, copy=True)
self.assertEqual(test_widget, new_widget)
self.assertEqual(new_widget.decision_variables, ('a', 2))
widget.relabel_variables({0: 'a'}, copy=False)
self.assertEqual(widget, test_widget)
self.assertEqual(widget.decision_variables, ('a', 2))
def test_input_checking_quadratic(self):
linear = {v: random.uniform(-2, 2) for v in range(11)}
quadratic = {(u, v): random.uniform(-1, 1)
for (u, v) in itertools.combinations(linear, 2)}
offset = random.random()
vartype = pm.SPIN
self.assertEqual(
pm.BinaryQuadraticModel(linear, quadratic, offset,
pm.BINARY).quadratic, quadratic)
# quadratic should be a dict
with self.assertRaises(TypeError):
pm.BinaryQuadraticModel(linear, [], offset, pm.BINARY)
# unknown varialbe (vars must be in linear)
with self.assertRaises(ValueError):
pm.BinaryQuadraticModel(linear, {('a', 1): .5}, offset, pm.BINARY)
# not 2-tuple
with self.assertRaises(ValueError):
pm.BinaryQuadraticModel(linear, {'edge': .5}, offset, pm.BINARY)
# not upper triangular
with self.assertRaises(ValueError):
pm.BinaryQuadraticModel(linear, {
(0, 1): .5,
(1, 0): -.5
}, offset, pm.BINARY)
# no self-loops
with self.assertRaises(ValueError):
pm.BinaryQuadraticModel(linear, {(0, 0): .5}, offset, pm.BINARY)
def test_relabel_typical_inplace(self):
linear = {0: .5, 1: 1.3}
quadratic = {(0, 1): -.435}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
mapping = {0: 'a', 1: 'b'}
newmodel = model.relabel_variables(mapping, copy=False)
self.assertEqual(id(model), id(newmodel))
self.assertEqual(id(model.linear), id(newmodel.linear))
self.assertEqual(id(model.quadratic), id(newmodel.quadratic))
# check that model is the same as old model
linear = {'a': .5, 'b': 1.3}
quadratic = {('a', 'b'): -.435}
offset = 1.2
vartype = pm.SPIN
testmodel = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
self.assertEqual(model, testmodel)
self.assertEqual(model.adj, testmodel.adj)
def test__repr__(self):
"""check that repr works correctly."""
linear = {0: 1, 1: -1, 2: .5}
quadratic = {(0, 1): .5, (1, 2): 1.5}
offset = 1.4
m = pm.BinaryQuadraticModel(linear, quadratic, offset, pm.SPIN)
# should recreate the model
from penaltymodel import BinaryQuadraticModel, Vartype
m2 = eval(m.__repr__())
self.assertEqual(m, m2)
def test_as_qubo_binary_to_qubo(self):
"""Binary model's as_qubo method"""
linear = {0: 0, 1: 0}
quadratic = {(0, 1): 1}
offset = 0.0
vartype = pm.BINARY
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
Q, off = model.as_qubo()
self.assertEqual(off, offset)
self.assertEqual({(0, 0): 0, (1, 1): 0, (0, 1): 1}, Q)
def test_as_ising_spin_to_ising(self):
linear = {0: 7.1, 1: 103}
quadratic = {(0, 1): .97}
offset = 0.3
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
h, J, off = model.as_ising()
self.assertEqual(off, offset)
self.assertEqual(linear, h)
self.assertEqual(quadratic, J)
def test_retrieval(self):
# put some stuff in the database
spec = pm.Specification(nx.path_graph(2), (0, 1), {(-1, -1), (1, 1)}, vartype=pm.SPIN)
model = pm.BinaryQuadraticModel({0: 0, 1: 0}, {(0, 1): -1}, 0.0, vartype=pm.SPIN)
widget = pm.PenaltyModel.from_specification(spec, model, 2, -1)
for cache in pm.iter_caches():
cache(widget)
# now try to get it back
new_widget = pm.get_penalty_model(spec)
self.assertEqual(widget, new_widget)
def test_relabel_with_identity(self):
linear = {v: .1 * v for v in range(-5, 4)}
quadratic = {(u, v): .1 * u * v
for u, v in itertools.combinations(linear, 2)}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
old_model = model.copy()
identity_mapping = {v: v for v in linear}
model.relabel_variables(identity_mapping, copy=False)
# should have stayed the same
self.assertEqual(old_model, model)
self.assertEqual(old_model.adj, model.adj)
def test_insert_retrieve(self):
dbfile = self.database
linear = {'1': 0.0, '0': -0.5, '3': 1.0, '2': -0.5}
quadratic = {
('0', '3'): -1.0,
('1', '2'): 1.0,
('0', '2'): 0.5,
('1', '3'): 1.0
}
offset = 0.0
model = pm.BinaryQuadraticModel(linear,
quadratic,
offset,
vartype=pm.SPIN)
graph = nx.Graph()
graph.add_edges_from(quadratic)
decision_variables = ('0', '2', '3')
feasible_configurations = ((-1, -1, -1), (-1, 1, -1), (1, -1, -1),
(1, 1, 1))
spec = pm.Specification(graph, decision_variables,
feasible_configurations, pm.SPIN)
classical_gap = 2
ground = -2.5
pmodel = pm.PenaltyModel.from_specification(spec, model, classical_gap,
ground)
pmc.cache_penalty_model(pmodel, database=dbfile)
# print(spec.feasible_configurations)
# print(spec.decision_variables)
# get it back
ret_pmodel = pmc.get_penalty_model(spec, database=dbfile)
# now get back one with a different decision_variables
spec2 = pm.Specification(graph, ('3', '0', '2'),
feasible_configurations, pm.SPIN)
try:
ret_pmodel = pmc.get_penalty_model(spec2, database=dbfile)
self.assertNotEqual(ret_pmodel, pmodel)
except:
pass
def test_arbitrary_labels_on_k44(self):
dbfile = self.database
graph = nx.Graph()
for i in range(3):
for j in range(3, 6):
graph.add_edge(i, j)
decision_variables = (0, 5)
feasible_configurations = ((0, 0), (1, 1)) # equality
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.BINARY)
linear = {v: 0 for v in graph}
quadratic = {edge: 0 for edge in graph.edges}
if decision_variables in quadratic:
quadratic[decision_variables] = -1
else:
u, v = decision_variables
assert (v, u) in quadratic
quadratic[(v, u)] = -1
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
pmodel = pm.PenaltyModel.from_specification(spec, model, 2, -1)
# now cache the pmodel to make sure there is something to find
for thingy in itertools.permutations(range(6)):
mapping = dict(enumerate(thingy))
pmodel = pmodel.relabel_variables(mapping, copy=True)
pmc.cache_penalty_model(pmodel, database=dbfile)
# now relabel some variables
mapping = {1: '1', 2: '2', 3: '3', 4: '4'}
new_spec = spec.relabel_variables(mapping)
# retrieve from the new_spec
# now try to retrieve it
retreived_pmodel = pmc.get_penalty_model(new_spec, database=dbfile)
def test_partial_relabel_inplace(self):
linear = {v: .1 * v for v in range(-5, 5)}
quadratic = {(u, v): .1 * u * v
for u, v in itertools.combinations(linear, 2)}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
newlinear = linear.copy()
newlinear['a'] = newlinear[0]
newlinear['b'] = newlinear[1]
del newlinear[0]
del newlinear[1]
mapping = {0: 'a', 1: 'b'} # partial mapping
model.relabel_variables(mapping, copy=False)
self.assertEqual(newlinear, model.linear)
def test_to_networkx_graph(self):
graph = nx.barbell_graph(7, 6)
# build a BQM
model = pm.BinaryQuadraticModel({v: -.1
for v in graph},
{edge: -.4
for edge in graph.edges},
1.3,
vartype=pm.SPIN)
# get the graph
BQM = model.to_networkx_graph()
self.assertEqual(set(graph), set(BQM))
for u, v in graph.edges:
self.assertIn(u, BQM[v])
for v, bias in model.linear.items():
self.assertEqual(bias, BQM.nodes[v]['bias'])
def test_binary_specification(self):
dbfile = self.database
# set up a specification and a corresponding penaltymodel
graph = nx.Graph()
for i in 'abcd':
for j in 'efgh':
graph.add_edge(i, j)
decision_variables = ('a', 'e')
feasible_configurations = ((0, 0), (1, 1)) # equality
spec = pm.Specification(graph,
decision_variables,
feasible_configurations,
vartype=pm.BINARY)
linear = {v: 0 for v in graph}
quadratic = {edge: 0 for edge in graph.edges}
if decision_variables in quadratic:
quadratic[decision_variables] = -1
else:
u, v = decision_variables
assert (v, u) in quadratic
quadratic[(v, u)] = -1
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
pmodel = pm.PenaltyModel.from_specification(spec, model, 2, -1)
# now cache the pmodel to make sure there is something to find
pmc.cache_penalty_model(pmodel, database=dbfile)
# now try to retrieve it
retreived_pmodel = pmc.get_penalty_model(spec, database=dbfile)
self.assertIs(retreived_pmodel.model.vartype, pm.BINARY)
# check that the specification is equal to the retreived_pmodel
self.assertTrue(spec.__eq__(retreived_pmodel))
def get_penalty_model(specification):
"""Factory function for penaltymodel_maxgap.
Args:
specification (penaltymodel.Specification): The specification
for the desired penalty model.
Returns:
:class:`penaltymodel.PenaltyModel`: Penalty model with the given specification.
Raises:
:class:`penaltymodel.ImpossiblePenaltyModel`: If the penalty cannot be built.
Parameters:
priority (int): -100
"""
# check that the feasible_configurations are spin
feasible_configurations = specification.feasible_configurations
if specification.vartype is pm.BINARY:
feasible_configurations = {
tuple(2 * v - 1 for v in config): en
for config, en in iteritems(feasible_configurations)
}
# convert ising_quadratic_ranges to the form we expect
ising_quadratic_ranges = specification.ising_quadratic_ranges
quadratic_ranges = {(u, v): ising_quadratic_ranges[u][v]
for u, v in specification.graph.edges}
linear, quadratic, ground, gap = generate_ising(
specification.graph, feasible_configurations,
specification.decision_variables, specification.ising_linear_ranges,
quadratic_ranges, None) # unspecified smt solver
# set of the model with 0.0 offset
model = pm.BinaryQuadraticModel(linear, quadratic, 0.0, pm.SPIN)
return pm.PenaltyModel.from_specification(specification, model, gap,
ground)
def test_as_qubo_spin_to_qubo(self):
"""Spin model's as_qubo method"""
linear = {0: .5, 1: 1.3}
quadratic = {(0, 1): -.435}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
Q, off = model.as_qubo()
for spins in itertools.product((-1, 1), repeat=len(model)):
spin_sample = dict(zip(range(len(spins)), spins))
bin_sample = {v: (s + 1) // 2 for v, s in spin_sample.items()}
# calculate the qubo's energy
energy = off
for (u, v), bias in Q.items():
energy += bin_sample[u] * bin_sample[v] * bias
# and the energy of the model
self.assertAlmostEqual(energy, model.energy(spin_sample))
def test_relabel_with_overlap(self):
linear = {v: .1 * v for v in range(-5, 4)}
quadratic = {(u, v): .1 * u * v
for u, v in itertools.combinations(linear, 2)}
offset = 1.2
vartype = pm.SPIN
model = pm.BinaryQuadraticModel(linear, quadratic, offset, vartype)
partial_overlap_mapping = {
v: -v
for v in linear
} # has variables mapped to other old labels
# construct a test model by using copy
testmodel = model.relabel_variables(partial_overlap_mapping, copy=True)
# now apply in place
model.relabel_variables(partial_overlap_mapping, copy=False)
# should have stayed the same
self.assertEqual(testmodel, model)
self.assertEqual(testmodel.adj, model.adj)
def test_typical(self):
dbfile = self.database
# insert a penalty model
graph = nx.path_graph(3)
decision_variables = (0, 2)
feasible_configurations = {(-1, -1): 0., (+1, +1): 0.}
spec = pm.Specification(graph, decision_variables,
feasible_configurations, pm.SPIN)
linear = {v: 0 for v in graph}
quadratic = {edge: -1 for edge in graph.edges}
model = pm.BinaryQuadraticModel(linear,
quadratic,
0.0,
vartype=pm.SPIN)
widget = pm.PenaltyModel.from_specification(spec, model, 2., -2)
# cache the penaltymodel
pmc.cache_penalty_model(widget, database=dbfile)
# retrieve it
widget_ = pmc.get_penalty_model(spec, database=dbfile)
self.assertEqual(widget_, widget)
