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_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_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_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_recursive_min_eigen_optimizer(self):
"""Test the recursive minimum eigen optimizer."""
try:
filename = 'op_ip1.lp'
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=4)
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(path.join('resources', filename))
problem.read_from_lp_file(lp_file)
# solve problem with cplex
cplex = CplexOptimizer()
cplex_result = cplex.solve(problem)
# solve problem
result = recursive_min_eigen_optimizer.solve(problem)
# analyze results
self.assertAlmostEqual(cplex_result.fval, result.fval)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_min_eigen_optimizer(self, config):
""" Min Eigen Optimizer Test """
try:
# unpack configuration
min_eigen_solver_name, backend, filename = config
# get minimum eigen solver
min_eigen_solver = self.min_eigen_solvers[min_eigen_solver_name]
if backend:
min_eigen_solver.quantum_instance = BasicAer.get_backend(
backend)
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(path.join('resources', filename))
problem.read_from_lp_file(lp_file)
# solve problem with cplex
cplex = CplexOptimizer()
cplex_result = cplex.solve(problem)
# solve problem
result = min_eigen_optimizer.solve(problem)
# analyze results
self.assertAlmostEqual(cplex_result.fval, result.fval)
except RuntimeError as ex:
msg = str(ex)
if 'CPLEX' in msg:
self.skipTest(msg)
else:
self.fail(msg)
def test_min_eigen_optimizer_history(self):
"""Tests different options for history."""
try:
filename = 'op_ip1.lp'
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(path.join('resources', filename))
problem.read_from_lp_file(lp_file)
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# no history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.NO_ITERATIONS)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNone(result.history[1])
# only last iteration in the history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.LAST_ITERATION)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNotNone(result.history[1])
# full history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.ALL_ITERATIONS)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertGreater(len(result.history[0]), 1)
self.assertIsNotNone(result.history[1])
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
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_optnvo_6_key(self):
"""Test with 6 linear coefficients, negative quadratics, no constant."""
# Circuit parameters.
try:
num_value = 4
# Input.
problem = QuadraticProgram()
# Input.
problem = QuadraticProgram()
for name in ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']:
problem.binary_var(name)
linear = [-1, -2, -1, 0, 1, 2]
quadratic = {('x0', 'x3'): -1, ('x1', 'x5'): -2}
problem.minimize(linear=linear, quadratic=quadratic)
# Convert to dictionary format with operator/oracle.
converter = QuadraticProgramToNegativeValueOracle(num_value)
a_operator, _, func_dict = converter.encode(problem)
self._validate_function(func_dict, problem)
self._validate_operator(func_dict, len(linear), num_value,
a_operator)
except NameError as ex:
self.skipTest(str(ex))
def test_cobyla_optimizer_with_variable_bounds(self):
""" Cobyla Optimizer Test With Variable Bounds. """
# initialize optimizer
cobyla = CobylaOptimizer()
# initialize problem
problem = QuadraticProgram()
# set variables and bounds
problem.continuous_var(lowerbound=-1, upperbound=1)
problem.continuous_var(lowerbound=-2, upperbound=2)
# set objective and minimize
problem.minimize(linear=[1, 1])
# solve problem with cobyla
result = cobyla.solve(problem)
# analyze results
self.assertAlmostEqual(result.x[0], -1.0, places=6)
self.assertAlmostEqual(result.x[1], -2.0, places=6)
# set objective and minimize
problem.maximize(linear=[1, 1])
# solve problem with cobyla
result = cobyla.solve(problem)
# analyze results
self.assertAlmostEqual(result.x[0], 1.0, places=6)
self.assertAlmostEqual(result.x[1], 2.0, places=6)
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 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)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
optimizer = COBYLA(maxiter=300, rhobeg=3, tol=1.5)
# Define Minimum Eigen Solvers
minimum_eigen_solver = QAOA(quantum_instance=quantum_instance,
optimizer=optimizer,
operator=qubitOp)
#minimum_eigen_solver = VQE(quantum_instance=quantum_instance, optimizer=optimizer, operator=qubitOp)
exact_mes = NumPyMinimumEigensolver()
# Create the optimizers so we can plug our Quadratic Program
minimum_eigen_optimizer = MinimumEigenOptimizer(minimum_eigen_solver)
#vqe = MinimumEigenOptimizer(vqe_mes)
exact = MinimumEigenOptimizer(exact_mes)
rqaoa = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer=minimum_eigen_optimizer,
min_num_vars=1,
min_num_vars_optimizer=exact)
# Create QUBO based on qubitOp from the TSP
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
result = rqaoa.solve(qp)
if (tsp.tsp_feasible(result.x)):
z = tsp.get_tsp_solution(result.x)
print('solution:', z)
return z
else:
print('no solution:', result.x)
return []
def test_cplex_optimizer(self, config):
""" Cplex Optimizer Test """
# unpack configuration
filename, x, fval = config
# load optimization problem
problem = QuadraticProgram()
problem.read_from_lp_file(self.resource_path + filename)
# solve problem with cplex
result = self.cplex_optimizer.solve(problem)
# analyze results
self.assertAlmostEqual(result.fval, fval)
for i in range(problem.get_num_vars()):
self.assertAlmostEqual(result.x[i], x[i])
def test_qubo_gas_int_simple_maximize(self):
"""Test for simple case, but with maximization."""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
model.maximize(-x_0+2*x_1)
op = QuadraticProgram()
op.from_docplex(model)
# Get the optimum key and value.
n_iter = 8
gmf = GroverOptimizer(4, num_iterations=n_iter, quantum_instance=self.sv_simulator)
results = gmf.solve(op)
self.validate_results(op, results)
def test_qubo_gas_int_zero(self):
"""Test for when the answer is zero."""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
model.minimize(0*x_0+0*x_1)
op = QuadraticProgram()
op.from_docplex(model)
# Will not find a negative, should return 0.
gmf = GroverOptimizer(1, num_iterations=1, quantum_instance=self.q_instance)
results = gmf.solve(op)
self.assertEqual(results.x, [0, 0])
self.assertEqual(results.fval, 0.0)
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_qubo_gas_int_paper_example(self):
"""Test the example from https://arxiv.org/abs/1912.04088."""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
x_2 = model.binary_var(name='x2')
model.minimize(-x_0+2*x_1-3*x_2-2*x_0*x_2-1*x_1*x_2)
op = QuadraticProgram()
op.from_docplex(model)
# Get the optimum key and value.
n_iter = 10
gmf = GroverOptimizer(6, num_iterations=n_iter, quantum_instance=self.q_instance)
results = gmf.solve(op)
self.validate_results(op, results)
def test_admm_ex6_max(self):
"""Example 6 as maximization"""
try:
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)
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_init(self):
""" test init. """
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
# pylint: disable=no-member
self.assertEqual(quadratic_program.objective.constant, 0.0)
self.assertEqual(len(quadratic_program.objective.linear.to_dict()), 0)
self.assertEqual(len(quadratic_program.objective.quadratic.to_dict()),
0)
self.assertEqual(quadratic_program.objective.sense,
QuadraticObjective.Sense.MINIMIZE)
constant = 1.0
linear_coeffs = np.array(range(5))
lst = [[0 for _ in range(5)] for _ in range(5)]
for i, v in enumerate(lst):
for j, _ in enumerate(v):
lst[min(i, j)][max(i, j)] += i * j
quadratic_coeffs = np.array(lst)
quadratic_program.minimize(constant, linear_coeffs, quadratic_coeffs)
self.assertEqual(quadratic_program.objective.constant, constant)
self.assertTrue(
(quadratic_program.objective.linear.to_array() == linear_coeffs
).all())
self.assertTrue((quadratic_program.objective.quadratic.to_array() ==
quadratic_coeffs).all())
self.assertEqual(quadratic_program.objective.sense,
QuadraticObjective.Sense.MINIMIZE)
quadratic_program.maximize(constant, linear_coeffs, quadratic_coeffs)
self.assertEqual(quadratic_program.objective.constant, constant)
self.assertTrue(
(quadratic_program.objective.linear.to_array() == linear_coeffs
).all())
self.assertTrue((quadratic_program.objective.quadratic.to_array() ==
quadratic_coeffs).all())
self.assertEqual(quadratic_program.objective.sense,
QuadraticObjective.Sense.MAXIMIZE)
self.assertEqual(quadratic_program.objective.evaluate(linear_coeffs),
931.0)
grad_values = [0., 61., 122., 183., 244.]
np.testing.assert_almost_equal(
quadratic_program.objective.evaluate_gradient(linear_coeffs),
grad_values)
def test_qubo_gas_int_simple(self):
"""Test for simple case, with 2 linear coeffs and no quadratic coeffs or constants."""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
model.minimize(-x_0+2*x_1)
op = QuadraticProgram()
op.from_docplex(model)
# Get the optimum key and value.
n_iter = 8
gmf = GroverOptimizer(4, num_iterations=n_iter, quantum_instance=self.sv_simulator)
results = gmf.solve(op)
self.validate_results(op, results)
self.assertIsNotNone(results.operation_counts)
self.assertEqual(results.n_input_qubits, 2)
self.assertEqual(results.n_output_qubits, 4)
def hamiltonian_calculator(cellular_potts_matrix, area_coeff,
area_of_cell_dict, perimeter_coeff,
perimeter_of_cell_dict):
mdl = Model()
A_0 = mdl.integer_var(lb=min(area_of_cell_dict) - 1,
ub=max(area_of_cell_dict) + 1,
name="A")
P_0 = mdl.integer_var(lb=min(perimeter_of_cell_dict) - 1,
ub=max(perimeter_of_cell_dict) + 1,
name="P")
objective_1 = area_coeff * mdl.sum(
[value - A_0 for key, value in area_of_cell_dict.items()])**2
objective_2 = perimeter_coeff * mdl.sum(
[value - P_0 for key, value in perimeter_of_cell_dict.items()])**2
objective_3 = mdl.sum(get_interaction(cellular_potts_matrix))
objective = objective_1 + objective_2 + objective_3
mdl.minimize(objective)
qp = QuadraticProgram()
qp.from_docplex(mdl)
# print(qp.export_as_lp_string())
return qp
def test_init_default(self):
""" test init with default values."""
quadratic_program = QuadraticProgram()
name = 'variable'
variable = Variable(quadratic_program, name)
self.assertEqual(variable.name, name)
self.assertEqual(variable.lowerbound, 0)
self.assertEqual(variable.upperbound, INFINITY)
self.assertEqual(variable.vartype, Variable.Type.CONTINUOUS)
def test_slsqp_optimizer(self):
""" Generic SLSQP Optimizer Test. """
problem = QuadraticProgram()
problem.continuous_var(upperbound=4)
problem.continuous_var(upperbound=4)
problem.linear_constraint(linear=[1, 1], sense='=', rhs=2)
problem.minimize(linear=[2, 2], quadratic=[[2, 0.25], [0.25, 0.5]])
# solve problem with SLSQP
slsqp = SlsqpOptimizer(trials=3)
result = slsqp.solve(problem)
self.assertAlmostEqual(result.fval, 5.8750)
def test_converter_list(self):
"""Test converter list"""
op = QuadraticProgram()
op.integer_var(0, 3, "x")
op.binary_var('y')
op.maximize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={
'y': 1,
'x': 1
},
sense='LE',
rhs=3,
name='xy_leq')
# construct minimum eigen optimizer
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# a single converter
qp2qubo = QuadraticProgramToQubo()
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=2, converters=qp2qubo)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=2, converters=converters)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# invalid converters
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=2,
converters=invalid)
def test_integer_variables(self):
"""Tests ADMM with integer variables."""
mdl = Model('integer-variables')
v = mdl.integer_var(lb=5, ub=20, name='v')
w = mdl.continuous_var(name='w', lb=0.)
mdl.minimize(v + w)
op = QuadraticProgram()
op.from_docplex(mdl)
solver = ADMMOptimizer()
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([5., 0.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(5., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_min_eigen_optimizer_with_filter(self, config):
""" Min Eigen Optimizer Test """
try:
# unpack configuration
filename, lowerbound, fval, status = config
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# set filter
# pylint: disable=unused-argument
def filter_criterion(x, v, aux):
return v > lowerbound
min_eigen_solver.filter_criterion = filter_criterion
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(path.join('resources', filename))
problem.read_from_lp_file(lp_file)
# solve problem
result = min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result)
# analyze results
self.assertAlmostEqual(fval, result.fval)
self.assertEqual(status, result.status)
# check that eigensolver result is present
self.assertIsNotNone(result.min_eigen_solver_result)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
except RuntimeError as ex:
self.fail(str(ex))
def test_converter_list(self):
"""Test converters list"""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
model.maximize(-x_0 + 2 * x_1)
op = QuadraticProgram()
op.from_docplex(model)
# Get the optimum key and value.
n_iter = 8
# a single converter.
qp2qubo = QuadraticProgramToQubo()
gmf = GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=qp2qubo)
results = gmf.solve(op)
self.validate_results(op, results)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
gmf = GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=converters)
results = gmf.solve(op)
self.validate_results(op, results)
# invalid converters
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=invalid)
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 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)
