def test_vqe(self): """Test VQE with gradients""" method = 'lin_comb' backend = 'qasm_simulator' q_instance = QuantumInstance(BasicAer.get_backend(backend), seed_simulator=79, seed_transpiler=2) # Define the Hamiltonian h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) \ - 0.01 * (Z ^ Z) + 0.18 * (X ^ X) h2_energy = -1.85727503 # Define the Ansatz wavefunction = QuantumCircuit(2) params = ParameterVector('theta', length=8) itr = iter(params) wavefunction.ry(next(itr), 0) wavefunction.ry(next(itr), 1) wavefunction.rz(next(itr), 0) wavefunction.rz(next(itr), 1) wavefunction.cx(0, 1) wavefunction.ry(next(itr), 0) wavefunction.ry(next(itr), 1) wavefunction.rz(next(itr), 0) wavefunction.rz(next(itr), 1) # Conjugate Gradient algorithm optimizer = CG(maxiter=10) grad = Gradient(grad_method=method) # Gradient callable vqe = VQE(h2_hamiltonian, wavefunction, optimizer=optimizer, gradient=grad) result = vqe.run(q_instance) np.testing.assert_almost_equal(result['optimal_value'], h2_energy, decimal=0)
def test_qgan_training_cg(self): """Test QGAN training.""" optimizer = CG(maxiter=1) self.qgan.set_generator(generator_circuit=self.generator_circuit, generator_optimizer=optimizer) trained_statevector = self.qgan.run(self.qi_statevector) trained_qasm = self.qgan.run(self.qi_qasm) self.assertAlmostEqual(trained_qasm['rel_entr'], trained_statevector['rel_entr'], delta=0.1)
def test_cg(self): """ cg test """ optimizer = CG(maxiter=1000, tol=1e-06) res = self._optimize(optimizer) self.assertLessEqual(res[2], 10000)
qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction, num_particles=core._molecule_info['num_particles'], sq_list=sqlist) circuit = init_state.construct_circuit() outfile.write("\nHartree-Fock energy %f \n" % (molecule.hf_energy)) outfile.write("\nHartree-Fock circuit\n") outfile.write(str(circuit.draw()) + "\n") var_form = RY(H_op.num_qubits, depth=3, entanglement='full', entanglement_gate='cz', initial_state=init_state) optimizer = CG(maxiter=1000) algo = VQE(H_op, var_form, optimizer, aux_operators=A_op) backend = Aer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend=backend) algo_result = algo.run(quantum_instance) get_results(H_op, A_op, molecule, core, algo_result, outfile) outfile.write("\nRY circuit\n") outfile.write( str(var_form.construct_circuit(algo_result['optimal_point']).draw()) + "\n") print_circuit_requirements( var_form.construct_circuit(algo_result['optimal_point']), 'ibmq_16_melbourne', 3, range(H_op.num_qubits), outfile)
var_form = UCCSD(reps=1, num_orbitals=core._molecule_info['num_orbitals'], num_particles=core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction, num_time_slices=1) init_parm = np.zeros(var_form.num_parameters) # 4) Initialize VQE with statevector simulator and run print("Running VQE on statevector simulator ...") optimizer = CG( maxiter=100 ) # We chose the CG optimizer but you can choose COBYLA, SPSA, L_BFGS_B, ... algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops, initial_point=init_parm) simulator = Aer.get_backend("qasm_simulator") backend_options = {"method": "statevector"} quantum_instance = QuantumInstance(backend=simulator, backend_options=backend_options) algo_result = algo.run(quantum_instance) # 5) Print the results print("\nResults")
def run_ucc_r12(opt): """ Parameters ---------- * opt dictionary with user and default options/thresholds Returns ------- * UCC-R12 ground state energy """ import itertools import logging import numpy as np import time from datetime import datetime import qiskit from qiskit import BasicAer,Aer from qiskit.aqua import set_qiskit_aqua_logging, QuantumInstance from qiskit.aqua.operators import Z2Symmetries, WeightedPauliOperator from qiskit.aqua.algorithms.adaptive import VQE from qiskit.aqua.algorithms.classical import ExactEigensolver from qiskit.aqua.components.optimizers import L_BFGS_B,CG,SPSA,SLSQP, COBYLA from qiskit.chemistry.drivers import PySCFDriver, UnitsType, HFMethodType from qiskit.chemistry.core import TransformationType, QubitMappingType from qiskit.chemistry.aqua_extensions.components.initial_states import HartreeFock from qiskit.chemistry import set_qiskit_chemistry_logging # ----- local functions ----- # import sys sys.path.append('/Users/mario/Documents/GitHub/R12-F12/project_ec/ucc_ec/') from qmolecule_ec import QMolecule_ec,build_parameter_list from hamiltonian_ec import Hamiltonian from uccsd_ec import UCCSD from davidson import davidson #import logging #set_qiskit_chemistry_logging(logging.DEBUG) logfile = open(opt["logfile"],'w') dateTimeObj = datetime.now() logfile.write("date and time "+str(dateTimeObj)+"\n") logfile.write("\n\n") import subprocess label = subprocess.check_output(['git','log','-1','--format="%H"']).strip() logfile.write("git commit "+str(label)+"\n") logfile.write("\n\n") qiskit_dict = qiskit.__qiskit_version__ logfile.write("qiskit version \n") for k in qiskit_dict: logfile.write(k+" : "+qiskit_dict[k]+"\n") logfile.write("\n\n") logfile.write("local run options \n") for k in opt: logfile.write(k+" : "+str(opt[k])+"\n") logfile.write("\n\n") import time t0 = time.time() if(opt["input_file"] is None): # ----- normal molecular calc ----- # if(opt["calc_type"].lower() == "rhf"): hf=HFMethodType.RHF if(opt["calc_type"].lower() == "rohf"): hf=HFMethodType.ROHF if(opt["calc_type"].lower() == "uhf"): hf=HFMethodType.UHF driver = PySCFDriver(atom=opt["geometry"],unit=UnitsType.ANGSTROM,charge=opt["charge"],spin=opt["spin"],basis=opt["basis"],hf_method=hf) molecule = driver.run() molecule_ec = QMolecule_ec(molecule=molecule,filename=None,logfile=logfile) else: # ----- custom matrix elements ----- # molecule_ec = QMolecule_ec(molecule=None,filename=opt["input_file"],calc=opt["calc_type"],nfreeze=opt["nfreeze"],logfile=logfile) molecule_ec.mo_eri_ints_ec = (molecule_ec.mo_eri_ints_ec).transpose((0,1,3,2)) t1 = time.time() logfile.write("classical ES and setup: %f [s] \n" % (t1-t0)) logfile.write("\n\n") core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,two_qubit_reduction=True,freeze_core=False) qubit_op, _ = core.run(molecule_ec) t2 = time.time() logfile.write("second-quantized Hamiltonian setup : %f [s] \n" % (t2-t1)) logfile.write("\n\n") logfile.write("Original number of qubits %d \n" % (qubit_op.num_qubits)) z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op) nsym = len(z2_symmetries.sq_paulis) the_tapered_op = qubit_op sqlist = None z2syms = None if(nsym>0): logfile.write('\nZ2 symmetries found: \n') for symm in z2_symmetries.symmetries: logfile.write(symm.to_label()) logfile.write('\nsingle-qubit operators found: \n') for sq in z2_symmetries.sq_paulis: logfile.write(sq.to_label()) logfile.write('\nCliffords found: \n') for clifford in z2_symmetries.cliffords: logfile.write(clifford.print_details()) logfile.write('\nsingle-qubit list: {} \n'.format(z2_symmetries.sq_list)) tapered_ops = z2_symmetries.taper(qubit_op) for tapered_op in tapered_ops: logfile.write("Number of qubits of tapered qubit operator: %d \n" % (tapered_op.num_qubits)) t3 = time.time() logfile.write("detection of symmetries: %f [s] \n" % (t3-t2)) smallest_eig_value = 99999999999999 smallest_idx = -1 for idx in range(len(tapered_ops)): td0 = time.time() from utils import retrieve_SCF_energy print("In sector ",idx,len(tapered_ops)) curr_value = retrieve_SCF_energy(tapered_ops[idx].copy(),core,opt) #,parm_list) curr_value = np.abs(curr_value-molecule_ec.hf_energy) print("Deviation ",curr_value) if curr_value < smallest_eig_value: smallest_eig_value = curr_value smallest_idx = idx if(curr_value<1e-6): break td1 = time.time() val = curr_value logfile.write("Lowest-energy computational basis state of the {}-th tapered operator is %s %f \n" % (str(idx),val)) logfile.write("HF search time %f: \n" % (td1-td0)) the_tapered_op = tapered_ops[smallest_idx] the_coeff = tapered_ops[smallest_idx].z2_symmetries.tapering_values logfile.write("{}-th tapered operator, with corresponding symmetry sector of {}".format(smallest_idx, the_coeff)) logfile.write("\nNumber of qubits in the {}-th tapered operator {}\n\n".format(smallest_idx,the_tapered_op.num_qubits)) sqlist = the_tapered_op.z2_symmetries.sq_list z2syms = the_tapered_op.z2_symmetries # ======== # setup initial state # ======== init_state = HartreeFock(num_qubits=the_tapered_op.num_qubits, num_orbitals=core._molecule_info['num_orbitals'], qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction, num_particles=core._molecule_info['num_particles'],sq_list=sqlist) # ---- initial parameter guess init_parm = None if(opt["start_pt"].lower()=="file"): init_parm = np.loadtxt('vqe.parameters') if(opt["var_form"].lower()=="uccsd" and opt["start_pt"].lower()=="ccsd"): parm_list = build_parameter_list(molecule_ec) logfile.write("Initial parameters = %d\n" % len(parm_list)) for mu,p in enumerate(parm_list): logfile.write('%d %f\n' % (mu,p)) if(opt["var_form"].lower()=="uccsd"): var_form = UCCSD(num_qubits=the_tapered_op.num_qubits,depth=opt["UCCSD_depth"], num_orbitals=core._molecule_info['num_orbitals'], num_particles=core._molecule_info['num_particles'], active_occupied=opt["UCCSD_active_occupied"], active_unoccupied=opt["UCCSD_active_unoccupied"], initial_state=init_state, qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction, num_time_slices=opt["UCCSD_num_time_slices"],z2_symmetries=z2syms,init_parm=parm_list) if(opt["var_form"].lower()=="uccsd" and opt["start_pt"].lower()=="ccsd"): nparm,ndepth = len(var_form._mask),var_form._depth init_parm = np.zeros(nparm*ndepth) for idp in range(ndepth): for ims in range(nparm): init_parm[ims+idp*nparm] = parm_list[var_form._mask[ims]] logfile.write("Selected parameters = %d\n" % nparm) for mu,p in enumerate(var_form._mask): logfile.write('%d %f\n' % (p,parm_list[p])) elif(opt["var_form"].lower()=="ry"): var_form = RY(the_tapered_op.num_qubits,depth=opt["R_depth"], entanglement=opt["R_entanglement"],initial_state=HF_state) elif(opt["var_form"].lower()=="ryrz"): var_form = RYRZ(the_tapered_op.num_qubits,depth=opt["R_depth"], entanglement=opt["R_entanglement"],initial_state=HF_state) elif(opt["var_form"].lower()=="swaprz"): var_form = SwapRZ(the_tapered_op.num_qubits,depth=opt["R_depth"], entanglement=opt["R_entanglement"],initial_state=HF_state) else: print("invalid variational form") assert(False) # setup optimizer if( opt["optimizer"].lower()=="bfgs"): optimizer = L_BFGS_B(maxiter=opt["max_eval"]) elif(opt["optimizer"].lower()=="cg"): optimizer = CG(maxiter=opt["max_eval"]) elif(opt["optimizer"].lower()=="slsqp"): optimizer = SLSQP(maxiter=opt["max_eval"]) elif(opt["optimizer"].lower()=="spsa"): optimizer = SPSA() elif(opt["optimizer"].lower()=="cobyla"): optimizer = COBYLA(maxiter=opt["max_eval"]) else: print("not coded yet"); assert(False) # set vqe if(opt["var_form"].lower()=="uccsd"): algo = VQE(the_tapered_op,var_form,optimizer,initial_point=init_parm) else: algo = VQE(the_tapered_op,var_form,optimizer) # setup backend backend = Aer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend=backend) t0 = time.time() algo_result = algo.run(quantum_instance) t1 = time.time() logfile.write("\nVQE time [s] %f \n\n" % (t1-t0)) result = core.process_algorithm_result(algo_result) for line in result[0]: logfile.write(line+"\n") logfile.write("\nThe parameters for UCCSD are:\n") for i,(tc,tq) in enumerate(zip(init_parm,algo_result['opt_params'])): logfile.write("%d %f %f \n" % (i,tc,tq)) if(opt["print_parameters"]): par_file = open('vqe.parameters','w') for p in algo_result['opt_params']: par_file.write("%f \n" % p) par_file.close() #td0 = time.time() #ee = davidson(the_tapered_op,'fci') #td1 = time.time() #logfile.write("\n\nExact diagonalization, energy: %f \n" % (ee+molecule_ec.nuclear_repulsion_energy+molecule_ec.energy_offset_ec)) #logfile.write("Davidson FCI time: %f [s] \n" % (td1-td0)) print('============================================================================') print(' DONE!') print('============================================================================') return 0