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_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_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)
quadraticCoeffDict = {}
for ii in range(len(z)):
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)
