class TestVQEAdaptUCCSD(QiskitChemistryTestCase):
""" Test Adaptive VQE with UCCSD"""
def setUp(self):
super().setUp()
# np.random.seed(50)
self.seed = 50
aqua_globals.random_seed = self.seed
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
return
molecule = 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 = Z2Symmetries.two_qubit_reduction(to_weighted_pauli_operator(qubit_op),
self.num_particles)
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):
""" VQEAdapt test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
self.var_form_base = UCCSD(self.num_spin_orbitals,
self.num_particles, initial_state=self.init_state)
backend = Aer.get_backend('statevector_simulator')
optimizer = L_BFGS_B()
algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer,
threshold=0.00001, delta=0.1)
result = algorithm.run(backend)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
self.assertIsNotNone(result.num_iterations)
self.assertIsNotNone(result.final_max_gradient)
self.assertIsNotNone(result.finishing_criterion)
class TestVQEAdaptUCCSD(QiskitAquaTestCase):
""" Test Adaptive VQE with UCCSD"""
def setUp(self):
super().setUp()
# np.random.seed(50)
self.seed = 50
aqua_globals.random_seed = self.seed
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
molecule = 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 = Z2Symmetries.two_qubit_reduction(
to_weighted_pauli_operator(qubit_op), self.num_particles)
self.num_qubits = self.qubit_op.num_qubits
self.init_state = HartreeFock(self.num_qubits, 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_qubits,
1,
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):
""" VQEAdapt test """
self.var_form_base = UCCSD(self.num_qubits,
1,
self.num_spin_orbitals,
self.num_particles,
initial_state=self.init_state)
backend = Aer.get_backend('statevector_simulator')
optimizer = L_BFGS_B()
algorithm = VQEAdapt(self.qubit_op,
self.var_form_base,
optimizer,
threshold=0.00001,
delta=0.1)
result = algorithm.run(backend)
self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
self.assertIn('num_iterations', result)
self.assertIn('final_max_grad', result)
self.assertIn('finishing_criterion', result)
class TestVQEAdaptUCCSD(QiskitChemistryTestCase):
""" Test Adaptive VQE with UCCSD"""
def setUp(self):
super().setUp()
# np.random.seed(50)
self.seed = 50
aqua_globals.random_seed = self.seed
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
return
molecule = 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 = Z2Symmetries.two_qubit_reduction(
to_weighted_pauli_operator(qubit_op), self.num_particles)
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):
""" VQEAdapt 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
self.var_form_base = UCCSD(self.num_spin_orbitals,
self.num_particles,
initial_state=self.init_state)
optimizer = L_BFGS_B()
warnings.filterwarnings('ignore', category=DeprecationWarning)
algorithm = VQEAdapt(self.qubit_op,
self.var_form_base,
optimizer,
threshold=0.00001,
delta=0.1,
max_iterations=1)
warnings.filterwarnings('always', category=DeprecationWarning)
result = algorithm.run(backend)
self.assertEqual(result.num_iterations, 1)
self.assertEqual(result.finishing_criterion,
'Maximum number of iterations reached')
warnings.filterwarnings('ignore', category=DeprecationWarning)
algorithm = VQEAdapt(self.qubit_op,
self.var_form_base,
optimizer,
threshold=0.00001,
delta=0.1)
warnings.filterwarnings('always', category=DeprecationWarning)
result = algorithm.run(backend)
self.assertAlmostEqual(result.eigenvalue.real, -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):
""" VQEAdapt 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, VQEAdapt._check_cyclicity(seq))
