Parity of noise model conversion args (#578)

* args parity

* type hint

* conditional flow

* add `changelog`

* tweak test

CHANGELOG.md

@@ -5,6 +5,7 @@
 * Added support for converting Qiskit noise models to
   PennyLane ``NoiseModels`` using ``load_noise_model``.
   [(#577)](https://github.com/PennyLaneAI/pennylane-qiskit/pull/577)
+  [(#578)](https://github.com/PennyLaneAI/pennylane-qiskit/pull/578)
 
 * Qiskit Sessions can now be used for the ``qiskit.remote`` device with the ``qiskit_session`` context
   manager.

pennylane_qiskit/converter.py

@@ -1225,19 +1225,19 @@ def _expr_eval_clvals(clbits, clvals, expr_func, bitwise=False):
     return condition_res
 
 
-def load_noise_model(noise_model, **kwargs) -> qml.NoiseModel:
+def load_noise_model(
+    noise_model, verbose: bool = False, decimal_places: Union[int, None] = None
+) -> qml.NoiseModel:
     """Loads a PennyLane `NoiseModel <https://docs.pennylane.ai/en/stable/code/api/pennylane.NoiseModel.html>`_
     from a Qiskit `noise model <https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.NoiseModel.html>`_.
 
     Args:
         noise_model (qiskit_aer.noise.NoiseModel): a Qiskit noise model object
-        kwargs: optional keyword arguments for the conversion of the noise model
-
-    Keyword Arguments:
-        verbose (bool): show a complete list of Kraus matrices for ``qml.QubitChannel`` instead of
-            number of Kraus matrices and the number of qubits they act on. The default is ``False``
-        decimal_places (int): number of decimal places to round the Kraus matrices when they are
-            being displayed for each ``qml.QubitChannel`` with ``verbose=False``.
+        verbose (bool): when printing a ``NoiseModel``, a complete list of Kraus matrices for each ``qml.QubitChannel``
+            is displayed with ``verbose=True``. By default, ``verbose=False`` and only the number of Kraus matrices and
+            the number of qubits they act on is displayed for brevity.
+        decimal_places (int | None): number of decimal places to round the elements of Kraus matrices when they are being
+            displayed for each ``qml.QubitChannel`` when ``verbose=True``.
 
     Returns:
         pennylane.NoiseModel: An equivalent noise model constructed in PennyLane
@@ -1281,14 +1281,13 @@ def load_noise_model(noise_model, **kwargs) -> qml.NoiseModel:
         fcond = reduce(lambda cond1, cond2: cond1 | cond2, conditions)
 
         noise = qml.noise.partial_wires(error)
-        if isinstance(error, qml.QubitChannel) and not kwargs.get("verbose", False):
-            kraus_shape = qml.math.shape(error.data)
-            num_kraus, num_wires = kraus_shape[0], int(np.log2(kraus_shape[1]))
-            noise = _rename(f"QubitChannel(num_kraus={num_kraus}, num_wires={num_wires})")(noise)
-
-        if isinstance(error, qml.QubitChannel) and kwargs.get("verbose", False):
-            if (decimals := kwargs.get("decimal_places", None)) is not None:
-                kraus_matrices = list(np.round(error.data, decimals=decimals))
+        if isinstance(error, qml.QubitChannel):
+            if not verbose:
+                kraus_shape = qml.math.shape(error.data)
+                n_kraus, n_wires = kraus_shape[0], int(np.log2(kraus_shape[1]))
+                noise = _rename(f"QubitChannel(num_kraus={n_kraus}, num_wires={n_wires})")(noise)
+            elif verbose and decimal_places is not None:
+                kraus_matrices = list(np.round(error.data, decimals=decimal_places))
                 noise = _rename(f"QubitChannel(Klist={kraus_matrices})")(noise)
 
         model_map[fcond] = noise

tests/test_converter.py

@@ -2610,31 +2610,31 @@ def test_build_noise_model(self):
         pl_model_map = {
             op_in("Identity")
             & wires_in(0): qml.ThermalRelaxationError(
-                pe=0.0, t1=26981.9403362283, t2=26034.6676428009, tg=1.0, wires=AnyWires
+                0.0, 26981.9403362283, 26034.6676428009, 1.0, wires=AnyWires
             ),
             op_in("Identity")
             & wires_in(1): qml.ThermalRelaxationError(
-                pe=0.0, t1=30732.034088541, t2=28335.6514829973, tg=1.0, wires=AnyWires
+                0.0, 30732.034088541, 28335.6514829973, 1.0, wires=AnyWires
             ),
             (op_in("U1") & wires_in(0))
             | (op_in("U1") & wires_in(1)): qml.DepolarizingChannel(
                 p=0.08999999999999997, wires=AnyWires
             ),
             op_in("U2")
             & wires_in(0): qml.ThermalRelaxationError(
-                pe=0.4998455776, t1=7.8227384666, t2=7.8226559459, tg=1.0, wires=AnyWires
+                0.4998455776, 7.8227384666, 7.8226559459, 1.0, wires=AnyWires
             ),
             op_in("U2")
             & wires_in(1): qml.ThermalRelaxationError(
-                pe=0.4998644198, t1=7.8227957211, t2=7.8226273195, tg=1.0, wires=AnyWires
+                0.4998644198, 7.8227957211, 7.8226273195, 1.0, wires=AnyWires
             ),
             op_in("U3")
             & wires_in(0): qml.ThermalRelaxationError(
-                pe=0.4996911588, t1=7.8227934813, t2=7.8226284393, tg=1.0, wires=AnyWires
+                0.4996911588, 7.8227934813, 7.8226284393, 1.0, wires=AnyWires
             ),
             op_in("U3")
             & wires_in(1): qml.ThermalRelaxationError(
-                pe=0.4997288404, t1=7.8229079927, t2=7.8225711871, tg=1.0, wires=AnyWires
+                0.4997288404, 7.8229079927, 7.8225711871, 1.0, wires=AnyWires
             ),
             op_in("CNOT")
             & wires_in([0, 1]): qml.QubitChannel(
@@ -2662,8 +2662,8 @@ def test_build_noise_model(self):
         "verbose, decimal",
         [(True, 8), (False, None)],
     )
-    def test_build_noise_model_with_kwargs(self, verbose, decimal):
-        """Tests that ``load_quantum_noise`` constructs a correct PennyLane NoiseModel with kwargs"""
+    def test_build_noise_model_with_args(self, verbose, decimal):
+        """Tests that ``load_quantum_noise`` constructs a correct PennyLane NoiseModel with args"""
         from qiskit_aer import noise
 
         error_1 = noise.depolarizing_error(0.001, 1)