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(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(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 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_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 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_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 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_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_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 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 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 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 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 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 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 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 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_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 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)
xp = np.zeros(num_nodes, dtype=np.bool) zp = np.zeros(num_nodes, dtype=np.bool) zp[key] = True pauli_list.append([value, Pauli(zp, xp)]) return WeightedPauliOperator(paulis=pauli_list), constant isingdict ={(0,1):0.5,(1,2):0.5,(2,3):0.5,(3,4):0.5,():-2.0} qubitOp, shift = get_ising_qubitops(isingdict,5) provider = OpenSuperQ_Provider() backend = provider.get_backend('OSQ_ETH7_rev1') optimizer = POWELL() qaoa = QAOA(qubitOp, optimizer, p=1, operator_mode='paulis',initial_point=[0.0, 0.0]) quantum_instance = QuantumInstance(backend) circ = qaoa.construct_circuit(parameter=[2.0, 1.0],circuit_name_prefix='Hello',statevector_mode=True) latex = circ[0].draw(output='latex_source') result = qaoa.run(quantum_instance) print('shift: ', shift) print('name: ', result.keys()) print([str(key) + " " + str(value) for key, value in result.items()]) plot_histogram(result['eigvecs'], figsize = (18,5)) x = max_cut.sample_most_likely(result['eigvecs'][0]) graph_solution = max_cut.get_graph_solution(x) #qaoa._circuit.draw(output='mpl')
print(qubo.export_as_lp_string()) # In[7]: qp2op = QuadraticProgramToIsing() op, offset = qp2op.encode(qubo) print('offset: {}'.format(offset)) print('operator:') print(op.print_details()) # In[8]: from qiskit.circuit.library import RealAmplitudes from qiskit.aqua.components.optimizers import COBYLA qaoa_mes = QAOA(quantum_instance=BasicAer.get_backend('statevector_simulator')) vqe_mes = VQE( quantum_instance=BasicAer.get_backend('statevector_simulator'), var_form=RealAmplitudes(3, reps=2), # parametrized circuit to use optimizer=COBYLA(maxiter=200)) # classical optimizer exact_mes = NumPyMinimumEigensolver() # In[9]: qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA vqe = MinimumEigenOptimizer(vqe_mes) # using VQE exact = MinimumEigenOptimizer( exact_mes) # using the exact classical numpy minimum eigen solver
pos = nx.spring_layout(G) w = my_graphs.adjacency_matrix(G) print("\nAdjacency matrix\n", w, "\n") # setting p p = 1 # ... QAOA ... # 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 optimizer = NELDER_MEAD() qaoa = QAOA(qubit_op, optimizer, p=p) backend = Aer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend, shots=1000) result = qaoa.run(quantum_instance) x = sample_most_likely(result.eigenstate) print('energy:', result.eigenvalue.real) print('time:', result.optimizer_time, 's') 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)) print('angles:', result.optimal_point)
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)