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."""
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()
problem.read_from_lp_file(self.resource_path + filename)
# 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 RuntimeError as ex:
msg = str(ex)
if 'CPLEX' in msg:
self.skipTest(msg)
else:
self.fail(msg)
def test_recursive_min_eigen_optimizer(self, config):
""" Min Eigen Optimizer Test """
# 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)
if backend == 'qasm_simulator':
min_eigen_solver.quantum_instance.run_config.shots = 10000
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# construct minimum eigen optimizer
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=4)
# load optimization problem
problem = OptimizationProblem()
problem.read(self.resource_path + filename)
# 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)
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 calculate(self, G, cost_matrix, starting_node=0):
# Create nodes array for the TSP solver in Qiskit
coords = []
for node in G.nodes:
coords.append(G.nodes[node]['pos'])
tsp_instance = tsp.TspData(name="TSP",
dim=len(G.nodes),
coord=coords,
w=cost_matrix)
qubitOp, offset = tsp.get_operator(tsp_instance)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
optimizer = COBYLA(maxiter=300, rhobeg=3, tol=1.5)
# Define Minimum Eigen Solvers
minimum_eigen_solver = QAOA(quantum_instance=quantum_instance,
optimizer=optimizer,
operator=qubitOp)
#minimum_eigen_solver = VQE(quantum_instance=quantum_instance, optimizer=optimizer, operator=qubitOp)
exact_mes = NumPyMinimumEigensolver()
# Create the optimizers so we can plug our Quadratic Program
minimum_eigen_optimizer = MinimumEigenOptimizer(minimum_eigen_solver)
#vqe = MinimumEigenOptimizer(vqe_mes)
exact = MinimumEigenOptimizer(exact_mes)
rqaoa = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer=minimum_eigen_optimizer,
min_num_vars=1,
min_num_vars_optimizer=exact)
# Create QUBO based on qubitOp from the TSP
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
result = rqaoa.solve(qp)
if (tsp.tsp_feasible(result.x)):
z = tsp.get_tsp_solution(result.x)
print('solution:', z)
return z
else:
print('no solution:', result.x)
return []
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)
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
qaoa_result = qaoa.solve(qubo)
print(qaoa_result)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
# using the exact classical numpy minimum eigen solver
exact_result = exact.solve(qubo)
print(exact_result)
rqaoa = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer=qaoa,
min_num_vars=14,
min_num_vars_optimizer=MinimumEigenOptimizer(NumPyMinimumEigensolver()))
rqaoa_result = rqaoa.solve(qubo)
print(rqaoa_result)
grover_mes = GroverOptimizer(numOfItems + backPackCap,
num_iterations=15,
quantum_instance=quantumBackend)
grover_result = grover_mes.solve(qubo)
print(grover_result)
print("x={}".format(grover_result.x))
print("fval={}".format(grover_result.fval))