def test_reuse(self):
"""Test re-using a VQE algorithm instance."""
vqe = VQE()
with self.subTest(msg='assert running empty raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
var_form = TwoLocal(rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz')
vqe.var_form = var_form
with self.subTest(msg='assert missing operator raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.h2_op
with self.subTest(msg='assert missing backend raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.quantum_instance = self.statevector_simulator
with self.subTest(msg='assert VQE works once all info is available'):
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real,
self.h2_energy,
places=5)
operator = PrimitiveOp(
np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 2, 0], [0, 0, 0,
3]]))
with self.subTest(msg='assert minimum eigensolver interface works'):
result = vqe.compute_minimum_eigenvalue(operator)
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def test_vqe_auto_symmetry_freeze_core(self):
""" Auto symmetry reduction, with freeze core using VQE """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True,
orbital_reduction=None,
z2symmetry_reduction='auto')
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 6)
num_orbitals = core.molecule_info[core.INFO_NUM_ORBITALS]
num_particles = core.molecule_info[core.INFO_NUM_PARTICLES]
qubit_mapping = 'jordan_wigner'
two_qubit_reduction = core.molecule_info[core.INFO_TWO_QUBIT_REDUCTION]
z2_symmetries = core.molecule_info[core.INFO_Z2SYMMETRIES]
initial_state = HartreeFock(num_orbitals, num_particles,
qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list)
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=z2_symmetries)
vqe = VQE(qubit_op, var_form=var_form, optimizer=SLSQP(maxiter=500), aux_operators=aux_ops)
vqe.quantum_instance = BasicAer.get_backend('statevector_simulator')
result = core.process_algorithm_result(vqe.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [-1, 1, 1, -1])
def test_vqe_mes(self):
""" Test vqe minimum eigen solver interface """
ansatz = TwoLocal(rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz')
vqe = VQE(var_form=ansatz, optimizer=COBYLA())
vqe.set_backend(BasicAer.get_backend('statevector_simulator'))
result = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
def test_uccsd_hf_qUCCSD(self):
""" uccsd tapering test using all double excitations """
fermionic_transformation = FermionicTransformation(
transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[],
z2symmetry_reduction='auto')
qubit_op, _ = fermionic_transformation.transform(self.driver)
# optimizer
optimizer = SLSQP(maxiter=100)
# initial state
init_state = HartreeFock(
num_orbitals=fermionic_transformation.
molecule_info['num_orbitals'],
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction,
num_particles=fermionic_transformation.
molecule_info['num_particles'],
sq_list=fermionic_transformation.molecule_info['z2_symmetries'].
sq_list)
var_form = UCCSD(
num_orbitals=fermionic_transformation.
molecule_info['num_orbitals'],
num_particles=fermionic_transformation.
molecule_info['num_particles'],
active_occupied=None,
active_unoccupied=None,
initial_state=init_state,
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=fermionic_transformation.
molecule_info['z2_symmetries'],
shallow_circuit_concat=False,
method_doubles='ucc',
excitation_type='sd',
skip_commute_test=True)
solver = VQE(
var_form=var_form,
optimizer=optimizer,
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator')))
raw_result = solver.compute_minimum_eigenvalue(qubit_op, None)
result = fermionic_transformation.interpret(raw_result)
self.assertAlmostEqual(result.energy,
self.reference_energy_UCCSD,
places=6)
def test_vqe(self):
""" VQE test """
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
coupling_map=[[0, 1]],
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
vqe = VQE(var_form=RYRZ(self.qubit_op.num_qubits),
optimizer=L_BFGS_B(),
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def test_vqe_qasm(self):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, num_qubits)
optimizer = SPSA(max_trials=300, last_avg=5)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqe = VQE(var_form=var_form,
optimizer=optimizer,
max_evals_grouped=1,
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503, places=1)
def test_measurement_error_mitigation_with_vqe(self):
""" measurement error mitigation test with vqe """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
h2_hamiltonian = -1.052373245772859 * (I ^ I) \
+ 0.39793742484318045 * (I ^ Z) \
- 0.39793742484318045 * (Z ^ I) \
- 0.01128010425623538 * (Z ^ Z) \
+ 0.18093119978423156 * (X ^ X)
optimizer = SPSA(maxiter=200)
var_form = EfficientSU2(2, reps=1)
vqe = VQE(
var_form=var_form,
operator=h2_hamiltonian,
quantum_instance=quantum_instance,
optimizer=optimizer,
)
result = vqe.compute_minimum_eigenvalue()
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def set_vqe_circuit(self, backend = None):
#Check https://qiskit.org/documentation/tutorials/algorithms/03_vqe_simulation_with_noise.html
#seed = 170
iterations = self.vqe_options['maxiter']
#aqua_globals.random_seed = seed
if backend is None:
backend = 'statevector_simulator'
backend = Aer.get_backend(backend)
counts = []
values = []
stds = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
stds.append(std)
var_form = TwoLocal(reps = self.vqe_options['n_steps'],
rotation_blocks = 'ry',
entanglement_blocks = 'cx',
entanglement = 'linear',
insert_barriers = True)
spsa = SPSA(maxiter=iterations)
if self.vqe_options['noise']:
os.environ['QISKIT_IN_PARALLEL'] = 'TRUE'
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
qi = QuantumInstance(backend=backend,
coupling_map=coupling_map,
noise_model=noise_model)
else:
qi = QuantumInstance(backend=backend)
vqe = VQE(var_form=var_form, optimizer=spsa, callback=store_intermediate_result, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=self.H)
return vqe.get_optimal_circuit(), vqe.optimal_params, vqe.get_optimal_vector(), vqe.get_optimal_cost()
def test_vqe_mes(self):
""" Test vqe minimum eigen solver interface """
vqe = VQE(var_form=RY(self.qubit_op.num_qubits, depth=3), optimizer=COBYLA())
vqe.set_backend(BasicAer.get_backend('statevector_simulator'))
result = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
