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_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_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_cobyla_optimizer_with_trials(self):
""" Cobyla Optimizer Test. """
# load optimization problem
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 cobyla
cobyla = CobylaOptimizer(trials=3)
result = cobyla.solve(problem)
# analyze results
self.assertAlmostEqual(result.fval, 5.8750)
def test_slsqp_optimizer_full_output(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, full_output=True)
result = slsqp.solve(problem)
self.assertAlmostEqual(result.fval, 5.8750)
self.assertAlmostEqual(result.fx, 5.8750)
self.assertGreaterEqual(result.its, 1)
self.assertEqual(result.imode, 0)
self.assertIsNotNone(result.smode)
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)
