def test_qaoa_qc_mixer_many_parameters(self):
""" QAOA test with a mixer as a parameterized circuit with the num of parameters > 1. """
seed = 0
aqua_globals.random_seed = seed
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
for i in range(num_qubits):
theta = Parameter('θ' + str(i))
mixer.rx(theta, range(num_qubits))
backend = BasicAer.get_backend('statevector_simulator')
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer=optimizer,
p=2,
mixer=mixer,
quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
self.log.debug(x)
graph_solution = max_cut.get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]), S1)
def test_change_operator_size(self):
"""QAOA change operator size test"""
qubit_op, _ = self._get_operator(
np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]]))
qaoa = QAOA(COBYLA(), 1, quantum_instance=self.statevector_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest(msg="QAOA 4x4"):
self.assertIn(graph_solution, {"0101", "1010"})
qubit_op, _ = self._get_operator(
np.array([
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
]))
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest(msg="QAOA 6x6"):
self.assertIn(graph_solution, {"010101", "101010"})
def test_qaoa_initial_point(self, w, solutions, init_pt):
"""Check first parameter value used is initial point as expected"""
qubit_op, _ = self._get_operator(w)
first_pt = []
def cb_callback(eval_count, parameters, mean, std):
nonlocal first_pt
if eval_count == 1:
first_pt = list(parameters)
qaoa = QAOA(
COBYLA(),
initial_point=init_pt,
callback=cb_callback,
quantum_instance=self.statevector_simulator,
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest("Initial Point"):
# If None the preferred random initial point of QAOA variational form
if init_pt is None:
self.assertLess(result.eigenvalue, -0.97)
else:
self.assertListEqual(init_pt, first_pt)
with self.subTest("Solution"):
self.assertIn(graph_solution, solutions)
def test_qaoa(self, w, prob, m, solutions, convert_to_matrix_op):
""" QAOA test """
seed = 0
aqua_globals.random_seed = seed
self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob,
w)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, offset = max_cut.get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer, prob, mixer=m, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
self.log.debug('energy: %s', result.eigenvalue.real)
self.log.debug('time: %s', result.optimizer_time)
self.log.debug('maxcut objective: %s',
result.eigenvalue.real + offset)
self.log.debug('solution: %s', graph_solution)
self.log.debug('solution objective: %s', max_cut.max_cut_value(x, w))
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_qaoa_qc_mixer(self, w, prob, solutions, convert_to_matrix_op):
""" QAOA test with a mixer as a parameterized circuit"""
seed = 0
aqua_globals.random_seed = seed
self.log.debug(
'Testing %s-step QAOA with MaxCut on graph with '
'a mixer as a parameterized circuit\n%s', prob, w)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
theta = Parameter('θ')
mixer.rx(theta, range(num_qubits))
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer, prob, mixer=mixer, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_measurement_error_mitigation_qaoa(self):
"""measurement error mitigation test with QAOA"""
algorithm_globals.random_seed = 167
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend("aer_simulator")
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
)
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5,
0.5,
seed=algorithm_globals.random_seed))
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(
optimizer=COBYLA(maxiter=1),
quantum_instance=quantum_instance,
initial_point=np.asarray([0.0, 0.0]),
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, 3.49, delta=0.05)
def test_qaoa_qc_mixer(self, w, prob, solutions, convert_to_matrix_op):
"""QAOA test with a mixer as a parameterized circuit"""
self.log.debug(
"Testing %s-step QAOA with MaxCut on graph with a mixer as a parameterized circuit\n%s",
prob,
w,
)
optimizer = COBYLA()
qubit_op, _ = self._get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
theta = Parameter("θ")
mixer.rx(theta, range(num_qubits))
qaoa = QAOA(optimizer,
prob,
mixer=mixer,
quantum_instance=self.statevector_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, solutions)
def test_qaoa_random_initial_point(self):
""" QAOA random initial point """
w = nx.adjacency_matrix(
nx.fast_gnp_random_graph(5, 0.5, seed=algorithm_globals.random_seed)).toarray()
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(optimizer=NELDER_MEAD(disp=True), reps=1, quantum_instance=self.qasm_simulator)
_ = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
np.testing.assert_almost_equal([-0.879, 0.395], qaoa.optimal_params, decimal=3)
def test_qaoa_random_initial_point(self):
"""QAOA random initial point"""
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5, 0.5, seed=algorithm_globals.random_seed)
)
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(optimizer=NELDER_MEAD(disp=True), reps=1, quantum_instance=self.qasm_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
self.assertLess(result.eigenvalue, -0.97)
def test_optimizer_scipy_callable(self):
"""Test passing a SciPy optimizer directly as callable."""
qaoa = QAOA(
optimizer=partial(scipy_minimize,
method="Nelder-Mead",
options={"maxiter": 2}),
quantum_instance=self.statevector_simulator,
)
result = qaoa.compute_minimum_eigenvalue(Z)
self.assertEqual(result.cost_function_evals, 4)
def test_qaoa_qc_mixer_no_parameters(self):
""" QAOA test with a mixer as a parameterized circuit with zero parameters. """
qubit_op, _ = self._get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
# just arbitrary circuit
mixer.rx(np.pi/2, range(num_qubits))
qaoa = QAOA(COBYLA(), reps=1, mixer=mixer, quantum_instance=self.statevector_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
# we just assert that we get a result, it is not meaningful.
self.assertIsNotNone(result.eigenstate)
def test_qaoa(self, w, prob, m, solutions, convert_to_matrix_op):
""" QAOA test """
self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob, w)
qubit_op, _ = self._get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
qaoa = QAOA(COBYLA(), prob, mixer=m, quantum_instance=self.statevector_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, solutions)
def test_simple_qubo(self):
"""Test on a simple QUBO problem."""
model = Model()
# pylint:disable=invalid-name
u = model.binary_var(name="u")
v = model.binary_var(name="v")
model.minimize((u - v + 2)**2)
problem = QuadraticProgram()
problem.from_docplex(model)
backend = BasicAer.get_backend("statevector_simulator")
qaoa = QAOA(quantum_instance=backend, reps=1)
optimizer = WarmStartQAOAOptimizer(
pre_solver=SlsqpOptimizer(),
relax_for_pre_solver=True,
qaoa=qaoa,
epsilon=0.25,
)
result_warm = optimizer.solve(problem)
self.assertIsNotNone(result_warm)
self.assertIsNotNone(result_warm.x)
np.testing.assert_almost_equal([0, 1], result_warm.x, 3)
self.assertIsNotNone(result_warm.fval)
np.testing.assert_almost_equal(1, result_warm.fval, 3)
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 test_max_cut(self):
"""Basic test on the max cut problem."""
graph = np.array([
[0.0, 1.0, 2.0, 0.0],
[1.0, 0.0, 1.0, 0.0],
[2.0, 1.0, 0.0, 1.0],
[0.0, 0.0, 1.0, 0.0],
])
presolver = GoemansWilliamsonOptimizer(num_cuts=10)
problem = Maxcut(graph).to_quadratic_program()
backend = BasicAer.get_backend("statevector_simulator")
qaoa = QAOA(quantum_instance=backend, reps=1)
aggregator = MeanAggregator()
optimizer = WarmStartQAOAOptimizer(
pre_solver=presolver,
relax_for_pre_solver=False,
qaoa=qaoa,
epsilon=0.25,
num_initial_solutions=10,
aggregator=aggregator,
converters=[],
)
result_warm = optimizer.solve(problem)
self.assertIsNotNone(result_warm)
self.assertIsNotNone(result_warm.x)
np.testing.assert_almost_equal([0, 0, 1, 0], result_warm.x, 3)
self.assertIsNotNone(result_warm.fval)
np.testing.assert_almost_equal(4, result_warm.fval, 3)
def test_constrained_binary(self):
"""Constrained binary optimization problem."""
model = Model()
v = model.binary_var(name="v")
w = model.binary_var(name="w")
# pylint:disable=invalid-name
t = model.binary_var(name="t")
model.minimize(v + w + t)
model.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
model.add_constraint(v + w + t >= 2, "cons2")
problem = QuadraticProgram()
problem.from_docplex(model)
backend = BasicAer.get_backend("statevector_simulator")
qaoa = QAOA(quantum_instance=backend, reps=1)
aggregator = MeanAggregator()
optimizer = WarmStartQAOAOptimizer(
pre_solver=SlsqpOptimizer(),
relax_for_pre_solver=True,
qaoa=qaoa,
epsilon=0.25,
aggregator=aggregator,
)
result_warm = optimizer.solve(problem)
self.assertIsNotNone(result_warm)
self.assertIsNotNone(result_warm.x)
np.testing.assert_almost_equal([1, 0, 1], result_warm.x, 3)
self.assertIsNotNone(result_warm.fval)
np.testing.assert_almost_equal(2, result_warm.fval, 3)
def test_portfolio_qaoa(self):
""" portfolio test with QAOA """
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
qaoa = QAOA(optimizer=COBYLA(maxiter=500),
initial_point=[0., 0.],
quantum_instance=quantum_instance)
result = qaoa.compute_minimum_eigenvalue(operator=self.qubit_op)
selection = OptimizationApplication.sample_most_likely(
result.eigenstate)
value = portfolio.portfolio_value(selection, self.muu, self.sigma,
self.risk, self.budget, self.penalty)
np.testing.assert_array_equal(selection, [0, 1, 1, 0])
self.assertAlmostEqual(value, -0.00679917)
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_max_cut(self):
"""Basic test on the max cut problem."""
try:
graph = np.array([[0., 1., 2., 0.], [1., 0., 1., 0.],
[2., 1., 0., 1.], [0., 0., 1., 0.]])
presolver = GoemansWilliamsonOptimizer(num_cuts=10)
problem = max_cut_qp(graph)
backend = BasicAer.get_backend("statevector_simulator")
qaoa = QAOA(quantum_instance=backend, reps=1)
aggregator = MeanAggregator()
optimizer = WarmStartQAOAOptimizer(pre_solver=presolver,
relax_for_pre_solver=False,
qaoa=qaoa,
epsilon=0.25,
num_initial_solutions=10,
aggregator=aggregator)
result_warm = optimizer.solve(problem)
self.assertIsNotNone(result_warm)
self.assertIsNotNone(result_warm.x)
np.testing.assert_almost_equal([0, 0, 1, 0], result_warm.x, 3)
self.assertIsNotNone(result_warm.fval)
np.testing.assert_almost_equal(4, result_warm.fval, 3)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_qaoa_qc_mixer_many_parameters(self):
""" QAOA test with a mixer as a parameterized circuit with the num of parameters > 1. """
optimizer = COBYLA()
qubit_op, _ = self._get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
for i in range(num_qubits):
theta = Parameter('θ' + str(i))
mixer.rx(theta, range(num_qubits))
qaoa = QAOA(optimizer, reps=2, mixer=mixer, quantum_instance=self.statevector_simulator)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
self.log.debug(x)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, S1)
def test_qaoa_random_initial_point(self):
""" QAOA random initial point """
aqua_globals.random_seed = 10598
w = nx.adjacency_matrix(
nx.fast_gnp_random_graph(5, 0.5,
seed=aqua_globals.random_seed)).toarray()
qubit_op, _ = max_cut.get_operator(w)
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed,
shots=4096)
qaoa = QAOA(optimizer=NELDER_MEAD(disp=True),
p=1,
quantum_instance=q_i)
_ = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
np.testing.assert_almost_equal([-0.8792, 0.3948],
qaoa.optimal_params,
decimal=4)
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_qaoa_qc_mixer_no_parameters(self):
""" QAOA test with a mixer as a parameterized circuit with zero parameters. """
seed = 0
aqua_globals.random_seed = seed
qubit_op, _ = max_cut.get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
# just arbitrary circuit
mixer.rx(np.pi / 2, range(num_qubits))
backend = BasicAer.get_backend('statevector_simulator')
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer=COBYLA(), p=1, mixer=mixer, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
# we just assert that we get a result, it is not meaningful.
self.assertIsNotNone(result.eigenstate)
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)
def disabled_test_qaoa_initial_state(self, w, init_state):
""" QAOA initial state test """
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
init_pt = [0.0, 0.0] # Avoid generating random initial point
if init_state is None:
initial_state = None
else:
initial_state = QuantumCircuit(QuantumRegister(4))
initial_state.initialize(init_state, initial_state.qubits)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'))
zero_init_state = QuantumCircuit(QuantumRegister(qubit_op.num_qubits))
qaoa_zero_init_state = QAOA(optimizer=optimizer,
initial_state=zero_init_state,
initial_point=init_pt,
quantum_instance=quantum_instance)
qaoa = QAOA(optimizer=optimizer,
initial_state=initial_state,
initial_point=init_pt,
quantum_instance=quantum_instance)
zero_circuits = qaoa_zero_init_state.construct_circuit(
init_pt, qubit_op)
custom_circuits = qaoa.construct_circuit(init_pt, qubit_op)
self.assertEqual(len(zero_circuits), len(custom_circuits))
backend = BasicAer.get_backend('statevector_simulator')
for zero_circ, custom_circ in zip(zero_circuits, custom_circuits):
z_length = len(zero_circ.data)
c_length = len(custom_circ.data)
self.assertGreaterEqual(c_length, z_length)
self.assertTrue(zero_circ.data == custom_circ.data[-z_length:])
custom_init_qc = custom_circ.copy()
custom_init_qc.data = custom_init_qc.data[0:c_length - z_length]
if initial_state is None:
original_init_qc = QuantumCircuit(qubit_op.num_qubits)
original_init_qc.h(range(qubit_op.num_qubits))
else:
original_init_qc = initial_state.construct_circuit()
job_init_state = execute(original_init_qc, backend)
job_qaoa_init_state = execute(custom_init_qc, backend)
statevector_original = job_init_state.result().get_statevector(
original_init_qc)
statevector_custom = job_qaoa_init_state.result().get_statevector(
custom_init_qc)
self.assertEqual(statevector_original.tolist(),
statevector_custom.tolist())
def test_qaoa_initial_point(self, w, solutions, init_pt):
""" Check first parameter value used is initial point as expected """
aqua_globals.random_seed = 10598
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
first_pt = []
def cb_callback(eval_count, parameters, mean, std):
nonlocal first_pt
if eval_count == 1:
first_pt = list(parameters)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa = QAOA(optimizer,
initial_point=init_pt,
callback=cb_callback,
quantum_instance=quantum_instance)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest('Initial Point'):
# If None the preferred random initial point of QAOA variational form
if init_pt is None:
np.testing.assert_almost_equal([-0.2398, 0.3378],
first_pt,
decimal=4)
else:
self.assertListEqual(init_pt, first_pt)
with self.subTest('Solution'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_qaoa(self, w, prob, m, solutions, convert_to_matrix_op):
""" QAOA test """
seed = 0
algorithm_globals.random_seed = seed
self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob,
w)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, _ = self._get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer, prob, mixer=m, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
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_change_operator_size(self):
""" QAOA change operator size test """
aqua_globals.random_seed = 0
qubit_op, _ = max_cut.get_operator(
np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]]))
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa = QAOA(COBYLA(), 1, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest(msg='QAOA 4x4'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
{'0101', '1010'})
try:
qubit_op, _ = max_cut.get_operator(
np.array([
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
]))
except Exception as ex: # pylint: disable=broad-except
self.fail("Failed to change operator. Error: '{}'".format(str(ex)))
return
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest(msg='QAOA 6x6'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
{'010101', '101010'})
def test_qaoa_initial_state(self, w, init_state):
"""QAOA initial state test"""
optimizer = COBYLA()
qubit_op, _ = self._get_operator(w)
init_pt = np.asarray([0.0, 0.0]) # Avoid generating random initial point
if init_state is None:
initial_state = None
else:
initial_state = QuantumCircuit(QuantumRegister(4, "q"))
initial_state.initialize(init_state, initial_state.qubits)
zero_init_state = QuantumCircuit(QuantumRegister(qubit_op.num_qubits, "q"))
qaoa_zero_init_state = QAOA(
optimizer=optimizer,
initial_state=zero_init_state,
initial_point=init_pt,
quantum_instance=self.statevector_simulator,
)
qaoa = QAOA(
optimizer=optimizer,
initial_state=initial_state,
initial_point=init_pt,
quantum_instance=self.statevector_simulator,
)
zero_circuits = qaoa_zero_init_state.construct_circuit(init_pt, qubit_op)
custom_circuits = qaoa.construct_circuit(init_pt, qubit_op)
self.assertEqual(len(zero_circuits), len(custom_circuits))
for zero_circ, custom_circ in zip(zero_circuits, custom_circuits):
z_length = len(zero_circ.data)
c_length = len(custom_circ.data)
self.assertGreaterEqual(c_length, z_length)
self.assertTrue(zero_circ.data == custom_circ.data[-z_length:])
custom_init_qc = QuantumCircuit(custom_circ.num_qubits)
custom_init_qc.data = custom_circ.data[0 : c_length - z_length]
if initial_state is None:
original_init_qc = QuantumCircuit(qubit_op.num_qubits)
original_init_qc.h(range(qubit_op.num_qubits))
else:
original_init_qc = initial_state
job_init_state = self.statevector_simulator.execute(original_init_qc)
job_qaoa_init_state = self.statevector_simulator.execute(custom_init_qc)
statevector_original = job_init_state.get_statevector(original_init_qc)
statevector_custom = job_qaoa_init_state.get_statevector(custom_init_qc)
self.assertListEqual(statevector_original.tolist(), statevector_custom.tolist())
