def setUp(self): super().setUp() try: PySCFDriver(atom=self.lih) except QiskitNatureError: self.skipTest('PySCF driver does not appear to be installed')
def setUp(self): super().setUp() PySCFDriver(atom=self.lih)
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 ---------------------------------------- from qiskit_nature import FermionicOperator from qiskit_nature.drivers import PySCFDriver, UnitsType from qiskit.opflow import TwoQubitReduction # Use PySCF, a classical computational chemistry software # package, to compute the one-body and two-body integrals in # molecular-orbital basis, necessary to form the Fermionic operator driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') molecule = driver.run() num_particles = molecule.num_alpha + molecule.num_beta num_spin_orbitals = molecule.num_orbitals * 2 # Build the qubit operator, which is the input to the VQE algorithm ferm_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubit_op = ferm_op.mapping(map_type) qubit_op = TwoQubitReduction( num_particles=num_particles).convert(qubit_op) num_qubits = qubit_op.num_qubits # setup a classical optimizer for VQE from qiskit.algorithms.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the initial state for the variational form from qiskit_nature.circuit.library import HartreeFock init_state = HartreeFock(num_spin_orbitals, num_particles) # setup the variational form for VQE from qiskit.circuit.library import TwoLocal var_form = TwoLocal(num_qubits, ['ry', 'rz'], 'cz') # add the initial state var_form.compose(init_state, front=True) # set the backend for the quantum computation from qiskit import Aer backend = Aer.get_backend('statevector_simulator') # setup and run VQE from qiskit.algorithms import VQE algorithm = VQE(var_form, optimizer=optimizer, quantum_instance=backend) result = algorithm.compute_minimum_eigenvalue(qubit_op) print(result.eigenvalue.real) # ---------------------------------------------------------------------- self.assertAlmostEqual(result.eigenvalue.real, -1.8572750301938803, places=6)
class TestAdaptVQEUCCSD(QiskitNatureTestCase): """ Test Adaptive VQE with UCCSD""" def setUp(self): super().setUp() # np.random.seed(50) self.seed = 50 algorithm_globals.random_seed = self.seed try: self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') except QiskitNatureError: self.skipTest('PYSCF driver does not appear to be installed') return molecule = self.driver.run() self.num_particles = molecule.num_alpha + molecule.num_beta self.num_spin_orbitals = molecule.num_orbitals * 2 fer_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubit_op = fer_op.mapping(map_type) self.qubit_op = TwoQubitReduction( num_particles=self.num_particles).convert(qubit_op) self.num_qubits = self.qubit_op.num_qubits self.init_state = HartreeFock(self.num_spin_orbitals, self.num_particles) self.var_form_base = None def test_uccsd_adapt(self): """ UCCSD test for adaptive features """ self.var_form_base = UCCSD(self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) self.var_form_base.manage_hopping_operators() # assert that the excitation pool exists self.assertIsNotNone(self.var_form_base.excitation_pool) # assert that the hopping ops list has been reset to be empty self.assertEqual(self.var_form_base._hopping_ops, []) def test_vqe_adapt(self): """ AdaptVQE test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer backend = Aer.get_backend('statevector_simulator') except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return class CustomFactory(VQEUCCSDFactory): """A custom MESFactory""" def get_solver(self, transformation): num_orbitals = transformation.molecule_info['num_orbitals'] num_particles = transformation.molecule_info['num_particles'] initial_state = HartreeFock(num_orbitals, num_particles) var_form = UCCSD(num_orbitals, num_particles, initial_state=initial_state) vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe algorithm = AdaptVQE(FermionicTransformation(), solver=CustomFactory(QuantumInstance(backend)), threshold=0.00001, delta=0.1, max_iterations=1) result = algorithm.solve(driver=self.driver) self.assertEqual(result.num_iterations, 1) self.assertEqual(result.finishing_criterion, 'Maximum number of iterations reached') algorithm = AdaptVQE(FermionicTransformation(), solver=CustomFactory(QuantumInstance(backend)), threshold=0.00001, delta=0.1) result = algorithm.solve(driver=self.driver) self.assertAlmostEqual(result.electronic_energies[0], -1.85727503, places=2) self.assertEqual(result.num_iterations, 2) self.assertAlmostEqual(result.final_max_gradient, 0.0, places=5) self.assertEqual(result.finishing_criterion, 'Threshold converged') def test_vqe_adapt_check_cyclicity(self): """ AdaptVQE index cycle detection """ param_list = [ ([1, 1], True), ([1, 11], False), ([11, 1], False), ([1, 12], False), ([12, 2], False), ([1, 1, 1], True), ([1, 2, 1], False), ([1, 2, 2], True), ([1, 2, 21], False), ([1, 12, 2], False), ([11, 1, 2], False), ([1, 2, 1, 1], True), ([1, 2, 1, 2], True), ([1, 2, 1, 21], False), ([11, 2, 1, 2], False), ([1, 11, 1, 111], False), ([11, 1, 111, 1], False), ([1, 2, 3, 1, 2, 3], True), ([1, 2, 3, 4, 1, 2, 3], False), ([11, 2, 3, 1, 2, 3], False), ([1, 2, 3, 1, 2, 31], False), ([1, 2, 3, 4, 1, 2, 3, 4], True), ([11, 2, 3, 4, 1, 2, 3, 4], False), ([1, 2, 3, 4, 1, 2, 3, 41], False), ([1, 2, 3, 4, 5, 1, 2, 3, 4], False), ] for seq, is_cycle in param_list: with self.subTest(msg="Checking index cyclicity in:", seq=seq): self.assertEqual(is_cycle, AdaptVQE._check_cyclicity(seq))
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 ---------------------------------------- from qiskit_nature.drivers import PySCFDriver, UnitsType from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem # Use PySCF, a classical computational chemistry software # package, to compute the one-body and two-body integrals in # electronic-orbital basis, necessary to form the Fermionic operator driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') problem = ElectronicStructureProblem(driver) # generate the second-quantized operators second_q_ops = problem.second_q_ops() main_op = second_q_ops[0] num_particles = (problem.molecule_data_transformed.num_alpha, problem.molecule_data_transformed.num_beta) num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals # setup the classical optimizer for VQE from qiskit.algorithms.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the mapper and qubit converter from qiskit_nature.mappers.second_quantization import ParityMapper from qiskit_nature.operators.second_quantization.qubit_converter import QubitConverter mapper = ParityMapper() converter = QubitConverter(mapper=mapper, two_qubit_reduction=True) # map to qubit operators qubit_op = converter.convert(main_op, num_particles=num_particles) # setup the initial state for the ansatz from qiskit_nature.circuit.library import HartreeFock init_state = HartreeFock(num_spin_orbitals, num_particles, converter) # setup the ansatz for VQE from qiskit.circuit.library import TwoLocal ansatz = TwoLocal(num_spin_orbitals, ['ry', 'rz'], 'cz') # add the initial state ansatz.compose(init_state, front=True) # set the backend for the quantum computation from qiskit import Aer backend = Aer.get_backend('statevector_simulator') # setup and run VQE from qiskit.algorithms import VQE algorithm = VQE(ansatz, optimizer=optimizer, quantum_instance=backend) result = algorithm.compute_minimum_eigenvalue(qubit_op) print(result.eigenvalue.real) electronic_structure_result = problem.interpret(result) print(electronic_structure_result) # ---------------------------------------------------------------------- self.assertAlmostEqual(result.eigenvalue.real, -1.8572750301938803, places=6)
def test_h2_bopes_sampler(self): """Test BOPES Sampler on H2""" seed = 50 algorithm_globals.random_seed = seed # Molecule dof = partial(Molecule.absolute_distance, atom_pair=(1, 0)) m = Molecule(geometry=[['H', [0., 0., 1.]], ['H', [0., 0.45, 1.]]], degrees_of_freedom=[dof]) f_t = FermionicTransformation() driver = PySCFDriver(molecule=m) qubitop, _ = f_t.transform(driver) # Quantum Instance: shots = 1 backend = 'statevector_simulator' quantum_instance = QuantumInstance(BasicAer.get_backend(backend), shots=shots) quantum_instance.run_config.seed_simulator = seed quantum_instance.compile_config['seed_transpiler'] = seed # Variational form i_state = HartreeFock(num_orbitals=f_t._molecule_info['num_orbitals'], qubit_mapping=f_t._qubit_mapping, two_qubit_reduction=f_t._two_qubit_reduction, num_particles=f_t._molecule_info['num_particles'], sq_list=f_t._molecule_info['z2_symmetries'].sq_list ) var_form = RealAmplitudes(qubitop.num_qubits, reps=1, entanglement='full', skip_unentangled_qubits=False) var_form.compose(i_state, front=True) # Classical optimizer: # Analytic Quantum Gradient Descent (AQGD) (with Epochs) aqgd_max_iter = [10] + [1] * 100 aqgd_eta = [1e0] + [1.0 / k for k in range(1, 101)] aqgd_momentum = [0.5] + [0.5] * 100 optimizer = AQGD(maxiter=aqgd_max_iter, eta=aqgd_eta, momentum=aqgd_momentum, tol=1e-6, averaging=4) # Min Eigensolver: VQE solver = VQE(var_form=var_form, optimizer=optimizer, quantum_instance=quantum_instance, expectation=PauliExpectation()) me_gss = GroundStateEigensolver(f_t, solver) # BOPES sampler sampler = BOPESSampler(gss=me_gss) # absolute internuclear distance in Angstrom points = [0.7, 1.0, 1.3] results = sampler.sample(driver, points) points_run = results.points energies = results.energies np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3]) np.testing.assert_array_almost_equal(energies, [-1.13618945, -1.10115033, -1.03518627], decimal=2)