def test_maxcut_qaoa_large(self):
G = nx.random_regular_graph(3, 20, seed=1)
w = nx.adjacency_matrix(G, nodelist=range(G.number_of_nodes()))
obj = partial(maxcut_obj, w=w)
C, offset = get_maxcut_operator(w)
start = time.time()
varopt = VariationalQuantumOptimizerSequential(
obj,
'COBYLA',
initial_point=np.zeros(2),
optimizer_parameters={
'maxiter': 1,
'disp': True
},
varform_description={
'name': 'QAOA',
'p': 1,
'cost_operator': C,
'num_qubits': G.number_of_nodes()
},
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'qasm_simulator'
},
problem_description={
'offset': offset,
'do_not_check_cost_operator': True
},
execute_parameters=self.execute_parameters)
res = varopt.optimize()
end = time.time()
self.assertTrue(end - start < 1)
def test_qaoa_pass_mixer(self):
w = np.array([[0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0]])
C, offset = get_maxcut_operator(w)
var_form_operator_mix = VarForm(varform_description={
'name': 'QAOA',
'p': 2,
'cost_operator': C,
'num_qubits': 4
})
# build initial state circuit
initial_state_circuit = QuantumCircuit(4)
initial_state_circuit.u2(0, np.pi, range(4))
# build transverse field mixer circuit
mixer_circuit = QuantumCircuit(4)
beta = Parameter('beta')
for q1 in range(4):
mixer_circuit.h(q1)
mixer_circuit.rz(2 * beta, q1)
mixer_circuit.h(q1)
# pass it to variational form
var_form_circuit_mix = VarForm(
varform_description={
'name': 'QAOA',
'p': 2,
'cost_operator': C,
'num_qubits': 4,
'use_mixer_circuit': True,
'mixer_circuit': mixer_circuit,
'initial_state_circuit': initial_state_circuit
})
self.assertEqual(var_form_operator_mix.num_parameters,
var_form_circuit_mix.num_parameters)
parameters = np.random.uniform(0, np.pi,
var_form_operator_mix.num_parameters)
sv_operator_mix = var_form_operator_mix.run(parameters,
backend_description={
'package':
'qiskit',
'provider':
'Aer',
'name':
'statevector_simulator'
},
execute_parameters={})
sv_circuit_mix = var_form_circuit_mix.run(parameters,
backend_description={
'package':
'qiskit',
'provider':
'Aer',
'name':
'statevector_simulator'
},
execute_parameters={})
# check that the two statevectors are equal up to global phase
phase_diff = sv_circuit_mix / sv_operator_mix
self.assertTrue(
np.allclose(phase_diff, np.full(phase_diff.shape, phase_diff[0])))
def test_maxcut_qaoa_smooth(self):
import logging
logging.disable(logging.CRITICAL)
C, offset = get_maxcut_operator(self.w)
varopt = VariationalQuantumOptimizerSequential(
self.obj,
'COBYLA',
initial_point=[np.pi / 4, 0, 0, np.pi / 2],
optimizer_parameters=self.optimizer_parameters,
varform_description={
'name': 'QAOA',
'p': 15,
'cost_operator': C,
'num_qubits': 4
},
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'statevector_simulator'
},
problem_description={
'offset': offset,
'smooth_schedule': True
},
execute_parameters=self.execute_parameters)
res = varopt.optimize()
self.assertTrue(res['min_val'] < -3.5)
logging.disable(logging.NOTSET)
def test_maxcut_qaoa_sv(self):
import logging
logging.disable(logging.CRITICAL)
C, offset = get_maxcut_operator(self.w)
varopt = VariationalQuantumOptimizerSequential(
self.obj,
'COBYLA',
optimizer_parameters=self.optimizer_parameters,
varform_description={
'name': 'QAOA',
'p': 2,
'cost_operator': C,
'num_qubits': 4
},
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'statevector_simulator'
},
problem_description={'offset': offset},
execute_parameters=self.execute_parameters)
varopt.optimize()
res = varopt.get_optimal_solution()
self.assertEqual(res[0], -4)
self.assertTrue(
np.array_equal(res[1], np.array([1, 0, 0, 1]))
or np.array_equal(res[1], np.array([0, 1, 1, 0])))
logging.disable(logging.NOTSET)
def setUp(self):
self.varform_description = {'name':'RYRZ', 'num_qubits':4, 'depth':1}
self.backend_description={'package':'mpsbackend'}
self.execute_parameters={'shots':100}
self.w = np.array([[0,1,1,0],[1,0,1,1],[1,1,0,1],[0,1,1,0]])
self.obj = partial(maxcut_obj, w=self.w)
self.C, _ = get_maxcut_operator(self.w)
def test_precompute_obj_cost_ham(self):
w = nx.adjacency_matrix(self.G,
nodelist=range(self.G.number_of_nodes()))
C, offset = get_maxcut_operator(w)
cost_diag = cost_operator_to_vec(C, offset)
precomputed = precompute_obj(self.obj, self.G.number_of_nodes())
self.assertTrue(np.allclose(cost_diag, precomputed))
def test_qasm_sv_obj_peterson(self):
elist = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [0, 5], [1, 6], [2, 7], [3, 8], [4, 9], [5, 7], [5, 8], [6, 8], [6, 9], [7, 9]]
G = nx.OrderedGraph()
G.add_edges_from(elist)
def obj_f_cut(x):
cut = 0
for i, j in G.edges():
if x[i] != x[j]:
# the edge is cut
cut -= 1
return cut
w = nx.adjacency_matrix(G, nodelist=range(10)).toarray()
obj = partial(maxcut_obj,w=w)
C, _ = get_maxcut_operator(w)
brute_force_opt_imported, _ = brute_force(obj, G.number_of_nodes())
brute_force_opt_custom, _ = brute_force(obj_f_cut, G.number_of_nodes())
self.assertEqual(brute_force_opt_imported, brute_force_opt_custom)
obj_sv = ObjectiveWrapper(obj,
varform_description={'name':'QAOA', 'p':9, 'num_qubits':10, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'statevector_simulator'},
objective_parameters={'save_resstrs':True},
execute_parameters={})
obj_qasm = ObjectiveWrapper(obj,
varform_description={'name':'QAOA', 'p':9, 'num_qubits':10, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'qasm_simulator'},
objective_parameters={'save_resstrs':True},
execute_parameters={'shots':10000})
obj_sv_custom = ObjectiveWrapper(obj_f_cut,
varform_description={'name':'QAOA', 'p':9, 'num_qubits':10, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'statevector_simulator'},
objective_parameters={'save_resstrs':True},
execute_parameters={})
obj_qasm_custom = ObjectiveWrapper(obj_f_cut,
varform_description={'name':'QAOA', 'p':9, 'num_qubits':10, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'qasm_simulator'},
objective_parameters={'save_resstrs':True},
execute_parameters={'shots':10000})
parameters = np.array([5.192253984583296, 5.144373231492732, 5.9438949617723775, 5.807748946652058, 3.533458907810596, 6.006206583282401, 6.122313961527631, 6.218468942101044, 6.227704753217614, 0.3895570099244132, -0.1809282325810937, 0.8844522327007089, 0.7916086532373585, 0.21294534589417236, 0.4328896243354414, 0.8327451563500539, 0.7694639329585451, 0.4727893829336214])
sv_imported = obj_sv.get_obj()(parameters)
resstrs_sv_imported = list(sorted(state_to_ampl_counts(obj_sv.resstrs[0],eps=0.01).items(), key=itemgetter(0)))
qasm_imported = obj_qasm.get_obj()(parameters)
resstrs_qasm_imported = list(("".join(str(x) for x in k),v) for k, v in Counter(tuple(x) for x in obj_qasm.resstrs[0]).items() if v > 5)
sv_custom = obj_sv_custom.get_obj()(parameters)
resstrs_sv_custom = list(sorted(state_to_ampl_counts(obj_sv_custom.resstrs[0],eps=0.01).items(), key=itemgetter(0)))
qasm_custom = obj_qasm_custom.get_obj()(parameters)
resstrs_qasm_custom = list(("".join(str(x) for x in k),v) for k, v in Counter(tuple(x) for x in obj_qasm_custom.resstrs[0]).items() if v > 5)
self.assertTrue(set(x[0] for x in resstrs_sv_imported) == set(x[0] for x in resstrs_sv_custom))
self.assertTrue(set(x[0] for x in resstrs_sv_imported) == set(x[0] for x in resstrs_qasm_imported))
self.assertTrue(set(x[0] for x in resstrs_sv_custom) == set(x[0] for x in resstrs_qasm_custom))
self.assertTrue(np.isclose(sv_imported, brute_force_opt_custom,rtol=0.01))
self.assertTrue(np.isclose(sv_imported, sv_custom))
self.assertTrue(np.isclose(sv_imported, qasm_imported, rtol=0.01))
self.assertTrue(np.isclose(sv_custom, qasm_custom, rtol=0.01))
def test_qaoa_maxcut(self):
w = np.array([[0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0]])
C, offset = get_maxcut_operator(w)
var_form = VarForm(varform_description={
'name': 'QAOA',
'p': 2,
'cost_operator': C,
'num_qubits': 4
})
parameters = np.random.uniform(0, np.pi, var_form.num_parameters)
execute_parameters = {'shots': 100}
resstrs = var_form.run(parameters,
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'qasm_simulator'
},
execute_parameters=execute_parameters)
self.assertEqual(len(resstrs), execute_parameters['shots'])
self.assertTrue(all(len(x) == 4 for x in resstrs))
def test_qasm_sv_obj_from_elist(self):
elist = [[3,1],[3,2],[0,1],[0,2],[1,2]]
G = nx.OrderedGraph()
G.add_edges_from(elist)
def obj_f_cut(x):
cut = 0
for i, j in G.edges():
if x[i] != x[j]:
# the edge is cut
cut -= 1
return cut
w = nx.adjacency_matrix(G, nodelist=range(4)).toarray()
obj = partial(maxcut_obj,w=w)
C, _ = get_maxcut_operator(w)
obj_sv = ObjectiveWrapper(obj,
varform_description={'name':'QAOA', 'p':10, 'num_qubits':4, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'statevector_simulator'},
execute_parameters={}).get_obj()
obj_qasm = ObjectiveWrapper(obj,
varform_description={'name':'QAOA', 'p':10, 'num_qubits':4, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'qasm_simulator'},
execute_parameters={'shots':10000}).get_obj()
obj_sv_custom = ObjectiveWrapper(obj_f_cut,
varform_description={'name':'QAOA', 'p':10, 'num_qubits':4, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'statevector_simulator'},
execute_parameters={}).get_obj()
obj_qasm_custom = ObjectiveWrapper(obj_f_cut,
varform_description={'name':'QAOA', 'p':10, 'num_qubits':4, 'cost_operator':C},
backend_description={'package':'qiskit', 'provider':'Aer', 'name':'qasm_simulator'},
execute_parameters={'shots':10000}).get_obj()
parameters = np.array([ 5.97337687, 2.58355601, 1.40698116, 1.41929411, -0.78430107,
-4.46418963, -0.61290647, -0.59975086, 0.48811492, 4.20269641,
-2.71558857, 2.82117292, 2.93922949, 2.06076731, 2.19543793,
2.42960372, -1.0079554 , 2.22741002, -1.06316475, 0.53106839])
sv_imported = obj_sv(parameters)
qasm_imported = obj_qasm(parameters)
sv_custom = obj_sv_custom(parameters)
qasm_custom = obj_qasm_custom(parameters)
self.assertTrue(np.isclose(sv_imported, sv_custom))
self.assertTrue(np.isclose(sv_imported, qasm_imported, rtol=0.01))
self.assertTrue(np.isclose(sv_custom, qasm_custom, rtol=0.01))
def simulate_qiskit_amps(G, gamma, beta):
assert len(gamma) == len(beta)
p = len(gamma)
w = nx.adjacency_matrix(G, nodelist=list(G.nodes())).toarray()
obj = partial(maxcut_obj, w=w)
C, _ = get_maxcut_operator(w)
parameters = np.concatenate([beta, -np.array(gamma)])
varform = QAOAVarForm(p=p, cost_operator=C)
circuit = varform.construct_circuit(parameters)
circuit_qiskit = transpile(circuit,
optimization_level=0,
basis_gates=['u1', 'u2', 'u3', 'cx'])
#print(circuit_qiskit)
sv = execute(circuit, backend=Aer.get_backend(
"statevector_simulator")).result().get_statevector()
res = -obj_from_statevector(sv, obj)
return res
def test_maxcut_qaoa_mixer_circuit(self):
import logging
logging.disable(logging.CRITICAL)
C, offset = get_maxcut_operator(self.w)
# build transverse field mixer circuit
mixer_circuit = QuantumCircuit(4)
beta = Parameter('beta')
for q1 in range(4):
mixer_circuit.h(q1)
mixer_circuit.rz(2 * beta, q1)
mixer_circuit.h(q1)
# pass it to variational quantum optimizer
varopt = VariationalQuantumOptimizerSequential(
self.obj,
'COBYLA',
optimizer_parameters=self.optimizer_parameters,
varform_description={
'name': 'QAOA',
'p': 2,
'cost_operator': C,
'num_qubits': 4,
'use_mixer_circuit': True,
'mixer_circuit': mixer_circuit
},
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'statevector_simulator'
},
problem_description={'offset': offset},
execute_parameters=self.execute_parameters)
varopt.optimize()
res = varopt.get_optimal_solution()
self.assertEqual(res[0], -4)
self.assertTrue(
np.array_equal(res[1], np.array([1, 0, 0, 1]))
or np.array_equal(res[1], np.array([0, 1, 1, 0])))
logging.disable(logging.NOTSET)
help="maximum depth to explore")
args = parser.parse_args()
#import logging; logging.basicConfig(level=logging.INFO)
# For testing purposes, hardcode Peterson graph
elist = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [0, 5], [1, 6], [2, 7],
[3, 8], [4, 9], [5, 7], [5, 8], [6, 8], [6, 9], [7, 9]]
G = nx.OrderedGraph()
G.add_edges_from(elist)
w = nx.adjacency_matrix(G)
obj_f_cut = partial(maxcut_obj, G=G)
C, _ = get_maxcut_operator(w)
lb = np.array([0, 0] * args.p)
ub = np.array([np.pi / 2] * args.p + [np.pi] * args.p)
np.random.seed(0)
init_theta = np.random.uniform(lb, ub)
obj_w = ObjectiveWrapper(obj_f_cut,
varform_description={
'name': 'QAOA',
'p': args.p,
'cost_operator': C,
'num_qubits': G.number_of_nodes()
},
backend_description={
def find_lowest_p(elist, maxiter, rtol):
G = nx.OrderedGraph()
G.add_edges_from(elist)
w = nx.adjacency_matrix(G, nodelist=range(G.number_of_nodes()))
obj_f = partial(maxcut_obj, G=G)
C, offset = get_maxcut_operator(w)
brute_force_opt, _ = brute_force(obj_f, G.number_of_nodes())
print(f"Brute force optimum: {brute_force_opt}")
precomputed_energies = precompute_obj(obj_f, G.number_of_nodes())
init_thetas = [
[np.pi / 4, 0, 0, np.pi / 2],
[np.pi / 5, 0, 0, np.pi / 2.5],
[np.pi / 6, 0, 0, np.pi / 3],
[np.pi / 7, 0, 0, np.pi / 3.5],
[np.pi / 8, 0, 0, np.pi / 4],
]
for p in range(2, 100):
start = time.time()
if is_master:
start = MPI.Wtime()
varopt = VariationalQuantumOptimizerAPOSMM(
obj_f,
'scipy_COBYLA',
gen_specs_user={
'initial_sample_size': len(init_thetas),
'sample_points': init_thetas,
'max_active_runs': len(init_thetas),
'run_max_eval': maxiter
},
variable_bounds=[(0, np.pi / 2), (0, np.pi / 2), (0, np.pi),
(0, np.pi)],
optimizer_parameters={'maxiter': maxiter},
varform_description={
'name': 'QAOA',
'p': p,
'cost_operator': C,
'num_qubits': G.number_of_nodes()
},
backend_description={
'package': 'qiskit',
'provider': 'Aer',
'name': 'statevector_simulator'
},
execute_parameters={},
problem_description={
'offset': offset,
'smooth_schedule': True,
'do_not_check_cost_operator': True
},
objective_parameters={
'precomputed_energies': precomputed_energies
})
res = varopt.optimize()
if is_master:
end = MPI.Wtime()
print(
f"Found {res['min_val']} at p={p} with theta: [{', '.join('{:0.2f}'.format(i) for i in res['opt_params'])}] in {res['num_optimizer_evals']} evals, {end-start:.2f} sec, {G.number_of_nodes()} nodes",
flush=True)
if abs(res['min_val'] - brute_force_opt) < abs(
rtol * brute_force_opt):
for rank in range(1, world_size):
MPI.COMM_WORLD.send(RETURN_FLAG, dest=rank)
return p, res
else:
for rank in range(1, world_size):
MPI.COMM_WORLD.send(BLANK_FLAG, dest=rank)
else:
flag = MPI.COMM_WORLD.recv(source=0)
if flag == RETURN_FLAG:
return
for i, j in G.edges():
if x[i] != x[j]:
# the edge is cut
cut -= 1
return cut
elist = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [0, 5], [1, 6], [2, 7],
[3, 8], [4, 9], [5, 7], [5, 8], [6, 8], [6, 9], [7, 9]]
G = nx.OrderedGraph()
G.add_edges_from(elist)
w = nx.adjacency_matrix(G)
obj = partial(maxcut_obj, G=G)
C, offset = get_maxcut_operator(w)
p = 10
lb = np.array([0, 0] * p)
ub = np.array([np.pi / 2] * p + [np.pi] * p)
np.random.seed(0)
init_theta = np.random.uniform(lb, ub)
print(f"Init point: {init_theta}")
np.random.seed(0)
varopt_aposmm = VariationalQuantumOptimizerAPOSMM(
obj,
'scipy_COBYLA',
initial_point=init_theta,
optimizer_parameters={