def test_uccsd_hf_aer_qasm(self): """ uccsd hf test with Aer qasm_simulator. """ 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 backend = Aer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) algo = VQE(self.qubit_op, self.var_form, optimizer, expectation=PauliExpectation()) result = algo.run( QuantumInstance(backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) result = self.core.process_algorithm_result(result) self.assertAlmostEqual(result.energy, -1.138, places=2)
def convert( self, operator: OperatorBase, params: Optional[Union[ParameterVector, ParameterExpression, List[ParameterExpression]]] = None ) -> OperatorBase: r""" Args: operator: The operator we are taking the gradient of. params: params: The parameters we are taking the gradient with respect to. Returns: An operator whose evaluation yields the Gradient. Raises: ValueError: If ``params`` contains a parameter not present in ``operator``. """ if params is None: raise ValueError("No parameters were provided to differentiate") if isinstance(params, (ParameterVector, list)): param_grads = [self.convert(operator, param) for param in params] absent_params = [ params[i] for i, grad_ops in enumerate(param_grads) if grad_ops is None ] if len(absent_params) > 0: raise ValueError( "The following parameters do not appear in the provided operator: ", absent_params) return ListOp(param_grads) param = params # Preprocessing expec_op = PauliExpectation( group_paulis=False).convert(operator).reduce() cleaned_op = self._factor_coeffs_out_of_composed_op(expec_op) return self.get_gradient(cleaned_op, param)
def test_construction(self): """Test the correct operator expression is constructed.""" alpha = 0.5 base_expecation = PauliExpectation() cvar_expecation = CVaRExpectation(alpha=alpha, expectation=base_expecation) with self.subTest('single operator'): op = ~StateFn(Z) @ Plus expected = CVaRMeasurement(Z, alpha) @ Plus cvar = cvar_expecation.convert(op) self.assertEqual(cvar, expected) with self.subTest('list operator'): op = ~StateFn(ListOp([Z ^ Z, I ^ Z])) @ (Plus ^ Plus) expected = ListOp([ CVaRMeasurement((Z ^ Z), alpha) @ (Plus ^ Plus), CVaRMeasurement((I ^ Z), alpha) @ (Plus ^ Plus) ]) cvar = cvar_expecation.convert(op) self.assertEqual(cvar, expected)
def test_uccsd_hf_aer_qasm(self): """ uccsd hf test with Aer qasm_simulator. """ 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 backend = Aer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(var_form=self.var_form, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def setUp(self) -> None: super().setUp() backend = BasicAer.get_backend('qasm_simulator') self.sampler = CircuitSampler(backend, attach_results=True) self.expect = PauliExpectation()
class TestPauliExpectation(QiskitAquaTestCase): """Pauli Change of Basis Expectation tests.""" def setUp(self) -> None: super().setUp() backend = BasicAer.get_backend('qasm_simulator') self.sampler = CircuitSampler(backend, attach_results=True) self.expect = PauliExpectation() def test_pauli_expect_pair(self): """ pauli expect pair test """ op = (Z ^ Z) # wf = (Pl^Pl) + (Ze^Ze) wf = CX @ (H ^ I) @ Zero converted_meas = self.expect.convert(~StateFn(op) @ wf) self.assertAlmostEqual(converted_meas.eval(), 0, delta=.1) sampled = self.sampler.convert(converted_meas) self.assertAlmostEqual(sampled.eval(), 0, delta=.1) def test_pauli_expect_single(self): """ pauli expect single test """ paulis = [Z, X, Y, I] states = [Zero, One, Plus, Minus, S @ Plus, S @ Minus] for pauli, state in itertools.product(paulis, states): converted_meas = self.expect.convert(~StateFn(pauli) @ state) matmulmean = state.adjoint().to_matrix() @ pauli.to_matrix() @ state.to_matrix() self.assertAlmostEqual(converted_meas.eval(), matmulmean, delta=.1) sampled = self.sampler.convert(converted_meas) self.assertAlmostEqual(sampled.eval(), matmulmean, delta=.1) def test_pauli_expect_op_vector(self): """ pauli expect op vector test """ paulis_op = ListOp([X, Y, Z, I]) converted_meas = self.expect.convert(~StateFn(paulis_op)) plus_mean = (converted_meas @ Plus) np.testing.assert_array_almost_equal(plus_mean.eval(), [1, 0, 0, 1], decimal=1) sampled_plus = self.sampler.convert(plus_mean) np.testing.assert_array_almost_equal(sampled_plus.eval(), [1, 0, 0, 1], decimal=1) minus_mean = (converted_meas @ Minus) np.testing.assert_array_almost_equal(minus_mean.eval(), [-1, 0, 0, 1], decimal=1) sampled_minus = self.sampler.convert(minus_mean) np.testing.assert_array_almost_equal(sampled_minus.eval(), [-1, 0, 0, 1], decimal=1) zero_mean = (converted_meas @ Zero) np.testing.assert_array_almost_equal(zero_mean.eval(), [0, 0, 1, 1], decimal=1) sampled_zero = self.sampler.convert(zero_mean) np.testing.assert_array_almost_equal(sampled_zero.eval(), [0, 0, 1, 1], decimal=1) sum_zero = (Plus + Minus) * (.5 ** .5) sum_zero_mean = (converted_meas @ sum_zero) np.testing.assert_array_almost_equal(sum_zero_mean.eval(), [0, 0, 1, 1], decimal=1) sampled_zero_mean = self.sampler.convert(sum_zero_mean) # !!NOTE!!: Depolarizing channel (Sampling) means interference # does not happen between circuits in sum, so expectation does # not equal expectation for Zero!! np.testing.assert_array_almost_equal(sampled_zero_mean.eval(), [0, 0, 0, 1], decimal=1) for i, op in enumerate(paulis_op.oplist): mat_op = op.to_matrix() np.testing.assert_array_almost_equal(zero_mean.eval()[i], Zero.adjoint().to_matrix() @ mat_op @ Zero.to_matrix(), decimal=1) np.testing.assert_array_almost_equal(plus_mean.eval()[i], Plus.adjoint().to_matrix() @ mat_op @ Plus.to_matrix(), decimal=1) np.testing.assert_array_almost_equal(minus_mean.eval()[i], Minus.adjoint().to_matrix() @ mat_op @ Minus.to_matrix(), decimal=1) def test_pauli_expect_state_vector(self): """ pauli expect state vector test """ states_op = ListOp([One, Zero, Plus, Minus]) paulis_op = X converted_meas = self.expect.convert(~StateFn(paulis_op) @ states_op) np.testing.assert_array_almost_equal(converted_meas.eval(), [0, 0, 1, -1], decimal=1) sampled = self.sampler.convert(converted_meas) np.testing.assert_array_almost_equal(sampled.eval(), [0, 0, 1, -1], decimal=1) # Small test to see if execution results are accessible for composed_op in sampled: self.assertIn('counts', composed_op[1].execution_results) def test_pauli_expect_op_vector_state_vector(self): """ pauli expect op vector state vector test """ paulis_op = ListOp([X, Y, Z, I]) states_op = ListOp([One, Zero, Plus, Minus]) valids = [[+0, 0, 1, -1], [+0, 0, 0, 0], [-1, 1, 0, -0], [+1, 1, 1, 1]] converted_meas = self.expect.convert(~StateFn(paulis_op) @ states_op) np.testing.assert_array_almost_equal(converted_meas.eval(), valids, decimal=1) sampled = self.sampler.convert(converted_meas) np.testing.assert_array_almost_equal(sampled.eval(), valids, decimal=1) def test_not_to_matrix_called(self): """ 45 qubit calculation - literally will not work if to_matrix is somehow called (in addition to massive=False throwing an error)""" qs = 45 states_op = ListOp([Zero ^ qs, One ^ qs, (Zero ^ qs) + (One ^ qs)]) paulis_op = ListOp([Z ^ qs, (I ^ Z ^ I) ^ int(qs / 3)]) converted_meas = self.expect.convert(~StateFn(paulis_op) @ states_op) np.testing.assert_array_almost_equal(converted_meas.eval(), [[1, -1, 0], [1, -1, 0]]) def test_grouped_pauli_expectation(self): """ grouped pauli expectation test """ two_qubit_H2 = (-1.052373245772859 * I ^ I) + \ (0.39793742484318045 * I ^ Z) + \ (-0.39793742484318045 * Z ^ I) + \ (-0.01128010425623538 * Z ^ Z) + \ (0.18093119978423156 * X ^ X) wf = CX @ (H ^ I) @ Zero expect_op = PauliExpectation(group_paulis=False).convert(~StateFn(two_qubit_H2) @ wf) self.sampler._extract_circuitstatefns(expect_op) num_circuits_ungrouped = len(self.sampler._circuit_ops_cache) self.assertEqual(num_circuits_ungrouped, 5) expect_op_grouped = PauliExpectation(group_paulis=True).convert(~StateFn(two_qubit_H2) @ wf) sampler = CircuitSampler(BasicAer.get_backend('statevector_simulator')) sampler._extract_circuitstatefns(expect_op_grouped) num_circuits_grouped = len(sampler._circuit_ops_cache) self.assertEqual(num_circuits_grouped, 2) @unittest.skip(reason="IBMQ testing not available in general.") def test_ibmq_grouped_pauli_expectation(self): """ pauli expect op vector state vector test """ from qiskit import IBMQ p = IBMQ.load_account() backend = p.get_backend('ibmq_qasm_simulator') paulis_op = ListOp([X, Y, Z, I]) states_op = ListOp([One, Zero, Plus, Minus]) valids = [[+0, 0, 1, -1], [+0, 0, 0, 0], [-1, 1, 0, -0], [+1, 1, 1, 1]] converted_meas = self.expect.convert(~StateFn(paulis_op) @ states_op) sampled = CircuitSampler(backend).convert(converted_meas) np.testing.assert_array_almost_equal(sampled.eval(), valids, decimal=1) def test_multi_representation_ops(self): """ Test observables with mixed representations """ mixed_ops = ListOp([X.to_matrix_op(), H, H + I, X]) converted_meas = self.expect.convert(~StateFn(mixed_ops)) plus_mean = (converted_meas @ Plus) sampled_plus = self.sampler.convert(plus_mean) np.testing.assert_array_almost_equal(sampled_plus.eval(), [1, .5**.5, (1 + .5**.5), 1], decimal=1)
def test_h2_bopes_sampler(self): """Test BOPES Sampler on H2""" seed = 50 aqua_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)
class TestVQE(QiskitAquaTestCase): """ Test VQE """ def setUp(self): super().setUp() self.seed = 50 aqua_globals.random_seed = self.seed self.h2_op = -1.052373245772859 * (I ^ I) \ + 0.39793742484318045 * (I ^ Z) \ - 0.39793742484318045 * (Z ^ I) \ - 0.01128010425623538 * (Z ^ Z) \ + 0.18093119978423156 * (X ^ X) self.h2_energy = -1.85727503 self.ryrz_wavefunction = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') self.ry_wavefunction = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz') self.qasm_simulator = QuantumInstance( BasicAer.get_backend('qasm_simulator'), shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) self.statevector_simulator = QuantumInstance( BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed) def test_basic_aer_statevector(self): """Test the VQE on BasicAer's statevector simulator.""" wavefunction = self.ryrz_wavefunction vqe = VQE(self.h2_op, wavefunction, L_BFGS_B()) result = vqe.run( 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)) with self.subTest(msg='test eigenvalue'): self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy) with self.subTest(msg='test dimension of optimal point'): self.assertEqual(len(result.optimal_point), 16) with self.subTest(msg='assert cost_function_evals is set'): self.assertIsNotNone(result.cost_function_evals) with self.subTest(msg='assert optimizer_time is set'): self.assertIsNotNone(result.optimizer_time) def test_circuit_input(self): """Test running the VQE on a plain QuantumCircuit object.""" wavefunction = QuantumCircuit(2).compose(EfficientSU2(2)) optimizer = SLSQP(maxiter=50) vqe = VQE(self.h2_op, wavefunction, optimizer=optimizer) result = vqe.run(self.statevector_simulator) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=5) @data( (MatrixExpectation(), 1), (AerPauliExpectation(), 1), (PauliExpectation(), 2), ) @unpack def test_construct_circuit(self, expectation, num_circuits): """Test construct circuits returns QuantumCircuits and the right number of them.""" wavefunction = EfficientSU2(2, reps=1) vqe = VQE(self.h2_op, wavefunction, expectation=expectation) params = [0] * wavefunction.num_parameters circuits = vqe.construct_circuit(params) self.assertEqual(len(circuits), num_circuits) for circuit in circuits: self.assertIsInstance(circuit, QuantumCircuit) def test_legacy_operator(self): """Test the VQE accepts and converts the legacy WeightedPauliOperator.""" pauli_dict = { 'paulis': [{ "coeff": { "imag": 0.0, "real": -1.052373245772859 }, "label": "II" }, { "coeff": { "imag": 0.0, "real": 0.39793742484318045 }, "label": "IZ" }, { "coeff": { "imag": 0.0, "real": -0.39793742484318045 }, "label": "ZI" }, { "coeff": { "imag": 0.0, "real": -0.01128010425623538 }, "label": "ZZ" }, { "coeff": { "imag": 0.0, "real": 0.18093119978423156 }, "label": "XX" }] } h2_op = WeightedPauliOperator.from_dict(pauli_dict) vqe = VQE(h2_op) self.assertEqual(vqe.operator, self.h2_op) def test_missing_varform_params(self): """Test specifying a variational form with no parameters raises an error.""" circuit = QuantumCircuit(self.h2_op.num_qubits) vqe = VQE(self.h2_op, circuit) with self.assertRaises(RuntimeError): vqe.run(BasicAer.get_backend('statevector_simulator')) @data( (SLSQP(maxiter=50), 5, 4), (SPSA(maxiter=150), 3, 2), # max_evals_grouped=n or =2 if n>2 ) @unpack def test_max_evals_grouped(self, optimizer, places, max_evals_grouped): """ VQE Optimizers test """ vqe = VQE(self.h2_op, self.ryrz_wavefunction, optimizer, max_evals_grouped=max_evals_grouped, quantum_instance=self.statevector_simulator) result = vqe.run() self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=places) def test_basic_aer_qasm(self): """Test the VQE on BasicAer's QASM simulator.""" optimizer = SPSA(maxiter=300, last_avg=5) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, max_evals_grouped=1) # TODO benchmark this later. result = vqe.run(self.qasm_simulator) self.assertAlmostEqual(result.eigenvalue.real, -1.86823, places=2) def test_with_aer_statevector(self): """Test VQE with Aer's statevector_simulator.""" 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 backend = Aer.get_backend('statevector_simulator') wavefunction = self.ry_wavefunction optimizer = L_BFGS_B() vqe = VQE(self.h2_op, wavefunction, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance( backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) def test_with_aer_qasm(self): """Test VQE with Aer's qasm_simulator.""" 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 backend = Aer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, expectation=PauliExpectation()) quantum_instance = QuantumInstance( backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.86305, places=2) def test_with_aer_qasm_snapshot_mode(self): """Test the VQE using Aer's qasm_simulator snapshot mode.""" 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 backend = Aer.get_backend('qasm_simulator') optimizer = L_BFGS_B() wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, expectation=AerPauliExpectation()) quantum_instance = QuantumInstance( backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) def test_callback(self): """Test the callback on VQE.""" history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []} def store_intermediate_result(eval_count, parameters, mean, std): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['mean'].append(mean) history['std'].append(std) optimizer = COBYLA(maxiter=3) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, callback=store_intermediate_result) vqe.run(self.qasm_simulator) self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue( all(isinstance(mean, float) for mean in history['mean'])) self.assertTrue(all(isinstance(std, float) for std in history['std'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params)) 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_optimizer(self): """ Test running same VQE twice to re-use optimizer, then switch optimizer """ vqe = VQE(self.h2_op, optimizer=SLSQP(), quantum_instance=QuantumInstance( BasicAer.get_backend('statevector_simulator'))) def run_check(): result = vqe.compute_minimum_eigenvalue() self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5) run_check() with self.subTest('Optimizer re-use'): run_check() with self.subTest('Optimizer replace'): vqe.optimizer = L_BFGS_B() run_check() def test_vqe_expectation_select(self): """Test expectation selection with Aer's qasm_simulator.""" 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 backend = Aer.get_backend('qasm_simulator') with self.subTest('Defaults'): vqe = VQE(self.h2_op, quantum_instance=backend) self.assertIsInstance(vqe.expectation, PauliExpectation) with self.subTest('Include custom'): vqe = VQE(self.h2_op, include_custom=True, quantum_instance=backend) self.assertIsInstance(vqe.expectation, AerPauliExpectation) with self.subTest('Set explicitly'): vqe = VQE(self.h2_op, expectation=AerPauliExpectation(), quantum_instance=backend) self.assertIsInstance(vqe.expectation, AerPauliExpectation) @unittest.skip(reason="IBMQ testing not available in general.") def test_ibmq(self): """ IBMQ VQE Test """ from qiskit import IBMQ provider = IBMQ.load_account() backend = provider.get_backend('ibmq_qasm_simulator') ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') opt = SLSQP(maxiter=1) opt.set_max_evals_grouped(100) vqe = VQE(self.h2_op, ansatz, SLSQP(maxiter=2)) result = vqe.run(backend) print(result) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy) np.testing.assert_array_almost_equal(result.eigenvalue.real, self.h2_energy, 5) self.assertEqual(len(result.optimal_point), 16) self.assertIsNotNone(result.cost_function_evals) self.assertIsNotNone(result.optimizer_time) @data(MatrixExpectation(), None) def test_backend_change(self, user_expectation): """Test that VQE works when backend changes.""" vqe = VQE( operator=self.h2_op, var_form=TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz'), optimizer=SLSQP(maxiter=2), expectation=user_expectation, quantum_instance=BasicAer.get_backend('statevector_simulator')) result0 = vqe.run() if user_expectation is not None: with self.subTest('User expectation kept.'): self.assertEqual(vqe.expectation, user_expectation) else: with self.subTest('Expectation created.'): self.assertIsInstance(vqe.expectation, ExpectationBase) try: vqe.set_backend(BasicAer.get_backend('qasm_simulator')) except Exception as ex: # pylint: disable=broad-except self.fail("Failed to change backend. Error: '{}'".format(str(ex))) return result1 = vqe.run() if user_expectation is not None: with self.subTest( 'Change backend with user expectation, it is kept.'): self.assertEqual(vqe.expectation, user_expectation) else: with self.subTest( 'Change backend without user expectation, one created.'): self.assertIsInstance(vqe.expectation, ExpectationBase) with self.subTest('Check results.'): self.assertEqual(len(result0.optimal_point), len(result1.optimal_point))
# Calculate the expectation value for Ising Hamiltonian print('expectation_value:', psi.adjoint().compose(op).compose(psi).eval().real) # %% another way of calculating expectation # define your backend or quantum instance (where you can add settings) backend = Aer.get_backend('qasm_simulator') q_instance = QuantumInstance(backend, shots=1024) # define the state to sample measurable_expression = StateFn(op, is_measurement=True).compose(psi) # convert to expectation value expectation = PauliExpectation().convert(measurable_expression) # get state sampler (you can also pass the backend directly) sampler = CircuitSampler(q_instance).convert(expectation) # evaluate print('Sampled:', sampler.eval().real) # %% print(qc) print('Hamiltonian of Ising model:') print(H.print_details()) # %% Randomly sample Clifford circuits and calculate <H> for each one. # (E.g. only change single qubit gates, not their locations in the circuit)
class TestCVaRExpectation(QiskitAquaTestCase): """Test the CVaR expectation object.""" def test_construction(self): """Test the correct operator expression is constructed.""" alpha = 0.5 base_expecation = PauliExpectation() cvar_expecation = CVaRExpectation(alpha=alpha, expectation=base_expecation) with self.subTest('single operator'): op = ~StateFn(Z) @ Plus expected = CVaRMeasurement(Z, alpha) @ Plus cvar = cvar_expecation.convert(op) self.assertEqual(cvar, expected) with self.subTest('list operator'): op = ~StateFn(ListOp([Z ^ Z, I ^ Z])) @ (Plus ^ Plus) expected = ListOp([ CVaRMeasurement((Z ^ Z), alpha) @ (Plus ^ Plus), CVaRMeasurement((I ^ Z), alpha) @ (Plus ^ Plus) ]) cvar = cvar_expecation.convert(op) self.assertEqual(cvar, expected) def test_unsupported_expectation(self): """Assert passing an AerPauliExpectation raises an error.""" expecation = AerPauliExpectation() with self.assertRaises(NotImplementedError): _ = CVaRExpectation(alpha=1, expectation=expecation) @data(PauliExpectation(), MatrixExpectation()) def test_underlying_expectation(self, base_expecation): """Test the underlying expectation works correctly.""" cvar_expecation = CVaRExpectation(alpha=0.3, expectation=base_expecation) circuit = QuantumCircuit(2) circuit.z(0) circuit.cp(0.5, 0, 1) circuit.t(1) op = ~StateFn(CircuitOp(circuit)) @ (Plus ^ 2) cvar = cvar_expecation.convert(op) expected = base_expecation.convert(op) # test if the operators have been transformed in the same manner self.assertEqual(cvar.oplist[0].primitive, expected.oplist[0].primitive) def test_compute_variance(self): """Test if the compute_variance method works""" alphas = [0, .3, 0.5, 0.7, 1] correct_vars = [0, 0, 0, 0.8163, 1] for i, alpha in enumerate(alphas): base_expecation = PauliExpectation() cvar_expecation = CVaRExpectation(alpha=alpha, expectation=base_expecation) op = ~StateFn(Z ^ Z) @ (Plus ^ Plus) cvar_var = cvar_expecation.compute_variance(op) np.testing.assert_almost_equal(cvar_var, correct_vars[i], decimal=3)