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={
'x': 1,
'y': 1
},
sense='LE',
rhs=3,
name='xy_leq')
min_eigen_solver = NumPyMinimumEigensolver()
# a single converter
qp2qubo = QuadraticProgramToQubo()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver,
converters=qp2qubo)
result = min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver,
converters=converters)
self.assertEqual(result.fval, 4)
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
MinimumEigenOptimizer(min_eigen_solver, converters=invalid)
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_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_slsqp_bounded(self):
"""Same as above, but a bounded test"""
problem = QuadraticProgram()
problem.continuous_var(name="x", lowerbound=2.5)
problem.continuous_var(name="y", upperbound=0.5)
problem.maximize(linear=[2, 0], quadratic=[[-1, 2], [0, -2]])
slsqp = SlsqpOptimizer()
solution = slsqp.solve(problem)
self.assertIsNotNone(solution)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([2.5, 0.5], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(0.75, solution.fval, 3)
def test_slsqp_unbounded(self):
"""Unbounded test for optimization"""
problem = QuadraticProgram()
problem.continuous_var(name="x")
problem.continuous_var(name="y")
problem.maximize(linear=[2, 0], quadratic=[[-1, 2], [0, -2]])
slsqp = SlsqpOptimizer()
solution = slsqp.solve(problem)
self.assertIsNotNone(solution)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([2., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
def test_slsqp_inequality(self):
"""A test with inequality constraint"""
problem = QuadraticProgram()
problem.continuous_var(name="x")
problem.continuous_var(name="y")
problem.linear_constraint(linear=[1, -1], sense='>=', rhs=1)
problem.maximize(linear=[2, 0], quadratic=[[-1, 2], [0, -2]])
slsqp = SlsqpOptimizer()
solution = slsqp.solve(problem)
self.assertIsNotNone(solution)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([2., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
def test_init(self):
""" test init. """
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
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)
def test_samples(self):
"""Test samples"""
SUCCESS = OptimizationResultStatus.SUCCESS # pylint: disable=invalid-name
aqua_globals.random_seed = 123
quantum_instance = QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
seed_simulator=123,
seed_transpiler=123,
shots=1000)
# test minimize
op = QuadraticProgram()
op.integer_var(0, 3, 'x')
op.binary_var('y')
op.minimize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={
'x': 1,
'y': 1
},
sense='>=',
rhs=1,
name='xy')
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(op)
opt_sol = 1
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, SUCCESS)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x,
[1, 0, 0, 0, 0])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, SUCCESS)
qaoa = QAOA(quantum_instance=quantum_instance)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(op)
self.assertEqual(len(result.samples), 8)
self.assertEqual(len(result.raw_samples), 32)
self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
self.assertAlmostEqual(sum(s.probability for s in result.raw_samples),
1)
self.assertAlmostEqual(min(s.fval for s in result.samples), 0)
self.assertAlmostEqual(
min(s.fval for s in result.samples if s.status == SUCCESS),
opt_sol)
self.assertAlmostEqual(min(s.fval for s in result.raw_samples),
opt_sol)
for sample in result.raw_samples:
self.assertEqual(sample.status, SUCCESS)
np.testing.assert_array_almost_equal(result.x, result.samples[0].x)
self.assertAlmostEqual(result.fval, result.samples[0].fval)
self.assertEqual(result.status, result.samples[0].status)
# test maximize
op = QuadraticProgram()
op.integer_var(0, 3, 'x')
op.binary_var('y')
op.maximize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={
'x': 1,
'y': 1
},
sense='<=',
rhs=1,
name='xy')
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(op)
opt_sol = 2
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, SUCCESS)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x,
[0, 0, 1, 0])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, SUCCESS)
qaoa = QAOA(quantum_instance=quantum_instance)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(op)
self.assertEqual(len(result.samples), 8)
self.assertEqual(len(result.raw_samples), 16)
self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
self.assertAlmostEqual(sum(s.probability for s in result.raw_samples),
1)
self.assertAlmostEqual(max(s.fval for s in result.samples), 5)
self.assertAlmostEqual(
max(s.fval for s in result.samples if s.status == SUCCESS),
opt_sol)
self.assertAlmostEqual(max(s.fval for s in result.raw_samples),
opt_sol)
for sample in result.raw_samples:
self.assertEqual(sample.status, SUCCESS)
np.testing.assert_array_almost_equal(result.x, result.samples[0].x)
self.assertAlmostEqual(result.fval, result.samples[0].fval)
self.assertEqual(result.status, result.samples[0].status)
