def test_linear_equality_to_penalty_decode(self):
"""Test decode func of LinearEqualityToPenalty"""
qprog = QuadraticProgram()
qprog.binary_var("x")
qprog.binary_var("y")
qprog.binary_var("z")
qprog.maximize(linear={"x": 3, "y": 1, "z": 1})
qprog.linear_constraint(linear={
"x": 1,
"y": 1,
"z": 1
},
sense="EQ",
rhs=2,
name="xyz_eq")
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qprog)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
result = exact.solve(qubo)
new_x = lineq2penalty.interpret(result.x)
np.testing.assert_array_almost_equal(new_x, [1, 1, 0])
infeasible_x = lineq2penalty.interpret([1, 1, 1])
np.testing.assert_array_almost_equal(infeasible_x, [1, 1, 1])
def test_auto_penalty(self):
"""Test auto penalty function"""
op = QuadraticProgram()
op.binary_var("x")
op.binary_var("y")
op.binary_var("z")
op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2})
op.linear_constraint(linear={
"x": 1,
"y": 1,
"z": 1
},
sense="EQ",
rhs=2,
name="xyz_eq")
lineq2penalty = LinearEqualityToPenalty(penalty=1e5)
lineq2penalty_auto = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(op)
qubo_auto = lineq2penalty_auto.convert(op)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
result = exact.solve(qubo)
result_auto = exact.solve(qubo_auto)
self.assertEqual(result.fval, result_auto.fval)
np.testing.assert_array_almost_equal(result.x, result_auto.x)
def test_samples_vqe(self, simulator):
"""Test samples for VQE"""
# test minimize
algorithm_globals.random_seed = 1
quantum_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator
opt_sol = -2
success = OptimizationResultStatus.SUCCESS
optimizer = SPSA(maxiter=100)
ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full")
vqe_mes = VQE(ry_ansatz, optimizer=optimizer, quantum_instance=quantum_instance)
vqe = MinimumEigenOptimizer(vqe_mes)
results = vqe.solve(self.op_ordering)
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)
np.testing.assert_array_almost_equal(results.x, results.raw_samples[0].x)
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)
np.testing.assert_array_almost_equal(results.samples[0].x, [0, 1])
self.assertAlmostEqual(results.samples[0].fval, opt_sol)
self.assertEqual(results.samples[0].status, success)
np.testing.assert_array_almost_equal(results.raw_samples[0].x, [0, 1])
self.assertAlmostEqual(results.raw_samples[0].fval, opt_sol)
self.assertEqual(results.raw_samples[0].status, success)
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_runtime(self, subroutine):
"""Test vqe and qaoa runtime"""
optimizer = {"name": "SPSA", "maxiter": 100}
backend = QasmSimulatorPy()
if subroutine == "vqe":
ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full")
initial_point = np.random.default_rng(42).random(
ry_ansatz.num_parameters)
solver = VQEProgram(
ansatz=ry_ansatz,
optimizer=optimizer,
initial_point=initial_point,
backend=backend,
provider=FakeVQERuntimeProvider(),
)
else:
reps = 2
initial_point = np.random.default_rng(42).random(2 * reps)
solver = QAOAProgram(
optimizer=optimizer,
reps=reps,
initial_point=initial_point,
backend=backend,
provider=FakeQAOARuntimeProvider(),
)
opt = MinimumEigenOptimizer(solver)
result = opt.solve(self.op_ordering)
self.assertIsInstance(result, MinimumEigenOptimizationResult)
def qaoa(G):
n = G.numberOfNodes()
G = nw.nxadapter.nk2nx(G)
w = nx.adjacency_matrix(G)
problem = QuadraticProgram()
_ = [problem.binary_var(f"x{i}") for i in range(n)]
linear = w.dot(np.ones(n))
quadratic = -w
problem.maximize(linear=linear, quadratic=quadratic)
c = [1]
for _ in range(n - 1):
c.append(0)
problem.linear_constraint(c, '==', 1)
cobyla = COBYLA()
backend = BasicAer.get_backend('qasm_simulator')
qaoa = QAOA(optimizer=cobyla, reps=3, quantum_instance=backend)
algorithm = MinimumEigenOptimizer(qaoa)
result = algorithm.solve(problem)
L = result.x
i = 0
res = {}
for x in L:
res[i] = x
i += 1
return res
def validate_results(self, problem, results):
"""Validate the results object returned by GroverOptimizer."""
# Get expected value.
solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
comp_result = solver.solve(problem)
# Validate results.
np.testing.assert_array_almost_equal(comp_result.x, results.x)
self.assertEqual(comp_result.fval, results.fval)
self.assertAlmostEqual(results.fval, results.intermediate_fval)
def _sample_code(self):
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
import networkx as nx
import numpy as np
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit import BasicAer
from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import SPSA
# Generate a graph of 4 nodes
n = 4
graph = nx.Graph()
graph.add_nodes_from(np.arange(0, n, 1))
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0),
(2, 3, 1.0)]
graph.add_weighted_edges_from(elist)
# Compute the weight matrix from the graph
w = nx.adjacency_matrix(graph)
# Formulate the problem as quadratic program
problem = QuadraticProgram()
_ = [problem.binary_var('x{}'.format(i))
for i in range(n)] # create n binary variables
linear = w.dot(np.ones(n))
quadratic = -w
problem.maximize(linear=linear, quadratic=quadratic)
# Fix node 0 to be 1 to break the symmetry of the max-cut solution
problem.linear_constraint([1, 0, 0, 0], '==', 1)
# Run quantum algorithm QAOA on qasm simulator
spsa = SPSA(maxiter=250)
backend = BasicAer.get_backend('qasm_simulator')
qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend)
algorithm = MinimumEigenOptimizer(qaoa)
result = algorithm.solve(problem)
print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4
# ----------------------------------------------------------------------
return result
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_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_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={'y': 1, 'x': 1}, sense='LE', rhs=3, name='xy_leq')
# construct minimum eigen optimizer
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# a single converter
qp2qubo = QuadraticProgramToQubo()
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=2,
converters=qp2qubo)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=2,
converters=converters)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# invalid converters
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=2,
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 solve_classically(qubo):
"""[summary]
Args:
qubo ([type]): [description]
Returns:
[type]: [description]
"""
from copy import deepcopy
from qiskit_optimization.problems.quadratic_objective import ObjSense
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
exact_result = exact.solve(qubo)
qubo_2 = deepcopy(qubo)
qubo_2.objective.sense = ObjSense.MAXIMIZE
worst_result = exact.solve(qubo_2)
return exact_result, worst_result
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 get_quantum_solution_for(quadprog: QuadraticProgram,
quantumInstance: QuantumInstance,
optimizer=None):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
# Create solver and optimizer
solver = QAOA(
optimizer=optimizer,
quantum_instance=quantumInstance,
callback=callback,
max_evals_grouped=3,
)
# Create optimizer for solver
optimizer = MinimumEigenOptimizer(solver)
# Get result from optimizer
result = optimizer.solve(quadprog)
return result, _eval_count
def test_samples_numpy_eigen_solver(self):
"""Test samples for NumPyMinimumEigensolver"""
# test minimize
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(self.op_minimize)
opt_sol = 1
success = OptimizationResultStatus.SUCCESS
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)
# test maximize
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(self.op_maximize)
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)
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_min_eigen_optimizer_with_filter(self, config):
""" Min Eigen Optimizer Test """
try:
# unpack configuration
filename, lowerbound, fval, status = config
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# set filter
# pylint: disable=unused-argument
def filter_criterion(x, v, aux):
return v > lowerbound
min_eigen_solver.filter_criterion = filter_criterion
# 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
result = min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result)
# analyze results
self.assertAlmostEqual(fval, result.fval)
self.assertEqual(status, result.status)
# check that eigensolver result is present
self.assertIsNotNone(result.min_eigen_solver_result)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
except RuntimeError as ex:
self.fail(str(ex))
def test_continuous_variable_decode(self):
"""Test decode func of IntegerToBinaryConverter for continuous variables"""
mdl = Model("test_continuous_varable_decode")
c = mdl.continuous_var(lb=0, ub=10.9, name="c")
x = mdl.binary_var(name="x")
mdl.maximize(c + x * x)
op = from_docplex_mp(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
new_x = converter.interpret(result.x)
self.assertEqual(new_x[0], 10.9)
def test_continuous_variable_decode(self):
""" Test decode func of IntegerToBinaryConverter for continuous variables"""
try:
mdl = Model('test_continuous_varable_decode')
c = mdl.continuous_var(lb=0, ub=10.9, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
new_x = converter.interpret(result.x)
self.assertEqual(new_x[0], 10.9)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_samples_qaoa(self, simulator):
"""Test samples for QAOA"""
# test minimize
algorithm_globals.random_seed = 1
quantum_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator
qaoa = QAOA(quantum_instance=quantum_instance, reps=2)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(self.op_minimize)
success = OptimizationResultStatus.SUCCESS
opt_sol = 1
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, [1, 0])
self.assertAlmostEqual(result.fval, result.samples[0].fval)
self.assertEqual(result.status, result.samples[0].status)
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertEqual(result.samples[0].status, success)
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.assertEqual(result.raw_samples[0].status, success)
# test maximize
opt_sol = 2
qaoa = QAOA(quantum_instance=quantum_instance, reps=2)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(self.op_maximize)
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, [0, 1])
self.assertEqual(result.fval, opt_sol)
self.assertEqual(result.status, success)
np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertEqual(result.samples[0].status, success)
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.assertEqual(result.raw_samples[0].status, success)
# test bit ordering
opt_sol = -2
qaoa = QAOA(quantum_instance=quantum_instance, reps=2)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(self.op_ordering)
self.assertEqual(result.fval, opt_sol)
np.testing.assert_array_almost_equal(result.x, [0, 1])
self.assertEqual(result.status, success)
result.raw_samples.sort(key=lambda x: x.probability, reverse=True)
np.testing.assert_array_almost_equal(result.x, result.raw_samples[0].x)
self.assertAlmostEqual(sum(s.probability for s in result.samples), 1, delta=1e-5)
self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1, delta=1e-5)
self.assertAlmostEqual(min(s.fval for s in result.samples), -2)
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.samples[0].x, [0, 1])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertEqual(result.samples[0].status, success)
np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 1])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertEqual(result.raw_samples[0].status, success)
def test_samples(self):
"""Test samples"""
SUCCESS = OptimizationResultStatus.SUCCESS # pylint: disable=invalid-name
algorithm_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)
