def test_cobyla_optimizer(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()
result = cobyla.solve(problem)
# analyze results
self.assertAlmostEqual(result.fval, 5.8750)
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_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_cobyla_optimizer_with_quadratic_constraint(self):
""" Cobyla Optimizer Test With Quadratic Constraints. """
# load optimization problem
problem = QuadraticProgram()
problem.continuous_var(upperbound=1)
problem.continuous_var(upperbound=1)
problem.minimize(linear=[1, 1])
linear = [-1, -1]
quadratic = [[1, 0], [0, 1]]
problem.quadratic_constraint(linear=linear, quadratic=quadratic, rhs=-1/2)
# solve problem with cobyla
cobyla = CobylaOptimizer()
result = cobyla.solve(problem)
# analyze results
self.assertAlmostEqual(result.fval, 1.0, places=2)
def test_slsqp_optimizer_with_quadratic_constraint(self):
"""A test with equality constraint"""
problem = QuadraticProgram()
problem.continuous_var(upperbound=1)
problem.continuous_var(upperbound=1)
problem.minimize(linear=[1, 1])
linear = [-1, -1]
quadratic = [[1, 0], [0, 1]]
problem.quadratic_constraint(linear=linear, quadratic=quadratic, rhs=-1/2)
slsqp = SlsqpOptimizer()
solution = slsqp.solve(problem)
self.assertIsNotNone(solution)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([0.5, 0.5], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1., solution.fval, 3)
def test_optnvo_3_linear_2_quadratic_no_constant(self):
"""Test with 3 linear coefficients, 2 quadratic, and no constant."""
try:
# Circuit parameters.
num_value = 4
# Input.
problem = QuadraticProgram()
for name in ['x0', 'x1', 'x2']:
problem.binary_var(name)
linear = [-1, 2, -3]
quadratic = {('x0', 'x2'): -2, ('x1', 'x2'): -1}
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_optnvo_4_key_all_negative(self):
"""Test with all negative values."""
# Circuit parameters.
try:
num_value = 5
# Input.
problem = QuadraticProgram()
for name in ['x0', 'x1', 'x2']:
problem.binary_var(name)
linear = [-1, -2, -1]
quadratic = {('x0', 'x1'): -1, ('x0', 'x2'): -2, ('x1', 'x2'): -1}
problem.minimize(constant=-1, 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_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)
for jj in range(len(z)):
if ((ii >= numOfItems) and (jj >= numOfItems)):
if (ii != jj):
quadraticCoeffDict[(z[ii], z[jj])] = penalty
else:
quadraticCoeffDict[(z[ii], z[jj])] = quadraticCoeffs[ii][jj]
else:
quadraticCoeffDict[(z[ii], z[jj])] = quadraticCoeffs[ii][jj]
#backend = BasicAer.get_backend('statevector_simulator')
qubo = QuadraticProgram()
for ii in range(numOfItems + backPackCap):
qubo.binary_var(z[ii])
qubo.minimize(linear=linearCoeff, quadratic=quadraticCoeffDict)
print(qubo.export_as_lp_string())
"""qaoa_mes = QAOA(quantum_instance=BasicAer.get_backend('statevector_simulator'));
qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA
qaoa_result = qaoa.solve(qubo)
print(qaoa_result)"""
quantumBackend = QuantumInstance(provider.get_backend('ibmq_qasm_simulator'),
shots=2048,
skip_qobj_validation=False)
qaoa_mes = QAOA(quantum_instance=quantumBackend)
qaoa = MinimumEigenOptimizer(qaoa_mes)
# using QAOA
