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_admm_ex6_max(self):
"""Example 6 as maximization"""
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)
admm_params = ADMMParameters(
rho_initial=1001, beta=1000, factor_c=900,
maxiter=100, three_block=True, tol=1.e-6
)
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., 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)
def test_recursive_min_eigen_optimizer(self):
"""Test the recursive minimum eigen optimizer."""
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(filename, "algorithms/resources")
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
np.testing.assert_array_almost_equal(cplex_result.x, result.x, 4)
self.assertAlmostEqual(cplex_result.fval, result.fval)
def test_samples_and_raw_samples(self, simulator):
"""Test samples and raw_samples"""
algorithm_globals.random_seed = 2
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")
q_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator
grover_optimizer = GroverOptimizer(
8, num_iterations=self.n_iter, quantum_instance=q_instance
)
opt_sol = 1
success = OptimizationResultStatus.SUCCESS
results = grover_optimizer.solve(op)
self.assertEqual(len(results.samples), 8)
self.assertEqual(len(results.raw_samples), 32)
self.assertAlmostEqual(sum(s.probability for s in results.samples), 1)
self.assertAlmostEqual(sum(s.probability for s in results.raw_samples), 1)
self.assertAlmostEqual(min(s.fval for s in results.samples), 0)
self.assertAlmostEqual(min(s.fval for s in results.samples if s.status == success), opt_sol)
self.assertAlmostEqual(min(s.fval for s in results.raw_samples), opt_sol)
for sample in results.raw_samples:
self.assertEqual(sample.status, success)
np.testing.assert_array_almost_equal(results.x, results.samples[0].x)
self.assertAlmostEqual(results.fval, results.samples[0].fval)
self.assertEqual(results.status, results.samples[0].status)
self.assertAlmostEqual(results.fval, results.raw_samples[0].fval)
self.assertEqual(results.status, results.raw_samples[0].status)
np.testing.assert_array_almost_equal([1, 0, 0, 0, 0], results.raw_samples[0].x)
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_samples_and_raw_samples(self):
"""Test samples and raw_samples"""
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')
opt_sol = 1
success = OptimizationResultStatus.SUCCESS
algorithm_globals.random_seed = 1
grover_optimizer = GroverOptimizer(
5, num_iterations=2, quantum_instance=self.qasm_simulator)
result = grover_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)
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)
self.assertEqual(len(solution.samples), 1)
self.assertAlmostEqual(solution.fval, solution.samples[0].fval)
np.testing.assert_almost_equal(solution.x, solution.samples[0].x)
self.assertEqual(solution.status, solution.samples[0].status)
self.assertAlmostEqual(solution.samples[0].probability, 1.0)
def test_bit_ordering(self, simulator):
"""Test bit ordering"""
# test minimize
algorithm_globals.random_seed = 2
q_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator
mdl = Model("docplex model")
x = mdl.binary_var("x")
y = mdl.binary_var("y")
mdl.minimize(x - 2 * y)
op = QuadraticProgram()
op.from_docplex(mdl)
opt_sol = -2
success = OptimizationResultStatus.SUCCESS
grover_optimizer = GroverOptimizer(3,
num_iterations=10,
quantum_instance=q_instance)
results = grover_optimizer.solve(op)
self.assertEqual(results.fval, opt_sol)
np.testing.assert_array_almost_equal(results.x, [0, 1])
self.assertEqual(results.status, success)
results.raw_samples.sort(key=lambda x: x.probability, reverse=True)
self.assertAlmostEqual(sum(s.probability for s in results.samples),
1,
delta=1e-5)
self.assertAlmostEqual(sum(s.probability for s in results.raw_samples),
1,
delta=1e-5)
self.assertAlmostEqual(min(s.fval for s in results.samples), -2)
self.assertAlmostEqual(
min(s.fval for s in results.samples if s.status == success),
opt_sol)
self.assertAlmostEqual(min(s.fval for s in results.raw_samples),
opt_sol)
for sample in results.raw_samples:
self.assertEqual(sample.status, success)
def to_quadratic_program(self) -> QuadraticProgram:
"""Convert a portfolio diversification problem instance into a
:class:`~qiskit_optimization.problems.QuadraticProgram`.
Returns:
The :class:`~qiskit_optimization.problems.QuadraticProgram` created
from the portfolio diversification problem instance.
"""
mdl = AdvModel(name='Portfolio diversification')
x = {(i, j): mdl.binary_var(name='x_{0}_{1}'.format(i, j))
for i in range(self._num_assets) for j in range(self._num_assets)}
y = {
i: mdl.binary_var(name='y_{0}'.format(i))
for i in range(self._num_assets)
}
mdl.maximize(
mdl.sum(self._similarity_matrix[i, j] * x[(i, j)]
for i in range(self._num_assets)
for j in range(self._num_assets)))
mdl.add_constraint(
mdl.sum(y[j]
for j in range(self._num_assets)) == self._num_clusters)
for i in range(self._num_assets):
mdl.add_constraint(
mdl.sum(x[(i, j)] for j in range(self._num_assets)) == 1)
for j in range(self._num_assets):
mdl.add_constraint(x[(j, j)] == y[j])
for i in range(self._num_assets):
for j in range(self._num_assets):
mdl.add_constraint(x[(i, j)] <= y[j])
op = QuadraticProgram()
op.from_docplex(mdl)
return op
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(filename, "algorithms/resources")
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)
self.assertIsNotNone(result)
# analyze results
self.assertAlmostEqual(cplex_result.fval, result.fval)
# check that eigensolver result is present
self.assertIsNotNone(result.min_eigen_solver_result)
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.sv_simulator,
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.sv_simulator,
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.sv_simulator,
converters=invalid)
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)
result = min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
MinimumEigenOptimizer(min_eigen_solver,
converters=invalid)
def test_setters(self):
"""test setters."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
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.objective.constant = constant
quadratic_program.objective.linear = linear_coeffs
quadratic_program.objective.quadratic = 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.objective.sense = quadratic_program.objective.Sense.MAXIMIZE
self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MAXIMIZE)
quadratic_program.objective.sense = quadratic_program.objective.Sense.MINIMIZE
self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE)
def test_recursive_warm_qaoa(self):
"""Test the recursive optimizer with warm start qaoa."""
algorithm_globals.random_seed = 12345
backend = BasicAer.get_backend("statevector_simulator")
qaoa = QAOA(quantum_instance=backend, reps=1)
warm_qaoa = WarmStartQAOAOptimizer(pre_solver=SlsqpOptimizer(),
relax_for_pre_solver=True,
qaoa=qaoa)
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
warm_qaoa, min_num_vars=4)
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path("op_ip1.lp", "algorithms/resources")
problem.read_from_lp_file(lp_file)
# solve problem with cplex
cplex = CplexOptimizer(cplex_parameters={
"threads": 1,
"randomseed": 1
})
cplex_result = cplex.solve(problem)
# solve problem
result = recursive_min_eigen_optimizer.solve(problem)
# analyze results
np.testing.assert_array_almost_equal(cplex_result.x, result.x, 4)
self.assertAlmostEqual(cplex_result.fval, result.fval)
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.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.0, 1.0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1.0, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
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.0)
t = mdl.continuous_var(name="t", lb=0.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.0, 1.0, 0.0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(1.0, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_qubo_gas_int_paper_example(self, simulator):
"""
Test the example from https://arxiv.org/abs/1912.04088 using the state vector simulator
and the qasm simulator
"""
# 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
q_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator
gmf = GroverOptimizer(6,
num_iterations=n_iter,
quantum_instance=q_instance)
results = gmf.solve(op)
self.validate_results(op, results)
def setUp(self):
super().setUp()
# setup minimum eigen solvers
self.min_eigen_solvers = {}
# exact eigen solver
self.min_eigen_solvers["exact"] = NumPyMinimumEigensolver()
# QAOA
optimizer = COBYLA()
self.min_eigen_solvers["qaoa"] = QAOA(optimizer=optimizer)
# simulators
self.sv_simulator = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=123,
seed_transpiler=123,
)
self.qasm_simulator = QuantumInstance(
BasicAer.get_backend("qasm_simulator"),
seed_simulator=123,
seed_transpiler=123,
)
# test minimize
self.op_minimize = QuadraticProgram()
self.op_minimize.integer_var(0, 3, "x")
self.op_minimize.binary_var("y")
self.op_minimize.minimize(linear={"x": 1, "y": 2})
self.op_minimize.linear_constraint(linear={
"x": 1,
"y": 1
},
sense=">=",
rhs=1,
name="xy")
# test maximize
self.op_maximize = QuadraticProgram()
self.op_maximize.integer_var(0, 3, "x")
self.op_maximize.binary_var("y")
self.op_maximize.maximize(linear={"x": 1, "y": 2})
self.op_maximize.linear_constraint(linear={
"x": 1,
"y": 1
},
sense="<=",
rhs=1,
name="xy")
# test bit ordering
mdl = Model("docplex model")
x = mdl.binary_var("x")
y = mdl.binary_var("y")
mdl.minimize(x - 2 * y)
self.op_ordering = from_docplex_mp(mdl)
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_recursive_history(self):
"""Tests different options for history."""
filename = "op_ip1.lp"
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(filename, "algorithms/resources")
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])
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_trivial_constraints_to_docplex_mp(self):
"""test trivial constraints of to_docplex_mp"""
with self.subTest("trivial linear constraint"):
q_p = QuadraticProgram()
q_p.linear_constraint(sense="==", rhs=1.0)
mod = to_docplex_mp(q_p)
self.assertEqual(mod.number_of_variables, 0)
self.assertEqual(mod.number_of_constraints, 1)
self.assertEqual(mod.number_of_linear_constraints, 1)
cst = mod.get_constraint_by_index(0)
left = cst.get_left_expr()
self.assertTrue(left.is_constant())
self.assertAlmostEqual(left.constant, 0)
right = cst.get_right_expr()
self.assertTrue(right.is_constant())
self.assertAlmostEqual(right.constant, 1)
with self.subTest("trivial quadratic constraint"):
q_p = QuadraticProgram()
q_p.quadratic_constraint(sense="==", rhs=1.0)
mod = to_docplex_mp(q_p)
self.assertEqual(mod.number_of_variables, 0)
self.assertEqual(mod.number_of_constraints, 1)
self.assertEqual(mod.number_of_linear_constraints, 1)
cst = mod.get_constraint_by_index(0)
left = cst.get_left_expr()
self.assertTrue(left.is_constant())
self.assertAlmostEqual(left.constant, 0)
right = cst.get_right_expr()
self.assertTrue(right.is_constant())
self.assertAlmostEqual(right.constant, 1)
def test_cplex_optimizer_no_solution(self, config):
"""Cplex Optimizer Test if no solution is found"""
cplex_optimizer = CplexOptimizer(disp=False, cplex_parameters={"dettimelimit": 0})
# unpack configuration
filename, _, _ = config
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(filename, "algorithms/resources")
problem.read_from_lp_file(lp_file)
# solve problem with cplex
result = cplex_optimizer.solve(problem)
np.testing.assert_array_almost_equal(result.x, np.zeros(problem.get_num_vars()))
self.assertEqual(result.status, OptimizationResultStatus.FAILURE)
self.assertEqual(result.raw_results, None)
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_cplex_optimizer(self, config):
""" Cplex Optimizer Test """
# unpack configuration
filename, x, fval = config
# 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
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_gurobi_optimizer(self, config):
"""Gurobi Optimizer Test"""
# unpack configuration
gurobi_optimizer = GurobiOptimizer(disp=False)
filename, x, fval = config
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(filename, "algorithms/resources")
problem.read_from_lp_file(lp_file)
# solve problem with gurobi
result = gurobi_optimizer.solve(problem)
# analyze results
self.assertAlmostEqual(result.fval, fval)
np.testing.assert_array_almost_equal(result.x, x)
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.sv_simulator)
results = gmf.solve(op)
np.testing.assert_array_almost_equal(results.x, [0, 0])
self.assertEqual(results.fval, 0.0)
self.assertAlmostEqual(results.fval, results.intermediate_fval)
def test_init(self):
"""test init"""
q_p = QuadraticProgram()
q_p.integer_var_list(3)
result = OptimizationResult(x=[1, 2, 3],
fval=10,
variables=q_p.variables,
status=OptimizationResultStatus.SUCCESS)
np.testing.assert_allclose(result.x, [1, 2, 3])
self.assertAlmostEqual(result.fval, 10)
self.assertEqual(result.status, OptimizationResultStatus.SUCCESS)
self.assertIsNone(result.raw_results)
self.assertEqual(len(result.samples), 1)
sample = result.samples[0]
np.testing.assert_allclose(sample.x, [1, 2, 3])
self.assertAlmostEqual(sample.fval, 10)
self.assertEqual(sample.status, OptimizationResultStatus.SUCCESS)
self.assertAlmostEqual(sample.probability, 1)
def test_linear(self):
"""Test linear expression"""
q_p = QuadraticProgram()
q_p.binary_var_list(3)
q_p.linear_constraint({0: 1, 1: 2, 2: 3}, "==", 0)
self.assertEqual(expr2str(linear=q_p.get_linear_constraint(0).linear),
"x0 + 2*x1 + 3*x2")
self.assertEqual(
expr2str(constant=-1, linear=q_p.get_linear_constraint(0).linear),
"x0 + 2*x1 + 3*x2 - 1",
)
def to_quadratic_program(self) -> QuadraticProgram:
"""Convert a portfolio optimization problem instance into a
:class:`~qiskit_optimization.problems.QuadraticProgram`.
Returns:
The :class:`~qiskit_optimization.problems.QuadraticProgram` created
from the portfolio optimization problem instance.
"""
num_assets = len(self._expected_returns)
mdl = AdvModel(name='Portfolio optimization')
x = [mdl.binary_var(name='x_{0}'.format(i)) for i in range(num_assets)]
quad = mdl.quad_matrix_sum(self._covariances, x)
linear = np.dot(self._expected_returns, x)
mdl.minimize(self._risk_factor * quad - linear)
mdl.add_constraint(
mdl.sum(x[i] for i in range(num_assets)) == self._budget)
op = QuadraticProgram()
op.from_docplex(mdl)
return op
