def makeCircuit7(graph, n, edges, cedges, gammasbetas, p, orderings):
cgraph = nx.complement(graph)
ans = ClassicalRegister(n)
sol = QuantumRegister(n)
QAOA = QuantumCircuit(sol, ans)
for j in range(p):
for i in range(n):
QAOA.u1(-gammasbetas[j], i)
for i in orderings[j]:
nbrs = 0
nbs = []
for nbr in cgraph[i]:
QAOA.x(nbr)
nbrs += 1
nbs.append(nbr)
nbs.append(i)
if (nbrs != 0):
gate = MCMT(RXGate(-2 * gammasbetas[p + j]), nbrs, 1)
QAOA.append(gate, nbs)
else:
QAOA.rx(-2 * gammasbetas[p + j], i)
for nbr in cgraph[i]:
QAOA.x(nbr)
return QAOA
def makeCircuit6(graph, n, edges, cedges, gammasbetas, p):
cgraph = nx.complement(graph)
ans = ClassicalRegister(n)
sol = QuantumRegister(n)
QAOA = QuantumCircuit(sol, ans)
r = 2
for j in range(p):
for i in range(n):
QAOA.u1(-gammasbetas[j], i)
for l in range(r):
for i in range(n):
nbrs = 0
nbs = []
for nbr in cgraph[i]:
QAOA.x(nbr)
nbrs += 1
nbs.append(nbr)
nbs.append(i)
if (nbrs != 0):
#gate = MCMT(RXGate(gammasbetas[p+j]/r),nbrs ,1)
gate = MCMT(RXGate(2 * gammasbetas[l + j] / r), nbrs, 1)
QAOA.append(gate, nbs)
else:
#QAOA.rx(gammasbetas[p+j]/r,i)
QAOA.rx(2 * gammasbetas[l + j] / r, i)
for nbr in cgraph[i]:
QAOA.x(nbr)
return QAOA
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)
qubit_op = qubit_op.to_opflow()
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
qaoa = QAOA(qubit_op, optimizer, prob, mixer=m)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
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(self, w, p, m, solutions):
os.environ.pop('QISKIT_AQUA_CIRCUIT_CACHE', None)
self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format(
p, w))
np.random.seed(0)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, offset = max_cut.get_max_cut_qubitops(w)
qaoa = QAOA(qubit_op, optimizer, p, mixer=m)
# TODO: cache fails for QAOA since we construct the evolution circuit via instruction
quantum_instance = QuantumInstance(backend, circuit_caching=False)
result = qaoa.run(quantum_instance)
x = max_cut.sample_most_likely(result['eigvecs'][0])
graph_solution = max_cut.get_graph_solution(x)
self.log.debug('energy: {}'.format(result['energy']))
self.log.debug('time: {}'.format(result['eval_time']))
self.log.debug('maxcut objective: {}'.format(result['energy'] +
offset))
self.log.debug('solution: {}'.format(graph_solution))
self.log.debug('solution objective: {}'.format(
max_cut.max_cut_value(x, w)))
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
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)
qubit_op = qubit_op.to_opflow()
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(qubit_op, optimizer=optimizer, p=2, mixer=mixer)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result.eigenstate)
print(x)
graph_solution = max_cut.get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]), S1)
def run_IBM(H=None,
backend=None,
num_samples=100,
qaoa_steps=3,
variables=None):
num_vars = len(list(H.linear))
qubit_op, offset = get_ising_opt_qubitops(H, variables)
if backend == None:
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
spsa = SPSA(max_trials=10)
qaoa = QAOA(qubit_op, spsa, qaoa_steps)
result = qaoa.run(quantum_instance)
circ = qaoa.get_optimal_circuit()
q = circ.qregs[0]
c = ClassicalRegister(num_vars, 'c')
circ.cregs.append(c)
circ.measure(q, c)
job = execute(circ, backend, shots=num_samples, memory=True)
return job.result().get_counts(circ)
def test_qaoa(self, w, p, m, solutions):
self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format(
p, w))
np.random.seed(0)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubitOp, offset = max_cut.get_max_cut_qubitops(w)
qaoa = QAOA(qubitOp, optimizer, p, operator_mode='matrix', mixer=m)
quantum_instance = QuantumInstance(backend)
result = qaoa.run(quantum_instance)
x = max_cut.sample_most_likely(result['eigvecs'][0])
graph_solution = max_cut.get_graph_solution(x)
self.log.debug('energy: {}'.format(result['energy']))
self.log.debug('time: {}'.format(result['eval_time']))
self.log.debug('maxcut objective: {}'.format(result['energy'] +
offset))
self.log.debug('solution: {}'.format(graph_solution))
self.log.debug('solution objective: {}'.format(
max_cut.max_cut_value(x, w)))
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_qaoa_initial_point(self, w, solutions, init_pt):
""" Check first parameter value used is initial point as expected """
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'))
qaoa = QAOA(qubit_op,
optimizer,
initial_point=init_pt,
callback=cb_callback,
quantum_instance=quantum_instance)
result = qaoa.compute_minimum_eigenvalue()
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
if init_pt is None: # If None the preferred initial point of QAOA variational form
init_pt = [0.0,
0.0] # i.e. 0,0 should come through as the first point
with self.subTest('Initial Point'):
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):
""" QAOA test """
seed = 0
aqua_globals.random_seed = seed
os.environ.pop('QISKIT_AQUA_CIRCUIT_CACHE', None)
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_qubit_op(w)
qaoa = QAOA(qubit_op, optimizer, prob, mixer=m)
# TODO: cache fails for QAOA since we construct the evolution circuit via instruction
quantum_instance = QuantumInstance(backend,
circuit_caching=False,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result['eigvecs'][0])
graph_solution = max_cut.get_graph_solution(x)
self.log.debug('energy: %s', result['energy'])
self.log.debug('time: %s', result['eval_time'])
self.log.debug('maxcut objective: %s', result['energy'] + 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)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
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)
qubit_op = qubit_op.to_opflow()
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(qubit_op, optimizer, prob, mixer=mixer)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
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 run_simulation(self, backend):
seed = int(os.environ.get("SEED", "40598"))
n = int(os.environ.get("N", "4"))
#
# Random 3-regular graph with 12 nodes
#
graph = nx.random_regular_graph(3, n, seed=seed)
for e in graph.edges():
graph[e[0]][e[1]]["weight"] = 1.0
# Compute the weight matrix from the graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
# Create an Ising Hamiltonian with docplex.
mdl = Model(name="max_cut")
mdl.node_vars = mdl.binary_var_list(list(range(n)), name="node")
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] *
(1 - mdl.node_vars[j]) for i in range(n)
for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
aqua_globals.random_seed = seed
# Run quantum algorithm QAOA on qasm simulator
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=5, max_evals_grouped=4)
quantum_instance = QuantumInstance(
backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0,
)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result["eigvecs"][0])
result["solution"] = max_cut.get_graph_solution(x)
result["solution_objective"] = max_cut.max_cut_value(x, w)
result["maxcut_objective"] = result["energy"] + offset
"""
print("energy:", result["energy"])
print("time:", result["eval_time"])
print("max-cut objective:", result["energy"] + offset)
print("solution:", max_cut.get_graph_solution(x))
print("solution objective:", max_cut.max_cut_value(x, w))
"""
return result
def test_portfolio_qaoa(self):
""" portfolio test with QAOA """
qaoa = QAOA(self.qubit_op, COBYLA(maxiter=500), initial_point=[0., 0.])
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = qaoa.run(quantum_instance)
selection = 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_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# Fix the random seed of SPSA (Optional)
from qiskit.aqua import aqua_globals
aqua_globals.random_seed = 123
# --- 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.aqua.algorithms import QAOA
from qiskit.aqua.components.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
# ----------------------------------------------------------------------
np.testing.assert_array_almost_equal(result.x, [1, 0, 1, 0])
self.assertAlmostEqual(result.fval, 4.0)
def objective(params):
aqua_globals.random_seed = 10598
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa_mes = QAOA(quantum_instance=quantum_instance,operator = qubitOp,p=n_layers,initial_point= params)
circuit2 = QuantumCircuit(n**2)
circuit = qaoa_mes.construct_circuit(params)
#create measurements on classical register
reg = ClassicalRegister(n**2)
circuit[0].add_register(reg)
circuit[0].measure(range(n**2),range(n**2))
# Execution of circuit(either simulation or on real quantum machines)
backend = Aer.get_backend("qasm_simulator")
shots = 1024
simulate = execute(circuit[0], backend=backend, shots=shots)
QAOA_results = simulate.result()
val = 0
# Evaluate the data from the simulator
counts = QAOA_results.get_counts()
expectedCost = 0
maxCost = [0,0]
hist = {}
for sample in list(counts.keys()):
# use sampled bit string x to compute C(x)
x2 = [int(num) for num in list(sample)]
tmp_eng = cost_function_C(x2)
# compute the expectation value and energy distribution
expectedCost = expectedCost + counts[sample]*tmp_eng
return expectedCost/shots; #/(shots);
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)
qaoa = QAOA(qubit_op, NELDER_MEAD(disp=True), 1)
quantum_instance = QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed,
shots=4096)
_ = qaoa.run(quantum_instance)
np.testing.assert_almost_equal([2.5179, 0.3528],
qaoa.optimal_params,
decimal=4)
def create_qiskit_circuit(num_nodes: int,
params: List[float],
edge_prob=0.8,
weight_range=10) -> qiskit.QuantumCircuit:
# print(locals())
np.random.seed(123)
w = random_graph(num_nodes, edge_prob=edge_prob, weight_range=weight_range)
qubit_op, offset = vertex_cover.get_operator(w)
qaoa = QAOA(qubit_op, p=int(len(params) / 2))
return qaoa.var_form.construct_circuit(params)
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 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)
qubit_op = qubit_op.to_opflow()
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
# just arbitrary circuit
mixer.rx(np.pi / 2, range(num_qubits))
qaoa = QAOA(qubit_op, optimizer=COBYLA(), p=1, mixer=mixer)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
# we just assert that we get a result, it is not meaningful.
self.assertIsNotNone(result.eigenstate)
def simulate_optimize(n_shots, p_steps, qubitOp, G):
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=n_shots)
qaoa = QAOA(qubitOp, ESCH(max_evals=100), p=p_steps)
result = qaoa.run(quantum_instance)
# QAOA converts the problem into finding the maximum eigenval/eigenvec pair
solution = max_cut.sample_most_likely(
result['eigvecs'][0]) #returns vector with highest counts
#print('energy:', result['energy'])
print('solution:', solution)
# For p steps, there should be 2*p parameters (beta,gamma)
#print('optimal parameters', result['opt_params'])
cost = 0
for i in range(len(G.nodes)):
for j in range(len(G.nodes)):
cost = cost + adj[i, j] * solution[i] * (1 - solution[j])
print("Sample profit = {}".format(cost))
return result, solution
def 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 = Custom(num_qubits=4, state_vector=init_state)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'))
qaoa_zero_init_state = QAOA(qubit_op,
optimizer,
initial_point=init_pt,
initial_state=Zero(qubit_op.num_qubits),
quantum_instance=quantum_instance)
qaoa = QAOA(qubit_op,
optimizer,
initial_point=init_pt,
initial_state=initial_state,
quantum_instance=quantum_instance)
zero_circuits = qaoa_zero_init_state.construct_circuit(init_pt)
custom_circuits = qaoa.construct_circuit(init_pt)
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(qubit_op,
optimizer,
initial_point=init_pt,
callback=cb_callback,
quantum_instance=quantum_instance)
result = qaoa.compute_minimum_eigenvalue()
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([1.5108, 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_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]]))
qaoa = QAOA(qubit_op.to_opflow(), COBYLA(), 1)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = qaoa.run(quantum_instance)
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],
]))
qaoa.operator = qubit_op.to_opflow()
except Exception as ex: # pylint: disable=broad-except
self.fail("Failed to change operator. Error: '{}'".format(str(ex)))
return
result = qaoa.run()
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 setUp(self):
super().setUp()
self.resource_path = './test/optimization/resources/'
# 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 makeCircuit5(graph, n, edges, cedges, gammasbetas, p):
cgraph = nx.complement(graph)
ans = ClassicalRegister(n)
sol = QuantumRegister(n)
QAOA = QuantumCircuit(sol, ans)
k = 1
#dickestate
for i in range(n - 1, n - k - 1, -1):
QAOA.x(i)
for l in range(n, k, -1):
scs(l, k, QAOA, n)
for l in range(k, 1, -1):
scs(l, l - 1, QAOA, n)
#mixer and phaseseparation
for j in range(p):
for i in range(n):
QAOA.u1(-gammasbetas[j], i)
for i in range(n):
nbrs = 0
nbs = []
for nbr in cgraph[i]:
QAOA.x(nbr)
nbrs += 1
nbs.append(nbr)
nbs.append(i)
if (nbrs != 0):
gate = MCMT(RXGate(gammasbetas[p + j]), nbrs, 1)
QAOA.append(gate, nbs)
#else:
#warum habe ich das ausgeklammert? Testen ob es besser ist?
#QAOA.rx(gammasbetas[p+j],i)
for nbr in cgraph[i]:
QAOA.x(nbr)
return QAOA
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_change_operator_size(self):
""" QAOA test """
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA(maxiter=2)
qubit_op, _ = max_cut.get_operator(W1)
qubit_op = qubit_op.to_opflow().to_matrix_op()
seed = 0
aqua_globals.random_seed = seed
qaoa = QAOA(qubit_op, optimizer, P1)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa.run(quantum_instance)
qaoa.operator = (X ^ qubit_op ^ Z)
qaoa.run()
def get_qaoa():
"""
Takes care of setting up qiskit aqua's qaoa implementation
with specific parameters
Args:
Returns:
Built QAOA object from qiskit aqua (c.f qiskit's github for more
info)
"""
size = 2
n_sys = size * 2
T = 1000
weights = np.array([[0, 1], [0, 0]])
p = 2
hamilt = ising_hamiltonian(weights, size, n_sys)
qreg = QuantumRegister(n_sys)
initial_state = prepare_init_state(T, qreg, size, n_sys)
qaoa = QAOA(hamilt, COBYLA(), p, initial_state)
return qaoa
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)
print("Qubits needed: ", qubitOp.num_qubits)
#print(qubitOp.print_details())
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
# Create QUBO based on qubitOp from the TSP
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
admm_params = ADMMParameters(
rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=True, tol=1.e-6)
qubo_optimizer = MinimumEigenOptimizer(QAOA(quantum_instance=backend))
convex_optimizer = CobylaOptimizer()
admm = ADMMOptimizer(params=admm_params,
qubo_optimizer=qubo_optimizer,
continuous_optimizer=convex_optimizer)
quantum_instance = QuantumInstance(backend)
result = admm.solve(qp)
print(result)
def libraryoptimize(qubo,
edges,
cedges,
n,
p,
plotoptangles=False,
modulo=False):
if (qubo == "qubo1"):
H = makeNPMatrix1(edges, cedges, n)
if (qubo == "qubo2"):
H = makeNPMatrix2(edges, cedges, n)
if (qubo == "qubo3"):
H = makeNPMatrix2(edges, cedges, n)
optimizer = COBYLA()
qaoa_mes = QAOA(H,
p=p,
optimizer=optimizer,
quantum_instance=Aer.get_backend('statevector_simulator'))
results = qaoa_mes.run()
qc1 = qaoa_mes.get_optimal_circuit()
print(type(results.optimal_parameters))
print(type(results.optimal_parameters.items()))
i = 0
for key, value in results.optimal_parameters.items():
if (i == 0):
gamma = value
i += 1
else:
beta = value
print("beta", beta)
print("gamma", gamma)
print('optimal params: ', results.optimal_parameters)
print('optimal value: ', results.optimal_value)
qcl = qaoa_mes.get_optimal_circuit()
optgammasbetas = []
isgamma = 0
for key, value in results.optimal_parameters.items():
if (modulo):
if (isgamma < p):
optgammasbetas.append(value % (2 * math.pi))
isgamma += 1
else:
optgammasbetas.append(value % (math.pi))
else:
optgammasbetas.append(value)
if (plotoptangles):
plottheoptangles(optgammasbetas, p)
if (qubo == "qubo1"):
qc = makeCircuit1(n, edges, cedges, optgammasbetas, p)
if (qubo == "qubo2"):
qc = makeCircuit2(n, edges, cedges, optgammasbetas, p)
if (qubo == "qubo3"):
qc = makeCircuit3(n, edges, cedges, optgammasbetas, p)
ans = ClassicalRegister(n)
sol = QuantumRegister(n)
QAOA2 = QuantumCircuit(sol, ans)
QAOA2.append(qc1, range(n))
return qc, optgammasbetas
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
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 docplex.mp.model import Model
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import SPSA
from qiskit.optimization.applications.ising import docplex, max_cut
from qiskit.optimization.applications.ising.common import sample_most_likely
# 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 = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp['weight']
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(n)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] *
(1 - mdl.node_vars[j]) for i in range(n)
for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
# Run quantum algorithm QAOA on qasm simulator
seed = 40598
aqua_globals.random_seed = seed
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=5)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result.eigenstate)
print('energy:', result.eigenvalue.real)
print('time:', result.optimizer_time)
print('max-cut objective:', result.eigenvalue.real + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
# ----------------------------------------------------------------------
self.assertListEqual(
max_cut.get_graph_solution(x).tolist(), [1, 0, 1, 0])
self.assertAlmostEqual(max_cut.max_cut_value(x, w), 4.0)
