def qc_solver(h_qop, num_spin_orbitals, num_particles, map_type, \ qubit_reduction, aux_qops=None): # backends = Aer.backends() backends = IBMQ.backends(simulator=False) print(backends) # backend = IBMQ.get_backend('ibmq_qasm_simulator') # backend = IBMQ.get_backend('ibmq_16_melbourne') # backend = Aer.get_backend('statevector_simulator') backend = Aer.get_backend('qasm_simulator') # setup COBYLA optimizer max_eval = 1000 cobyla = COBYLA(maxiter=max_eval) # setup hartreeFock state hf_state = HartreeFock(h_qop.num_qubits, num_spin_orbitals, num_particles, map_type, qubit_reduction) # setup UCCSD variational form var_form = UCCSD(h_qop.num_qubits, depth=1, num_orbitals=num_spin_orbitals, num_particles=num_particles, active_occupied=[0], active_unoccupied=[0], initial_state=hf_state, qubit_mapping=map_type, two_qubit_reduction=qubit_reduction, num_time_slices=1) # setup VQE vqe = VQE(h_qop, var_form, cobyla, operator_mode='matrix', \ aux_operators=aux_qops) quantum_instance = QuantumInstance(backend=backend, shots=1024, max_credits=10) ret = vqe.run(quantum_instance) print(ret['aux_ops']) print('The computed ground state energy is: {:.12f}'.format(\ ret['eigvals'][0]))
def test_vqe_2_iqpe(self): backend = get_aer_backend('qasm_simulator') num_qbits = self.algo_input.qubit_op.num_qubits var_form = RYRZ(num_qbits, 3) optimizer = SPSA(max_trials=10) # optimizer.set_options(**{'max_trials': 500}) algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis') quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.log.debug('VQE result: {}.'.format(result)) self.ref_eigenval = -1.85727503 num_time_slices = 50 num_iterations = 11 state_in = VarFormBased(var_form, result['opt_params']) iqpe = IQPE(self.algo_input.qubit_op, state_in, num_time_slices, num_iterations, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) quantum_instance = QuantumInstance(backend, shots=100, pass_manager=PassManager(), seed=self.random_seed, seed_mapper=self.random_seed) result = iqpe.run(quantum_instance) self.log.debug('top result str label: {}'.format( result['top_measurement_label'])) self.log.debug('top result in decimal: {}'.format( result['top_measurement_decimal'])) self.log.debug('stretch: {}'.format( result['stretch'])) self.log.debug('translation: {}'.format( result['translation'])) self.log.debug('final eigenvalue from QPE: {}'.format( result['energy'])) self.log.debug('reference eigenvalue: {}'.format( self.ref_eigenval)) self.log.debug('ref eigenvalue (transformed): {}'.format( (self.ref_eigenval + result['translation']) * result['stretch'])) self.log.debug('reference binary str label: {}'.format( decimal_to_binary((self.ref_eigenval + result['translation']) * result['stretch'], max_num_digits=num_iterations + 3, fractional_part_only=True))) np.testing.assert_approx_equal(self.ref_eigenval, result['energy'], significant=2)
def test_vqe_direct(self, batch_mode): backend = get_aer_backend('statevector_simulator') num_qubits = self.algo_input.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, 3, initial_state=init_state) optimizer = L_BFGS_B() algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'matrix', batch_mode=batch_mode) quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503)
backend = Aer.get_backend('statevector_simulator') # setup COBYLA optimizer max_eval = 200 cobyla = COBYLA(maxiter=max_eval) # setup HartreeFock state HF_state = HartreeFock(qubitOp.num_qubits, num_spin_orbitals, num_particles, map_type, qubit_reduction) # setup UCCSD variational form var_form = UCCSD(qubitOp.num_qubits, depth=1, num_orbitals=num_spin_orbitals, num_particles=num_particles, active_occupied=[0], active_unoccupied=[0, 1], initial_state=HF_state, qubit_mapping=map_type, two_qubit_reduction=qubit_reduction, num_time_slices=1) # setup VQE vqe = VQE(qubitOp, var_form, cobyla, 'matrix') quantum_instance = QuantumInstance(backend=backend) results = vqe.run(quantum_instance) print('The computed ground state energy is: {:.12f}'.format( results['eigvals'][0])) print('The total ground state energy is: {:.12f}'.format( results['eigvals'][0] + energy_shift + nuclear_repulsion_energy)) #print("Parameters: {}".format(results['opt_params']))
seqs=seq_array, costs=cost_array, coeffs=coeff_arr, inserts=insert_vals, times=np.array(times), states=np.array(states), angles=np.array(angle_arr), energies=np.array(energies)) for s in alignment: print(s) # VQE if method == "VQE": opt = SPSA(max_trials=100) trial = RY(Hamilt.num_qubits, depth=10, entanglement='linear') solver = VQE(Hamilt, trial, opt, "paulis") simulator = IBMQ.get_backend(backend) instance = QuantumInstance(backend=simulator, shots=1024) print("Starting job") result = solver.run(instance) print("Job finished?") state = result["eigvecs"][0] energy = result["eigvals"][0] + shift positions = MSA_column.sample_most_likely(state, rev_inds) for (key, value) in positions.items(): print(key, value) alignment = MSA_column.get_alignment_string(sequences, inserts, positions) print("VQE solution: Energy=", energy)
# ====================== # define the initial state init_state = Zero(num_qubits) # get a variational ansatz ansatz = RY(num_qubits, initial_state=init_state) # operator from hamiltonian qubit_op = Operator.load_from_dict(pauli_dict) # get an optimizer optimizer = COBYLA(maxiter=1000, disp=True) # form the algorithm vqe = VQE(qubit_op, ansatz, optimizer) # get a backend backend = get_aer_backend("statevector_simulator") # get a quantum instance qinstance = QuantumInstance(backend, shots=1024) # =================== # do the optimization # =================== result = vqe.run(qinstance) # ================ # show the results
# Build the qubit operator, which is the input to the VQE algorithm in Aqua ferOp = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubitOp = ferOp.mapping(map_type) qubitOp = qubitOp.two_qubit_reduced_operator(num_particles) num_qubits = qubitOp.num_qubits # set the backend for the quantum computation from qiskit import Aer backend = Aer.get_backend('statevector_simulator') # setup a classical optimizer for VQE from qiskit_aqua.components.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the initial state for the variational form from qiskit_chemistry.aqua_extensions.components.initial_states import HartreeFock init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles) # setup the variational form for VQE from qiskit_aqua.components.variational_forms import RYRZ var_form = RYRZ(num_qubits, initial_state=init_state) # setup and run VQE from qiskit_aqua.algorithms import VQE algorithm = VQE(qubitOp, var_form, optimizer) result = algorithm.run(backend) print(result['energy'])