update EstimatorV2 and tests

Author: t-imamichi

qiskit_aer/primitives/estimator_v2.py

@@ -19,7 +19,7 @@
 
 import numpy as np
 from qiskit.primitives.base import BaseEstimatorV2
-from qiskit.primitives.containers import EstimatorPubLike, PrimitiveResult, PubResult
+from qiskit.primitives.containers import DataBin, EstimatorPubLike, PrimitiveResult, PubResult
 from qiskit.primitives.containers.estimator_pub import EstimatorPub
 from qiskit.primitives.primitive_job import PrimitiveJob
 from qiskit.quantum_info import Pauli
@@ -132,7 +132,6 @@ def _run_pub(self, pub: EstimatorPub) -> PubResult:
         ).result()
 
         # calculate expectation values (evs) and standard errors (stds)
-        rng = np.random.default_rng(self.options.run_options.get("seed_simulator"))
         flat_indices = list(param_indices.ravel())
         evs = np.zeros_like(bc_param_ind, dtype=float)
         stds = np.full(bc_param_ind.shape, precision)
@@ -143,10 +142,11 @@ def _run_pub(self, pub: EstimatorPub) -> PubResult:
                 expval = result.data(flat_index)[pauli]
                 evs[index] += expval * coeff
         if precision > 0:
-            evs = rng.normal(evs, precision)
-        data_bin_cls = self._make_data_bin(pub)
-        data_bin = data_bin_cls(evs=evs, stds=stds)
+            rng = np.random.default_rng(self.options.run_options.get("seed_simulator"))
+            if not np.all(np.isreal(evs)):
+                raise ValueError("Given operator is not Hermitian and noise cannot be added.")
+            evs = rng.normal(evs, precision, evs.shape)
         return PubResult(
-            data_bin,
+            DataBin(evs=evs, stds=stds, shape=evs.shape),
             metadata={"target_precision": precision, "simulator_metadata": result.metadata},
         )

qiskit_aer/primitives/sampler_v2.py

@@ -184,7 +184,12 @@ def _run_pubs(self, pubs: list[SamplerPub], shots: int) -> list[SamplerPubResult
             end = start + p_v.size
             results.append(
                 self._postprocess_pub(
-                    result_memory[start:end], shots, p_v.shape, meas_info, max_num_bytes
+                    result_memory[start:end],
+                    shots,
+                    p_v.shape,
+                    meas_info,
+                    max_num_bytes,
+                    result.metadata,
                 )
             )
             start = end
@@ -198,6 +203,7 @@ def _postprocess_pub(
         shape: tuple[int, ...],
         meas_info: list[_MeasureInfo],
         max_num_bytes: int,
+        metadata: dict,
     ) -> SamplerPubResult:
         """Converts the memory data into an array of bit arrays with the shape of the pub."""
         arrays = {
@@ -214,7 +220,9 @@ def _postprocess_pub(
         meas = {
             item.creg_name: BitArray(arrays[item.creg_name], item.num_bits) for item in meas_info
         }
-        return SamplerPubResult(DataBin(**meas, shape=shape), metadata={})
+        return SamplerPubResult(
+            DataBin(**meas, shape=shape), metadata={"simulator_metadata": metadata}
+        )
 
 
 def _convert_parameter_bindings(pub: SamplerPub) -> dict:

test/terra/primitives/test_estimator_v2.py

@@ -32,7 +32,7 @@
 
 
 class TestEstimatorV2(QiskitAerTestCase):
-    """Test Estimator"""
+    """Test Estimator V2"""
 
     def setUp(self):
         super().setUp()
@@ -84,6 +84,7 @@ def test_estimator_run(self):
         job = estimator.run([(psi1, ham1, [theta1])])
         result = job.result()
         np.testing.assert_allclose(result[0].data.evs, [1.5555572817900956], rtol=self._rtol)
+        self.assertIn("simulator_metadata", result[0].metadata)
 
         # Objects can be passed instead of indices.
         # Note that passing objects has an overhead
@@ -93,12 +94,14 @@ def test_estimator_run(self):
         ham1 = hamiltonian1.apply_layout(psi2.layout)
         result2 = estimator.run([(psi2, ham1, theta2)]).result()
         np.testing.assert_allclose(result2[0].data.evs, [2.97797666], rtol=self._rtol)
+        self.assertIn("simulator_metadata", result2[0].metadata)
 
         # calculate [ <psi1(theta1)|H2|psi1(theta1)>, <psi1(theta1)|H3|psi1(theta1)> ]
         ham2 = hamiltonian2.apply_layout(psi1.layout)
         ham3 = hamiltonian3.apply_layout(psi1.layout)
         result3 = estimator.run([(psi1, [ham2, ham3], theta1)]).result()
         np.testing.assert_allclose(result3[0].data.evs, [-0.551653, 0.07535239], rtol=self._rtol)
+        self.assertIn("simulator_metadata", result3[0].metadata)
 
         # calculate [ [<psi1(theta1)|H1|psi1(theta1)>,
         #              <psi1(theta3)|H3|psi1(theta3)>],
@@ -114,6 +117,8 @@ def test_estimator_run(self):
         ).result()
         np.testing.assert_allclose(result4[0].data.evs, [1.55555728, -1.08766318], rtol=self._rtol)
         np.testing.assert_allclose(result4[1].data.evs, [0.17849238], rtol=self._rtol)
+        self.assertIn("simulator_metadata", result4[0].metadata)
+        self.assertIn("simulator_metadata", result4[1].metadata)
 
     def test_estimator_with_pub(self):
         """Test estimator with explicit EstimatorPubs."""
@@ -296,10 +301,9 @@ def test_run_errors(self):
             est.run([(qc, op, None, -1)]).result()
         with self.assertRaises(ValueError):
             est.run([(qc, op)], precision=-1).result()
-        # Comment out after Qiskit 1.0.3
-        # with self.subTest("missing []"):
-        #     with self.assertRaisesRegex(ValueError, "An invalid Estimator pub-like was given"):
-        #         _ = est.run((qc, op)).result()
+        with self.subTest("missing []"):
+            with self.assertRaisesRegex(ValueError, "An invalid Estimator pub-like was given"):
+                _ = est.run((qc, op)).result()
 
     def test_run_numpy_params(self):
         """Test for numpy array as parameter values"""
@@ -347,6 +351,31 @@ def test_precision(self):
         result = job.result()
         np.testing.assert_allclose(result[0].data.evs, [1.5555572817900956], rtol=self._rtol)
 
+    def test_diff_precision(self):
+        """Test for running different precisions at once"""
+        estimator = EstimatorV2(options=self._options)
+        pm = generate_preset_pass_manager(optimization_level=0, backend=self.backend)
+        psi1 = pm.run(self.psi[0])
+        hamiltonian1 = self.hamiltonian[0].apply_layout(psi1.layout)
+        theta1 = self.theta[0]
+        job = estimator.run(
+            [(psi1, hamiltonian1, [theta1]), (psi1, hamiltonian1, [theta1], self._precision * 0.8)]
+        )
+        result = job.result()
+        np.testing.assert_allclose(result[0].data.evs, [1.901141473854881], rtol=self._rtol)
+        np.testing.assert_allclose(result[1].data.evs, [1.901141473854881], rtol=self._rtol)
+
+    def test_iter_pub(self):
+        """test for an iterable of pubs"""
+        circuit = self.ansatz.assign_parameters([0, 1, 1, 2, 3, 5])
+        pm = generate_preset_pass_manager(optimization_level=0, backend=self.backend)
+        circuit = pm.run(circuit)
+        estimator = EstimatorV2(options=self._options)
+        observable = self.observable.apply_layout(circuit.layout)
+        result = estimator.run(iter([(circuit, observable), (circuit, observable)])).result()
+        np.testing.assert_allclose(result[0].data.evs, [-1.284366511861733], rtol=self._rtol)
+        np.testing.assert_allclose(result[1].data.evs, [-1.284366511861733], rtol=self._rtol)
+
 
 if __name__ == "__main__":
     unittest.main()

test/terra/primitives/test_sampler_v2.py

@@ -22,7 +22,7 @@
 from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
 from qiskit.circuit import Parameter
 from qiskit.circuit.library import RealAmplitudes, UnitaryGate
-from qiskit.primitives import PrimitiveResult, PubResult, StatevectorSampler
+from qiskit.primitives import PrimitiveResult, SamplerPubResult, StatevectorSampler
 from qiskit.primitives.containers import BitArray
 from qiskit.primitives.containers.data_bin import DataBin
 from qiskit.primitives.containers.sampler_pub import SamplerPub
@@ -93,10 +93,11 @@ def test_sampler_run(self):
             self.assertIsInstance(result, PrimitiveResult)
             self.assertIsInstance(result.metadata, dict)
             self.assertEqual(len(result), 1)
-            self.assertIsInstance(result[0], PubResult)
+            self.assertIsInstance(result[0], SamplerPubResult)
             self.assertIsInstance(result[0].data, DataBin)
             self.assertIsInstance(result[0].data.meas, BitArray)
             self._assert_allclose(result[0].data.meas, np.array(target))
+            self.assertIn("simulator_metadata", result[0].metadata)
 
         with self.subTest("single with param"):
             pqc, param_vals, target = self._cases[2]
@@ -108,10 +109,11 @@ def test_sampler_run(self):
             self.assertIsInstance(result, PrimitiveResult)
             self.assertIsInstance(result.metadata, dict)
             self.assertEqual(len(result), 1)
-            self.assertIsInstance(result[0], PubResult)
+            self.assertIsInstance(result[0], SamplerPubResult)
             self.assertIsInstance(result[0].data, DataBin)
             self.assertIsInstance(result[0].data.meas, BitArray)
             self._assert_allclose(result[0].data.meas, np.array(target))
+            self.assertIn("simulator_metadata", result[0].metadata)
 
         with self.subTest("multiple"):
             pqc, param_vals, target = self._cases[2]
@@ -125,10 +127,11 @@ def test_sampler_run(self):
             self.assertIsInstance(result, PrimitiveResult)
             self.assertIsInstance(result.metadata, dict)
             self.assertEqual(len(result), 1)
-            self.assertIsInstance(result[0], PubResult)
+            self.assertIsInstance(result[0], SamplerPubResult)
             self.assertIsInstance(result[0].data, DataBin)
             self.assertIsInstance(result[0].data.meas, BitArray)
             self._assert_allclose(result[0].data.meas, np.array([target, target, target]))
+            self.assertIn("simulator_metadata", result[0].metadata)
 
     def test_sampler_run_multiple_times(self):
         """Test run() returns the same results if the same input is given."""
@@ -649,8 +652,8 @@ def test_iter_pub(self):
         result = sampler.run(iter([qc, qc2]), shots=self._shots).result()
         self.assertIsInstance(result, PrimitiveResult)
         self.assertEqual(len(result), 2)
-        self.assertIsInstance(result[0], PubResult)
-        self.assertIsInstance(result[1], PubResult)
+        self.assertIsInstance(result[0], SamplerPubResult)
+        self.assertIsInstance(result[1], SamplerPubResult)
         self._assert_allclose(result[0].data.meas, np.array({0: self._shots}))
         self._assert_allclose(result[1].data.meas, np.array({1: self._shots}))