def test_eval_op_qasm_aer(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=AerPauliExpectation(), include_custom=True, quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[ self.electronic_structure_problem.main_property_name] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real)
def test_eval_op_qasm_aer(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" try: # pylint: disable=import-outside-toplevel # pylint: disable=unused-import from qiskit import Aer backend = Aer.get_backend("aer_simulator") except ImportError as ex: # pylint: disable=broad-except self.skipTest(f"Aer doesn't appear to be installed. Error: '{str(ex)}'") return solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=AerPauliExpectation(), include_custom=True, quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[0] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real)
def test_print_result(self): """Regression test against issues with printing results.""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = AdaptVQE(self.qubit_converter, solver) res = calc.solve(self.problem) with contextlib.redirect_stdout(io.StringIO()) as out: print(res) # do NOT change the below! Lines have been truncated as to not force exact numerical matches expected = """\ === GROUND STATE ENERGY === * Electronic ground state energy (Hartree): -1.857 - computed part: -1.857 ~ Nuclear repulsion energy (Hartree): 0.719 > Total ground state energy (Hartree): -1.137 === MEASURED OBSERVABLES === 0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000 === DIPOLE MOMENTS === ~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38 0: * Electronic dipole moment (a.u.): [0.0 0.0 1.38 - computed part: [0.0 0.0 1.38 > Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0. (debye): [0.0 0.0 0.0] Total: 0. """ for truth, expected in zip(out.getvalue().split("\n"), expected.split("\n")): assert truth.strip().startswith(expected.strip())
def test_vqe_ucc_custom(self): """Test custom ansatz in Factory use case""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def test_vqe_uccsd(self): """ Test VQE UCCSD case """ solver = VQEUCCFactory( quantum_instance=QuantumInstance(BasicAer.get_backend('statevector_simulator')), ansatz=UCC(excitations='d'), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def test_default(self): """Default execution""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = AdaptVQE(self.qubit_converter, solver) res = calc.solve(self.problem) self.assertAlmostEqual(res.electronic_energies[0], self.expected, places=6)
def test_gradient(self, grad_method): """test for different gradient methods""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) grad = Gradient(grad_method, epsilon=1.0) calc = AdaptVQE(self.qubit_converter, solver, gradient=grad) res = calc.solve(self.problem) self.assertAlmostEqual(res.electronic_energies[0], self.expected, places=6)
def test_natural_gradients_invalid(self): """test that an exception is thrown when an invalid gradient method is used""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) grad = NaturalGradient(grad_method="fin_diff", qfi_method="lin_comb_full", regularization="ridge") calc = AdaptVQE(self.qubit_converter, solver, gradient=grad) with self.assertRaises(QiskitNatureError): _ = calc.solve(self.problem)
def _solve_with_vqe_mes(self, converter: QubitConverter): solver = VQEUCCFactory(self.quantum_instance) gsc = GroundStateEigensolver(converter, solver) esc = QEOM(gsc, "sd") results = esc.solve(self.electronic_structure_problem) for idx, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_energies[idx], energy, places=4)
def _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator'))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) # now we decide that we want to evaluate another operator # for testing simplicity, we just use some pre-constructed auxiliary operators _, *aux_ops = self.qubit_converter.convert_match( self.electronic_structure_problem.second_q_ops()) return calc, res, aux_ops
def test_delta_and_gradient(self): """test for when delta and gradient both are set""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) delta1 = 0.01 grad = Gradient(grad_method="fin_diff", epsilon=1.0) with self.assertRaises(TypeError): _ = AdaptVQE(self.qubit_converter, solver, delta=delta1, gradient=grad)
def test_vqe_mes(self): """Test VQEUCCSDFactory with QEOM""" solver = VQEUCCFactory(self.quantum_instance) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, "sd") results = esc.solve(self.electronic_structure_problem) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx], places=4)
def setUp(self): super().setUp() self.converter = QubitConverter(JordanWignerMapper()) self.seed = 50 self.quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed) self._vqe_ucc_factory = VQEUCCFactory(self.quantum_instance)
def test_delta(self): """test for when delta is set instead of gradient""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) delta1 = 0.01 with warnings.catch_warnings(record=True): warnings.simplefilter("always") calc = AdaptVQE(self.qubit_converter, solver, delta=delta1) res = calc.solve(self.problem) self.assertAlmostEqual(res.electronic_energies[0], self.expected, places=6)
def test_default_initial_point(self): """Test when using the default initial point.""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_equal(solver.initial_point.to_numpy_array(), [0.0, 0.0, 0.0]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) # now we decide that we want to evaluate another operator # for testing simplicity, we just use some pre-constructed auxiliary operators second_q_ops = self.electronic_structure_problem.second_q_ops() # Remove main op to leave just aux ops second_q_ops.pop(self.electronic_structure_problem.main_property_name) aux_ops_dict = self.qubit_converter.convert_match(second_q_ops) return calc, res, aux_ops_dict
def test_vqe_ucc_factory_with_user_initial_point(self): """Test VQEUCCFactory when using it with a user defined initial point.""" initial_point = np.asarray( [1.28074029e-19, 5.92226076e-08, 1.11762559e-01]) solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=initial_point, optimizer=SLSQP(maxiter=1), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal(res.raw_result.optimal_point, initial_point)
def test_aux_ops_reusability(self): """Test that the auxiliary operators can be reused""" # Regression test against #1475 solver = VQEUCCFactory(QuantumInstance(BasicAer.get_backend("statevector_simulator"))) calc = AdaptVQE(self.qubit_converter, solver) modes = 4 h_1 = np.eye(modes, dtype=complex) h_2 = np.zeros((modes, modes, modes, modes)) aux_ops = [build_ferm_op_from_ints(h_1, h_2)] aux_ops_copy = copy.deepcopy(aux_ops) _ = calc.solve(self.problem) assert all( frozenset(a.to_list()) == frozenset(b.to_list()) for a, b in zip(aux_ops, aux_ops_copy) )
def test_vqe_uccsd_with_callback(self): """Test VQE UCCSD with callback.""" def callback(nfev, parameters, energy, stddev): # pylint: disable=unused-argument print(f"iterations {nfev}: energy: {energy}") solver = VQEUCCFactory( quantum_instance=QuantumInstance(BasicAer.get_backend("statevector_simulator")), callback=callback, ) calc = GroundStateEigensolver(self.qubit_converter, solver) with contextlib.redirect_stdout(io.StringIO()) as out: res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) for idx, line in enumerate(out.getvalue().split("\n")): if line.strip(): self.assertTrue(line.startswith(f"iterations {idx+1}: energy: "))
def test_vqe_ucc_factory_with_mp2(self): """Test when using MP2InitialPoint to generate the initial point.""" informed_start = MP2InitialPoint() solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=informed_start, ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal( solver.initial_point.to_numpy_array(), [0.0, 0.0, -0.07197145]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def test_LiH(self): """Lih test""" driver = PySCFDriver( atom="Li .0 .0 .0; H .0 .0 1.6", unit=UnitsType.ANGSTROM, basis="sto3g", ) transformer = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=3) problem = ElectronicStructureProblem(driver, [transformer]) solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = AdaptVQE(self.qubit_converter, solver) res = calc.solve(problem) self.assertAlmostEqual(res.electronic_energies[0], -8.855126478, places=6)
def test_aux_ops_reusability(self): """Test that the auxiliary operators can be reused""" # Regression test against #1475 solver = VQEUCCFactory( QuantumInstance(BasicAer.get_backend("statevector_simulator"))) calc = AdaptVQE(self.qubit_converter, solver) modes = 4 h_1 = np.eye(modes, dtype=complex) h_2 = np.zeros((modes, modes, modes, modes)) aux_ops = ElectronicEnergy([ OneBodyElectronicIntegrals(ElectronicBasis.MO, (h_1, None)), TwoBodyElectronicIntegrals(ElectronicBasis.MO, (h_2, None, None, None)), ]).second_q_ops() aux_ops_copy = copy.deepcopy(aux_ops) _ = calc.solve(self.problem) assert all( frozenset(a.to_list()) == frozenset(b.to_list()) for a, b in zip(aux_ops, aux_ops_copy))