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))