def test_continuous_variable_decode(self):
""" Test decode func of IntegerToBinaryConverter for continuous variables"""
try:
mdl = Model('test_continuous_varable_decode')
c = mdl.continuous_var(lb=0, ub=10.9, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
result = converter.interpret(result)
self.assertEqual(result.x[0], 10.9)
self.assertListEqual(result.variable_names, ['c', 'x'])
self.assertDictEqual(result.variables_dict, {'c': 10.9, 'x': 0})
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_admm_maximization(self):
"""Tests a simple maximization problem using ADMM optimizer"""
mdl = Model('test')
c = mdl.continuous_var(lb=0, ub=10, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = OptimizationProblem()
op.from_docplex(mdl)
self.assertIsNotNone(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params)
solution: ADMMOptimizerResult = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizerResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([10, 0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(10, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_maximization(self):
"""Tests a simple maximization problem using ADMM optimizer"""
mdl = Model('simple-max')
c = mdl.continuous_var(lb=0, ub=10, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters()
solver = ADMMOptimizer(params=admm_params, continuous_optimizer=CobylaOptimizer())
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([10, 0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(10, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
self.assertEqual(len(solution.samples), 1)
self.assertAlmostEqual(solution.fval, solution.samples[0].fval)
np.testing.assert_almost_equal(solution.x, solution.samples[0].x)
self.assertEqual(solution.status, solution.samples[0].status)
self.assertAlmostEqual(solution.samples[0].probability, 1.0)
def test_admm_maximization(self):
"""Tests a simple maximization problem using ADMM optimizer"""
try:
mdl = Model('simple-max')
c = mdl.continuous_var(lb=0, ub=10, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
# qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([10, 0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(10, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_admm_miskp_eigen(self):
"""ADMM Optimizer Test based on Mixed-Integer Setup Knapsack Problem
using NumPy eigen optimizer"""
miskp = Miskp(*self._get_miskp_problem_params())
op: OptimizationProblem = miskp.create_problem()
self.assertIsNotNone(op)
admm_params = ADMMParameters()
# use numpy exact diagonalization
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params)
solution: ADMMOptimizerResult = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizerResult)
correct_solution = [
0.009127, 0.009127, 0.009127, 0.009127, 0.009127, 0.009127,
0.009127, 0.009127, 0.009127, 0.009127, 0.006151, 0.006151,
0.006151, 0.006151, 0.006151, 0.006151, 0.006151, 0.006151,
0.006151, 0.006151, 0., 0.
]
correct_objective = -1.2113693
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal(correct_solution, solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(correct_objective, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_quad_constraints(self):
"""Simple example to test quadratic constraints."""
mdl = Model('quad-constraints')
v = mdl.binary_var(name='v')
w = mdl.continuous_var(name='w', lb=0.)
mdl.minimize(v + w)
mdl.add_constraint(v + w >= 1, "cons2")
mdl.add_constraint(v**2 + w**2 <= 1, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(
rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=True,
)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_equality_constraints_with_continuous_variables(self):
"""Simple example to test equality constraints with continuous variables."""
mdl = Model("eq-constraints-cts-vars")
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.continuous_var(name='w', lb=0.)
t = mdl.continuous_var(name='t', lb=0.)
mdl.minimize(v + w + t)
mdl.add_constraint(2 * v + w >= 2, "cons1")
mdl.add_constraint(w + t == 1, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(
rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=True,
)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([0., 1., 0.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_ex5_warm_start(self):
"""Example 5 but with a warm start"""
mdl = Model('ex5')
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
t = mdl.binary_var(name='t')
mdl.minimize(v + w + t)
mdl.add_constraint(2 * v + 2 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=False,
warm_start=True)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([0., 1., 0.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_ex6_max(self):
"""Example 6 as maximization"""
mdl = Model('ex6-max')
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
t = mdl.binary_var(name='t')
u = mdl.continuous_var(name='u')
# mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
mdl.maximize(- v - w - t - 5 * (u - 2) ** 2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(
rho_initial=1001, beta=1000, factor_c=900,
maxiter=100, three_block=True, tol=1.e-6
)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 0., 2.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(-1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_setters_getters(self):
"""Tests get/set properties of ADMMOptimizer"""
optimizer = ADMMOptimizer()
self.assertEqual(optimizer.parameters.maxiter, 10)
optimizer.parameters.maxiter = 11
self.assertEqual(optimizer.parameters.maxiter, 11)
params = ADMMParameters(maxiter=12)
optimizer.parameters = params
self.assertEqual(optimizer.parameters.maxiter, 12)
def test_admm_ex4(self):
"""Example 4 as a unit test. Example 4 is reported in:
Gambella, C., & Simonetto, A. (2020).
Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
and Quantum Computers.
arXiv preprint arXiv:2001.02069."""
try:
mdl = Model('ex4')
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
# pylint:disable=invalid-name
t = mdl.binary_var(name='t')
# b = 1
b = 2
mdl.minimize(v + w + t)
mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= b, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
# qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
max_iter=100,
three_block=False)
solver = ADMMOptimizer(
params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_admm_ex4_no_bin_var_in_objective(self):
"""Modified Example 4 as a unit test. See the description of the previous test.
This test differs from the previous in the objective: one binary variable
is omitted in objective to test a problem when a binary variable defined but is used only
in constraints.
"""
try:
mdl = Model('ex4')
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
# pylint:disable=invalid-name
t = mdl.binary_var(name='t')
# b = 1
b = 2
mdl.minimize(v + t)
mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= b, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
# qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
max_iter=100,
three_block=False)
solver = ADMMOptimizer(
params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_admm_ex6(self):
"""Example 6 as a unit test. Example 6 is reported in:
Gambella, C., & Simonetto, A. (2020).
Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
and Quantum Computers.
arXiv preprint arXiv:2001.02069."""
try:
mdl = Model('ex6')
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
t = mdl.binary_var(name='t')
u = mdl.continuous_var(name='u')
mdl.minimize(v + w + t + 5 * (u - 2)**2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
op = QuadraticProgram()
op.from_docplex(mdl)
qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
max_iter=100,
three_block=True,
tol=1.e-6)
solver = ADMMOptimizer(params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 0., 2.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_quad_constraints(self):
"""Simple example to test quadratic constraints."""
try:
mdl = Model('quad-constraints')
v = mdl.binary_var(name='v')
w = mdl.continuous_var(name='w', lb=0.)
mdl.minimize(v + w)
mdl.add_constraint(v + w >= 1, "cons2")
mdl.add_constraint(v**2 + w**2 <= 1, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
# qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
qubo_optimizer = CplexOptimizer()
continuous_optimizer = CplexOptimizer()
admm_params = ADMMParameters(
rho_initial=1001,
beta=1000,
factor_c=900,
max_iter=100,
three_block=True,
)
solver = ADMMOptimizer(
params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
except NameError as ex:
self.skipTest(str(ex))
def test_admm_ex5(self):
"""Example 5 as a unit test. Example 5 is reported in:
Gambella, C., & Simonetto, A. (2020).
Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
and Quantum Computers.
arXiv preprint arXiv:2001.02069."""
mdl = Model('ex5')
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
t = mdl.binary_var(name='t')
mdl.minimize(v + w + t)
mdl.add_constraint(2 * v + 2 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=False)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def calculate(self, G, cost_matrix, starting_node = 0):
# Create nodes array for the TSP solver in Qiskit
coords = []
for node in G.nodes:
coords.append(G.nodes[node]['pos'])
tsp_instance = tsp.TspData(name = "TSP", dim = len(G.nodes), coord = coords, w = cost_matrix)
qubitOp, offset = tsp.get_operator(tsp_instance)
print("Qubits needed: ", qubitOp.num_qubits)
#print(qubitOp.print_details())
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
# Create QUBO based on qubitOp from the TSP
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
admm_params = ADMMParameters(
rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=True, tol=1.e-6)
qubo_optimizer = MinimumEigenOptimizer(QAOA(quantum_instance=backend))
convex_optimizer = CobylaOptimizer()
admm = ADMMOptimizer(params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=convex_optimizer)
quantum_instance = QuantumInstance(backend)
result = admm.solve(qp)
print(result)
def test_continuous_variable_decode(self):
""" Test decode func of IntegerToBinaryConverter for continuous variables"""
try:
mdl = Model('test_continuous_varable_decode')
c = mdl.continuous_var(lb=0, ub=10.9, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
converter = IntegerToBinary()
op = converter.encode(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
solution = solver.solve(op)
solution = converter.decode(solution)
self.assertEqual(solution.x[0], 10.9)
except NameError as ex:
self.skipTest(str(ex))
