def test_ising_to_quadraticprogram_quadratic(self):
"""Test optimization problem to operators with linear=False"""
op = QUBIT_OP_MAXIMIZE_SAMPLE
offset = OFFSET_MAXIMIZE_SAMPLE
quadratic = QuadraticProgram()
quadratic.from_ising(op, offset, linear=False)
self.assertEqual(quadratic.get_num_vars(), 4)
self.assertEqual(quadratic.get_num_linear_constraints(), 0)
self.assertEqual(quadratic.get_num_quadratic_constraints(), 0)
self.assertEqual(quadratic.objective.sense,
quadratic.objective.Sense.MINIMIZE)
self.assertAlmostEqual(quadratic.objective.constant, 900000)
quadratic_matrix = np.zeros((4, 4))
quadratic_matrix[0, 0] = -500001
quadratic_matrix[0, 1] = 400000
quadratic_matrix[0, 2] = 600000
quadratic_matrix[0, 3] = 800000
quadratic_matrix[1, 1] = -800001
quadratic_matrix[1, 2] = 1200000
quadratic_matrix[1, 3] = 1600000
quadratic_matrix[2, 2] = -900001
quadratic_matrix[2, 3] = 2400000
quadratic_matrix[3, 3] = -800001
np.testing.assert_array_almost_equal(
quadratic.objective.quadratic.coefficients.toarray(),
quadratic_matrix)
def test_quadratic_program_element_when_loaded_from_source(self):
"""Test QuadraticProgramElement when QuadraticProgram is loaded from an external source"""
with self.subTest("from_ising"):
q_p = QuadraticProgram()
q_p.from_ising(PauliSumOp.from_list([("IZ", 1), ("ZZ", 2)]))
self.assertEqual(id(q_p.objective.quadratic_program), id(q_p))
for elem in q_p.variables:
self.assertEqual(id(elem.quadratic_program), id(q_p))
for elem in q_p.linear_constraints:
self.assertEqual(id(elem.quadratic_program), id(q_p))
for elem in q_p.quadratic_constraints:
self.assertEqual(id(elem.quadratic_program), id(q_p))
try:
lp_file = self.get_resource_path("test_quadratic_program.lp",
"problems/resources")
q_p = QuadraticProgram()
q_p.read_from_lp_file(lp_file)
self.assertEqual(id(q_p.objective.quadratic_program), id(q_p))
for elem in q_p.variables:
self.assertEqual(id(elem.quadratic_program), id(q_p))
for elem in q_p.linear_constraints:
self.assertEqual(id(elem.quadratic_program), id(q_p))
for elem in q_p.quadratic_constraints:
self.assertEqual(id(elem.quadratic_program), id(q_p))
except RuntimeError as ex:
self.fail(str(ex))
def symmetrise_qubo(self):
new_operator = []
operator, _ = self.qubo.to_ising()
for op_1 in operator:
coeff, op_1 = op_1.to_pauli_op().coeff, op_1.to_pauli_op().primitive
op_1_str = op_1.to_label()
Z_counts = op_1_str.count('Z')
if Z_counts == 1:
op_1_str = "Z" + op_1_str #Add a Z in the last qubit to single Z terms
else:
op_1_str = "I" + op_1_str #Add an I in the last qubit to ZZ terms (no change in operator)
pauli = PauliOp( primitive = Pauli(op_1_str), coeff = coeff )
new_operator.append(pauli)
symmetrised_qubo = QuadraticProgram()
symmetrised_operator = sum(new_operator)
symmetrised_qubo.from_ising(symmetrised_operator, self.offset, linear=True)
self.qubo = symmetrised_qubo
self.rename_qubo_variables()
operator, _ = self.qubo.to_ising()
self.operator = operator
def main(args=None):
"""[summary]
Args:
raw_args ([type], optional): [description]. Defaults to None.
"""
start = time()
if args == None:
args = parse()
qubo_no = args["no_samples"]
print_to_file("-" * 50)
print_to_file("QUBO_{}".format(qubo_no))
#Load generated qubo_no
with open(
'qubos_{}_car_{}_routes/qubo_{}.pkl'.format(
args["no_cars"], args["no_routes"], qubo_no), 'rb') as f:
qubo, max_coeff, operator, offset, routes = pkl.load(f)
qubo = QuadraticProgram()
qubo.from_ising(operator)
x_s, opt_value, classical_result = find_all_ground_states(qubo)
print_to_file(classical_result)
#Set optimizer method
method = args["method"]
optimizer = NLOPT_Optimizer(method=method, result_message=False)
# optimizer = COBYLA()
backend = Aer.get_backend("statevector_simulator")
quantum_instance = QuantumInstance(backend=backend)
approx_ratios = []
prob_s_s = []
p_max = args["p_max"]
no_routes, no_cars = (args["no_routes"], args["no_cars"])
custom = True
if custom:
initial_state = construct_initial_state(no_routes=no_routes,
no_cars=no_cars)
mixer = n_qbit_mixer(initial_state)
else:
initial_state, mixer = (None, None)
fourier_parametrise = args["fourier"]
print_to_file("-" * 50)
print_to_file(
"Now solving with TQA_QAOA... Fourier Parametrisation: {}".format(
fourier_parametrise))
# maxeval = 125
for p in range(1, p_max + 1):
construct_circ = False
deltas = np.arange(0.45, 0.91, 0.05)
point = np.append([(i + 1) / p for i in range(p)],
[1 - (i + 1) / p for i in range(p)])
points = [delta * point for delta in deltas]
print_to_file("-" * 50)
print_to_file(" " + "p={}".format(p))
if fourier_parametrise:
points = [
convert_to_fourier_point(point, len(point)) for point in points
]
# maxeval *= 2 #Double max_allowed evals for optimizer
# optimizer.set_options(maxeval = maxeval)
optimizer.set_options(maxeval=1000 * p)
qaoa_results, optimal_circ = CustomQAOA(
operator,
quantum_instance,
optimizer,
reps=p,
initial_state=initial_state,
mixer=mixer,
construct_circ=construct_circ,
fourier_parametrise=fourier_parametrise,
list_points=points,
qubo=qubo)
exp_val = qaoa_results.eigenvalue * max_coeff
state_solutions = {
item[0][::-1]: item[1:]
for item in qaoa_results.eigenstate
}
for item in sorted(state_solutions.items(),
key=lambda x: x[1][1],
reverse=True)[0:5]:
print_to_file(item)
prob_s = 0
for string in x_s:
prob_s += state_solutions[string][
1] if string in state_solutions else 0
prob_s /= len(x_s) #normalise
optimal_point = qaoa_results.optimal_point
if fourier_parametrise:
optimal_point = convert_from_fourier_point(optimal_point,
len(optimal_point))
approx_ratio = 1 - np.abs((opt_value - exp_val) / opt_value)
nfev = qaoa_results.cost_function_evals
print_to_file(
" " + "Optimal_point: {}, Nfev: {}".format(optimal_point, nfev))
print_to_file(" " +
"Exp_val: {}, Prob_s: {}, approx_ratio: {}".format(
exp_val, prob_s, approx_ratio))
approx_ratios.append(approx_ratio)
prob_s_s.append(prob_s)
print_to_file("-" * 50)
print_to_file("QAOA terminated")
print_to_file("-" * 50)
print_to_file("Approximation ratios per layer: {}".format(approx_ratios))
print_to_file("Prob_success per layer: {}".format(prob_s_s))
save_results = np.append(approx_ratios, prob_s_s)
if fourier_parametrise:
with open(
'results_{}cars{}routes/TQA_F_{}.csv'.format(
args["no_cars"], args["no_routes"], args["no_samples"]),
'w') as f:
np.savetxt(f, save_results, delimiter=',')
print_to_file(
"Results saved in results_{}cars{}routes/TQA_F_{}.csv".format(
args["no_cars"], args["no_routes"], args["no_samples"]))
else:
with open(
'results_{}cars{}routes/TQA_NF_{}.csv'.format(
args["no_cars"], args["no_routes"], args["no_samples"]),
'w') as f:
np.savetxt(f, save_results, delimiter=',')
print_to_file(
"Results saved in results_{}cars{}routes/TQA_NF_{}.csv".format(
args["no_cars"], args["no_routes"], args["no_samples"]))
finish = time()
print_to_file("Time Taken: {}".format(finish - start))
def main(args = None):
"""[summary]
Args:
raw_args ([type], optional): [description]. Defaults to None.
"""
start = time()
if args == None:
args = parse()
qubo_no = args["no_samples"]
print_to_file("-"*50)
print_to_file("QUBO_{}".format(qubo_no))
#Load generated qubo_no
with open('qubos_{}_car_{}_routes/qubo_{}.pkl'.format(args["no_cars"], args["no_routes"], qubo_no), 'rb') as f:
qubo, max_coeff, operator, offset, routes = pkl.load(f)
qubo = QuadraticProgram()
qubo.from_ising(operator)
x_s, opt_value, classical_result = find_all_ground_states(qubo)
print_to_file(classical_result)
#Set optimizer method
method = args["method"]
optimizer = NLOPT_Optimizer(method = method, result_message=False)
backend = Aer.get_backend("statevector_simulator")
quantum_instance = QuantumInstance(backend = backend)
approx_ratios = []
prob_s_s = []
p_max = args["p_max"]
no_routes, no_cars = (args["no_routes"], args["no_cars"])
custom = True
if custom:
initial_state = construct_initial_state(no_routes = no_routes, no_cars = no_cars)
mixer = n_qbit_mixer(initial_state)
else:
initial_state, mixer = (None, None)
fourier_parametrise = args["fourier"]
print_to_file("-"*50)
print_to_file("Now solving with QAOA... Fourier Parametrisation: {}".format(fourier_parametrise))
for p in range(1, p_max+1):
if p == 1:
points = [[0,0]] + [ np.random.uniform(low = -np.pi/2+0.01, high = np.pi/2-0.01, size = 2*p) for _ in range(2**p)]
next_point = []
else:
penalty = 0.6
points = [next_point_l] + generate_points(next_point, no_perturb=min(2**p-1,10), penalty=penalty)
construct_circ = False
#empty lists to save following results to choose best result
results = []
exp_vals = []
print_to_file("-"*50)
print_to_file(" "+"p={}".format(p))
optimizer.set_options(maxeval = 1000*p)
for r, point in enumerate(points):
qaoa_results, optimal_circ = CustomQAOA(operator,
quantum_instance,
optimizer,
reps = p,
initial_fourier_point= point,
initial_state = initial_state,
mixer = mixer,
construct_circ= construct_circ,
fourier_parametrise = fourier_parametrise,
qubo = qubo
)
if r == 0:
if fourier_parametrise:
next_point_l = np.zeros(shape = 2*p + 2)
next_point_l[0:p] = qaoa_results.optimal_point[0:p]
next_point_l[p+1:2*p+1] = qaoa_results.optimal_point[p:2*p]
else:
next_point_l = interp_point(qaoa_results.optimal_point)
exp_val = qaoa_results.eigenvalue * max_coeff
exp_vals.append(exp_val)
state_solutions = { item[0][::-1]: item[1:] for item in qaoa_results.eigenstate }
for item in sorted(state_solutions.items(), key = lambda x: x[1][1], reverse = True)[0:5]:
print_to_file( item )
prob_s = 0
for string in x_s:
prob_s += state_solutions[string][1] if string in state_solutions else 0
prob_s /= len(x_s) #normalise
results.append((qaoa_results, optimal_circ, prob_s))
print_to_file(" "+"Point_{}, Exp_val: {}, Prob_s: {}".format(r, exp_val, prob_s))
minim_index = np.argmin(exp_vals)
optimal_qaoa_result, optimal_circ, optimal_prob_s = results[minim_index]
if fourier_parametrise:
next_point = convert_from_fourier_point( optimal_qaoa_result.optimal_point, 2*p )
next_point = convert_to_fourier_point( interp_point(next_point), 2*p + 2 )
# next_point = np.zeros(shape = 2*p + 2)
# next_point[0:p] = optimal_qaoa_result.optimal_point[0:p]
# next_point[p+1:2*p+1] = optimal_qaoa_result.optimal_point[p:2*p]
else:
next_point = interp_point(optimal_qaoa_result.optimal_point)
if construct_circ:
print_to_file(optimal_circ.draw(fold=150))
minim_exp_val = exp_vals[minim_index]
approx_ratio = 1.0 - np.abs( (opt_value - minim_exp_val ) / opt_value )
print_to_file(" "+"Minimum: {}, prob_s: {}, approx_ratio {}".format(minim_exp_val, optimal_prob_s, approx_ratio))
approx_ratios.append(approx_ratio)
prob_s_s.append(optimal_prob_s)
print_to_file("-"*50)
print_to_file("QAOA terminated")
print_to_file("-"*50)
print_to_file("Approximation ratios per layer: {}".format(approx_ratios))
print_to_file("Prob_success per layer: {}".format(prob_s_s))
save_results = np.append(approx_ratios, prob_s_s)
if fourier_parametrise:
with open('results_{}cars{}routes/RI_F_{}.csv'.format(args["no_cars"], args["no_routes"], args["no_samples"]), 'w') as f:
np.savetxt(f, save_results, delimiter=',')
print_to_file("Results saved in results_{}cars{}routes/RI_F_{}.csv".format(args["no_cars"], args["no_routes"], args["no_samples"]))
else:
with open('results_{}cars{}routes/RI_NF_{}.csv'.format(args["no_cars"], args["no_routes"], args["no_samples"]), 'w') as f:
np.savetxt(f, save_results, delimiter=',')
print_to_file("Results saved in results_{}cars{}routes/RI_NF_{}.csv".format(args["no_cars"], args["no_routes"], args["no_samples"]))
finish = time()
print_to_file("Time Taken: {}".format(finish - start))
def main(args=None):
start = time()
if args == None:
args = parse()
prob_s_s = []
qubo_no = args["no_samples"]
print("__"*50, "\nQUBO NO: {}\n".format(qubo_no), "__"*50)
#Load generated qubo_no
with open('qubos_{}_car_{}_routes/qubo_{}.pkl'.format(args["no_cars"], args["no_routes"], qubo_no), 'rb') as f:
qubo, max_coeff, operator, offset, routes = pkl.load(f)
# print(operator)
classical_result = solve_classically(qubo)
print(classical_result)
x_arr = classical_result.x
optimal_value = qubo.objective.evaluate(x_arr)
# print(optimal_value)
x_str = arr_to_str(x_arr)
sort_values = get_costs(qubo)
# print("_"*50)
# up_to = 27
# print("{} lowest states:".format(up_to))
# avg = 0
# for i in range(up_to):
# print(sort_values[i])
# avg += sort_values[i][1]
# print("_"*50)
# print("Avg: {}".format(avg/up_to))
#Remake QUBO to introduce only ZiZj terms
op, offset = qubo.to_ising()
new_operator = []
for i, op_1 in enumerate(op):
coeff, op_1 = op_1.to_pauli_op().coeff, op_1.to_pauli_op().primitive
op_1_str = op_1.to_label()
Z_counts = op_1_str.count('Z')
if Z_counts == 1:
op_1_str = 'Z' + op_1_str
else:
op_1_str = 'I' + op_1_str
pauli = PauliOp( primitive = Pauli(op_1_str), coeff = coeff )
new_operator.append(pauli)
qubo_2 = QuadraticProgram()
operator = sum(new_operator)
qubo_2.from_ising(operator, offset, linear=True)
print("Solving with QAOA...")
no_shots = 10000
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, shots = no_shots)
optimizer_method = "LN_SBPLX"
optimizer = NLOPT_Optimizer(method = optimizer_method)
print("_"*50,"\n"+optimizer.__class__.__name__)
print("_"*50)
p = 1
delta_points = []
deltas = np.arange(0.75, 0.76, 0.05)
print("delta_t's: ", deltas)
original_point = np.append([], [[(i+1)/p, 1-(i+1)/p] for i in range(p)])
for delta in deltas:
delta_points.append(delta*original_point)
# point = [ 0.60081404, 0.11785113, 0.02330747, 1.10006101, 0.46256391,
# -0.96823671]
draw_circuit = True
initial_state = construct_initial_state_2(args["no_routes"], args["no_cars"])
mixer = n_qbit_mixer(initial_state)
quantum_instance = QuantumInstance(backend)
results = []
exp_vals = []
for point in delta_points:
point = QAOAEx.convert_to_fourier_point(point, 2*p)
qaoa_results, _ = Fourier_QAOA(operator,
quantum_instance,
optimizer,
reps = p,
initial_fourier_point=point,
initial_state = initial_state,
mixer = mixer,
construct_circ=draw_circuit,
fourier_parametrise = True
)
# print(optimal_circ.draw())
results.append(qaoa_results)
exp_val = qaoa_results.eigenvalue + offset
print("ExpVal {}".format(exp_val))
exp_vals.append(exp_val)
minim_index = np.argmin(exp_vals)
qaoa_results = results[minim_index]
sort_states = sorted(qaoa_results.eigenstate.items(), key=lambda x: x[1], reverse=True)
correlations = get_correlations(sort_states)
# print(correlations)
i,j = find_strongest_correlation(correlations)
if correlations[i,j] > 0:
condition = "Z_{i} = Z_{j}".format(i=i,j=j)
else:
condition = "Z_{i} = - Z_{j}".format(i=i,j=j)
print("Max: <Z_{i}Z_{j}>={maxim}, condition: ".format(i=i, j=j, maxim = correlations[i,j])+condition)
ground_energy = sort_values[0][1]
x_s = [x_str]
for i in range(0,10):
if sort_values[i][0] == x_str or np.round(sort_values[i][1], 4) != np.round(ground_energy, 4):
continue
else:
print("Other ground state(s) found: '{}'".format(sort_values[i][0]))
x_s.append(sort_values[i][0])
x_s_2 = []
print("All the possible solutions were originally: ")
print("[Z0 Z1 Z2 Z3 Z4 Z5 Z6 Z7 Z8 Z9]")
for string in x_s:
x = '0' + string
x_arr = np.array(str_to_arr(x))
# print("f({x})={obj}".format(x=x, obj = qubo_2.objective.evaluate(x_arr)))
x_s_2.append(x_arr)
formatted_arr = ["{} ".format(item) for item in x_arr]
formatted_arr = ' '.join(formatted_arr)
print("[{}]".format(formatted_arr))
finish = time()
print("Time taken {time}s".format(time=finish-start))
