Add conversion support for Qiskit's NoiseModels

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ### New features since last release
 
+* Added the support for converting Qiskit noise models to
+  PennyLane ``NoiseModels`` using ``load_noise_model``.
+  [(#569)](https://github.com/PennyLaneAI/pennylane-qiskit/pull/569)
+
 ### Improvements 🛠
 
 ### Breaking changes 💔
@@ -16,6 +20,9 @@
 
 This release contains contributions from (in alphabetical order):
 
+Utkarsh Azad
+
+
 ---
 # Release 0.37.0
 

pennylane_qiskit/__init__.py

@@ -18,6 +18,6 @@
 from .basic_aer import BasicAerDevice, BasicSimulatorDevice
 from .ibmq import IBMQDevice
 from .remote import RemoteDevice
-from .converter import load, load_pauli_op, load_qasm, load_qasm_from_file
+from .converter import load, load_pauli_op, load_qasm, load_qasm_from_file, load_noise_model
 from .runtime_devices import IBMQCircuitRunnerDevice
 from .runtime_devices import IBMQSamplerDevice

pennylane_qiskit/converter.py

@@ -15,15 +15,19 @@
 This module contains functions for converting Qiskit QuantumCircuit objects
 into PennyLane circuit templates.
 """
-from typing import Dict, Any, Iterable, Sequence, Union
 import warnings
 from functools import partial, reduce
+from typing import Any, Dict, Iterable, Sequence, Union
 
 import numpy as np
+import pennylane as qml
+import pennylane.ops as pennylane_ops
 import qiskit.qasm2
+from pennylane.noise.conditionals import WiresIn, _rename
+from pennylane.operation import AnyWires
 from qiskit import QuantumCircuit
+from qiskit.circuit import Barrier, Clbit, ControlFlowOp, Measure
 from qiskit.circuit import Parameter, ParameterExpression, ParameterVector
-from qiskit.circuit import Measure, Barrier, ControlFlowOp, Clbit
 from qiskit.circuit.classical import expr
 from qiskit.circuit.controlflow.switch_case import _DefaultCaseType
 from qiskit.circuit.library import GlobalPhaseGate
@@ -32,10 +36,10 @@
 from qiskit.quantum_info import SparsePauliOp
 from sympy import lambdify
 
-import pennylane as qml
-import pennylane.ops as pennylane_ops
 from pennylane_qiskit.qiskit_device import QISKIT_OPERATION_MAP
 
+from .noise_models import _build_noise_model_map
+
 # pylint: disable=too-many-instance-attributes
 
 inv_map = {v.__name__: k for k, v in QISKIT_OPERATION_MAP.items()}
@@ -1042,3 +1046,104 @@ def _expr_eval_clvals(clbits, clvals, expr_func, bitwise=False):
         condition_res = expr_func(meas1, clreg2)
 
     return condition_res
+
+
+def load_noise_model(noise_model, **kwargs) -> 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 conversion of the noise model.
+
+    Keyword Arguments:
+        thermal_relaxation (bool): prefer conversion of ``QiskitErrors`` to thermal relaxation errors
+            over damping errors. Default is ``False``.
+        readout_error (bool): include readout error in the converted noise model. Default is ``True``.
+        gate_times (Dict[Tuple(str, Tuple[int]), float]): a dictionary to provide gate times for building
+            thermal relaxation error. Each key will be a tuple of instruction name and qubit indices and
+            the corresponding value will be the time in seconds. If it is not provided or a gate/qubit
+            is missing, then a default value of ``1.0 s`` will be used for the specific constructions.
+        optimize (bool): controls if a contraction order optimization is used for ``einsum`` while
+            transforming Kraus operators to a Choi matrix, wherever required. Default is ``False``.
+        kraus_shape (bool): use shape of the Kraus operators to display ``qml.QubitChannel``
+            instead of the complete list of matrices. Default is ``True``.
+        options (dict[str, Union[int, float]]): optional parameters related to tolerance and rounding:
+
+            - **decimals** (*int*): number of decimal places to round the Kraus matrices. Default is ``10``.
+            - **atol** (*float*): the relative tolerance parameter. Default value is ``1e-05``.
+            - **rtol** (*float*): the absolute tolernace parameters. Defualt value is ``1e-08``.
+
+    Returns:
+        pennylane.NoiseModel: An equivalent noise model constructed in PennyLane
+
+    Raises:
+        ValueError: When an encountered quantum error cannoted be converted.
+
+    .. note::
+
+        Currently, PennyLane noise models does not support readout errors, so those will be skipped during conversion.
+
+    **Example**
+
+    Consider the following noise model constructed in Qiskit:
+
+    .. code-block:: python
+
+        >>> import qiskit.providers.aer.noise as noise
+        >>> error_1 = noise.depolarizing_error(0.001, 1) # 1-qubit noise
+        >>> error_2 = noise.depolarizing_error(0.01, 2) # 2-qubit noise
+        >>> noise_model = noise.NoiseModel()
+        >>> noise_model.add_all_qubit_quantum_error(error_1, ['rz', 'ry'])
+        >>> noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
+        >>> load_noise_model(noise_model)
+        NoiseModel({
+            OpIn(['RZ', 'RY']): DepolarizingChannel(p=0.00075)
+            OpIn(['CNOT']): QubitChannel(Klist=Tensor(16, 4, 4))
+        })
+
+    Equivalently, in PennyLane this will be:
+
+    .. code-block:: python
+
+        import numpy as np
+        import pennylane as qml
+        import itertools as it
+        import functools as ft
+
+        pauli_mats = [
+            ft.reduce(np.kron, prod, 1.0)
+            for prod in it.product(
+                map(qml.matrix, tuple(getattr(qml, i)(0) for i in ["I", "X", "Y", "Z"]))
+                repeat=2
+            )
+        ]
+        pauli_prob = np.sqrt(error_2.probabilities)
+        kraus_ops = [prob * kraus_op for prob, kraus_op in zip(pauli_prob, pauli_mats)]
+
+        c0 = qml.noise.op_eq(qml.RZ) | qml.noise.op_eq(qml.RY)
+        c1 = qml.noise.op_eq(qml.CNOT)
+
+        n0 = qml.noise.partial_wires(qml.DepolarizingChannel, 0.001)
+        n1 = qml.noise.partial_wires(qml.QubitChanel(kraus_ops))
+
+        equivalent_pl_noise_model = qml.NoiseModel({c0: n0, c1: n1})
+    """
+    qerror_dmap, _ = _build_noise_model_map(noise_model, **kwargs)
+    model_map = {}
+    for error, wires_map in qerror_dmap.items():
+        conditions = []
+        for wires, operations in wires_map.items():
+            cond = qml.noise.op_in(operations)
+            if wires != AnyWires:
+                cond &= WiresIn(wires)
+            conditions.append(cond)
+        fcond = reduce(lambda cond1, cond2: cond1 | cond2, conditions)
+
+        noise = qml.noise.partial_wires(error)
+        if isinstance(error, qml.QubitChannel) and kwargs.get("kraus_shape", True):
+            noise = _rename(f"QubitChannel(Klist=Tensor{qml.math.shape(error.data)})")(noise)
+
+        model_map[fcond] = noise
+
+    return qml.NoiseModel(model_map)