qiskit-aer 0.17.2__cp314-cp314-win_amd64.whl

qiskit_aer/noise/noise_model.py

@@ -0,0 +1,1231 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2018, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Noise model class for Aer simulators.
+"""
+import copy
+import json
+import logging
+from typing import Optional
+from warnings import warn, catch_warnings, filterwarnings
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, Instruction, Delay, Reset
+from qiskit.circuit.library.generalized_gates import PauliGate, UnitaryGate
+from qiskit.providers import QubitProperties
+from qiskit.transpiler import PassManager
+from qiskit.utils import apply_prefix
+from .device.models import _excited_population, _truncate_t2_value
+from .device.models import basic_device_gate_errors
+from .device.models import basic_device_readout_errors
+from .errors.base_quantum_error import BaseQuantumError
+from .errors.quantum_error import QuantumError
+from .errors.readout_error import ReadoutError
+from .noiseerror import NoiseError
+from .passes import RelaxationNoisePass
+from ..backends.backend_utils import BASIS_GATES
+
+logger = logging.getLogger(__name__)
+
+
+class AerJSONEncoder(json.JSONEncoder):
+    """
+    JSON encoder for NumPy arrays and complex numbers.
+
+    This functions as the standard JSON Encoder but adds support
+    for encoding:
+        complex numbers z as lists [z.real, z.imag]
+        ndarrays as nested lists.
+    """
+
+    # pylint: disable=method-hidden,arguments-differ
+    def default(self, o):
+        if isinstance(o, np.ndarray):
+            return o.tolist()
+        if isinstance(o, complex):
+            return [o.real, o.imag]
+        if hasattr(o, "to_dict"):
+            return o.to_dict()
+        return super().default(o)
+
+
+class QuantumErrorLocation(Instruction):
+    """Instruction for referencing a multi-qubit error in a NoiseModel"""
+
+    _directive = True
+
+    def __init__(self, qerror):
+        """Construct a new quantum error location instruction.
+
+        Args:
+            qerror (QuantumError): the quantum error to reference.
+        """
+        super().__init__("qerror_loc", qerror.num_qubits, 0, [], label=qerror.id)
+
+
+class NoiseModel:
+    """Noise model class for Aer simulators.
+
+    This class is used to represent noise model for the
+    :class:`~qiskit_aer.QasmSimulator`. It can be used to construct
+    custom noise models for simulator, or to automatically generate a basic
+    device noise model for an IBMQ backend. See the
+    :mod:`~qiskit_aer.noise` module documentation for additional
+    information.
+
+    **Example: Basic device noise model**
+
+    An approximate :class:`NoiseModel` can be generated automatically from the
+    properties of real device backends from the IBMQ provider using the
+    :meth:`~NoiseModel.from_backend` method.
+
+    .. code-block:: python
+
+        from qiskit import IBMQ, Aer
+        from qiskit_aer.noise import NoiseModel
+
+        provider = IBMQ.load_account()
+        backend = provider.get_backend('ibmq_vigo')
+        noise_model = NoiseModel.from_backend(backend)
+        print(noise_model)
+
+
+    **Example: Custom noise model**
+
+    Custom noise models can be used by adding :class:`QuantumError` to circuit
+    gate, reset or measure instructions, and :class:`ReadoutError` to measure
+    instructions.
+
+    .. code-block:: python
+
+        import qiskit_aer.noise as noise
+
+        # Error probabilities
+        prob_1 = 0.001  # 1-qubit gate
+        prob_2 = 0.01   # 2-qubit gate
+
+        # Depolarizing quantum errors
+        error_1 = noise.depolarizing_error(prob_1, 1)
+        error_2 = noise.depolarizing_error(prob_2, 2)
+
+        # Add errors to noise model
+        noise_model = noise.NoiseModel()
+        noise_model.add_all_qubit_quantum_error(error_1, ['rz', 'sx', 'x'])
+        noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
+        print(noise_model)
+
+    """
+
+    # Checks for standard 1-3 qubit instructions
+    _1qubit_instructions = set(
+        [
+            "u1",
+            "u2",
+            "u3",
+            "u",
+            "p",
+            "r",
+            "rx",
+            "ry",
+            "rz",
+            "id",
+            "x",
+            "y",
+            "z",
+            "h",
+            "s",
+            "sdg",
+            "sx",
+            "sxdg",
+            "t",
+            "tdg",
+        ]
+    )
+    _2qubit_instructions = set(
+        [
+            "swap",
+            "cx",
+            "cy",
+            "cz",
+            "csx",
+            "cp",
+            "cu",
+            "cu1",
+            "cu2",
+            "cu3",
+            "rxx",
+            "ryy",
+            "rzz",
+            "rzx",
+            "ecr",
+        ]
+    )
+    _3qubit_instructions = set(["ccx", "cswap"])
+
+    def __init__(self, basis_gates=None):
+        """Initialize an empty noise model.
+
+        Args:
+            basis_gates (list[str] or None): Specify an initial basis_gates
+                for the noise model. If None a default value of ['id', 'rz', 'sx', 'cx']
+                is used (Default: None).
+
+        Additional Information:
+        Errors added to the noise model will have their instruction
+        appended to the noise model basis_gates if the instruction is in
+        the :class:`~qiskit_aer.QasmSimulator` basis_gates. If
+        the instruction is not in the
+        :class:`~qiskit_aer.QasmSimulator` basis_gates it is
+        assumed to be a label for a standard gate, and that gate should be
+        added to the `NoiseModel` basis_gates either using the init method,
+        or the :meth:`add_basis_gates` method.
+        """
+        if basis_gates is None:
+            # Default basis gates is id, rz, sx, cx so that all standard
+            # non-identity instructions can be unrolled to rz, sx, cx,
+            # and identities won't be unrolled
+            self._basis_gates = set(["id", "rz", "sx", "cx"])
+        else:
+            self._basis_gates = set(name for name, _ in self._instruction_names_labels(basis_gates))
+        # Store gates with a noise model defined
+        self._noise_instructions = set()
+        # Store qubits referenced in noise model.
+        # These include gate qubits in local quantum and readout errors.
+        self._noise_qubits = set()
+        # Default (all-qubit) quantum errors are stored as:
+        # dict(str: QuantumError)
+        # where they keys are the instruction str label
+        self._default_quantum_errors = {}
+        # Local quantum errors are stored as:
+        # dict(str: dict(tuple: QuantumError))
+        # where the outer keys are the instruction str label and the
+        # inner dict keys are the gate qubits
+        self._local_quantum_errors = {}
+        # Default (all-qubit) readout error is stored as a single
+        # ReadoutError object since there may only be one defined.
+        self._default_readout_error = None
+        # Local readout errors are stored as:
+        # dict(tuple: ReadoutError)
+        # where the dict keys are the gate qubits.
+        self._local_readout_errors = {}
+        # Custom noise passes
+        self._custom_noise_passes = []
+
+    @property
+    def basis_gates(self):
+        """Return basis_gates for compiling to the noise model."""
+        # Convert noise instructions to basis_gates string
+        return sorted(self._basis_gates)
+
+    @property
+    def noise_instructions(self):
+        """Return the set of noisy instructions for this noise model."""
+        return sorted(self._noise_instructions)
+
+    @property
+    def noise_qubits(self):
+        """Return the set of noisy qubits for this noise model."""
+        return sorted(self._noise_qubits)
+
+    @classmethod
+    def from_backend(
+        cls,
+        backend,
+        gate_error=True,
+        readout_error=True,
+        thermal_relaxation=True,
+        temperature=0,
+        gate_lengths=None,
+        gate_length_units="ns",
+        warnings=None,
+    ):
+        """Return a noise model derived from a devices backend properties.
+
+        This function generates a noise model based on:
+
+        * 1 and 2 qubit gate errors consisting of a
+          :func:`depolarizing_error` followed
+          by a :func:`thermal_relaxation_error`.
+
+        * Single qubit :class:`ReadoutError` on all measurements.
+
+        The error (noise) parameters are tuned for each individual qubit based on
+        the :math:`T_1`, :math:`T_2`, frequency and readout error parameters for
+        each qubit, and the gate error and gate time parameters for each gate
+        obtained from the device backend properties.
+
+        Note that if un-physical parameters are supplied, they are internally truncated to
+        the theoretical bound values. For example, if :math:`T_2 > 2 T_1`, :math:`T_2`
+        parameter will be truncated to :math:`2 T_1`.
+
+        **Additional Information**
+
+        The noise model includes the following errors:
+
+        * If ``readout_error=True`` include single qubit readout
+          errors on measurements.
+
+        * If ``gate_error=True`` and ``thermal_relaxation=True`` include:
+
+            * Single-qubit gate errors consisting of a :func:`depolarizing_error`
+              followed by a :func:`thermal_relaxation_error` for the qubit the
+              gate acts on.
+
+            * Two-qubit gate errors consisting of a 2-qubit
+              :func:`depolarizing_error` followed by single qubit
+              :func:`thermal_relaxation_error` on each qubit participating in
+              the gate.
+
+        * If ``gate_error=True`` is ``True`` and ``thermal_relaxation=False``:
+
+            * An N-qubit :func:`depolarizing_error` on each N-qubit gate.
+
+        * If ``gate_error=False`` and ``thermal_relaxation=True`` include
+          single-qubit :func:`thermal_relaxation_errors` on each qubits
+          participating in a multi-qubit gate.
+
+        For best practice in simulating a backend make sure that the
+        circuit is compiled using the set of basis gates in the noise
+        module by setting ``basis_gates=noise_model.basis_gates``
+        and using the device coupling map with
+        ``coupling_map=backend.configuration().coupling_map``
+
+        **Specifying custom gate times**
+
+        The ``gate_lengths`` kwarg can be used to specify custom gate times
+        to add gate errors using the :math:`T_1` and :math:`T_2` values from
+        the backend properties. This should be passed as a list of tuples
+        ``gate_lengths=[(name, value), ...]``
+        where ``name`` is the gate name string, and ``value`` is the gate time
+        in nanoseconds.
+
+        If a custom gate is specified that already exists in
+        the backend properties, the ``gate_lengths`` value will override the
+        gate time value from the backend properties.
+        If non-default values are used gate_lengths should be a list
+
+        Args:
+            backend (Backend): backend. For BackendV2, `warnings`
+                               options are ignored, and their default values are used.
+            gate_error (bool): Include depolarizing gate errors (Default: True).
+            readout_error (Bool): Include readout errors in model
+                                  (Default: True).
+            thermal_relaxation (Bool): Include thermal relaxation errors
+                                       (Default: True).
+            temperature (double): qubit temperature in milli-Kelvin (mK) for
+                                  thermal relaxation errors (Default: 0).
+            gate_lengths (list): Custom gate times for thermal relaxation errors.
+                                  Used to extend or override the gate times in
+                                  the backend properties (Default: None))
+            gate_length_units (str): Time units for gate length values in
+                                     gate_lengths. Can be 'ns', 'ms', 'us',
+                                     or 's' (Default: 'ns').
+            warnings (bool): DEPRECATED, Display warnings (Default: None).
+
+        Returns:
+            NoiseModel: An approximate noise model for the device backend.
+
+        Raises:
+            NoiseError: If the input backend is not valid.
+        """
+        if warnings is not None:
+            warn(
+                '"warnings" argument has been deprecated as of qiskit-aer 0.12.0 '
+                "and will be removed no earlier than 3 months from that release date. "
+                "Use the warnings filter in Python standard library instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        else:
+            warnings = True
+
+        backend_interface_version = getattr(backend, "version", None)
+        if not isinstance(backend_interface_version, int):
+            backend_interface_version = 0
+
+        target = None
+        if backend_interface_version == 2:
+            if not warnings:
+                warn(
+                    "When a BackendV2 is supplied, `warnings`"
+                    " are ignored, and their default values are used.",
+                    UserWarning,
+                )
+            properties = None
+            basis_gates = backend.operation_names
+            target = backend.target
+            if gate_lengths:
+                # Update target based on gate_lengths and gate_length_units
+                target = copy.deepcopy(target)
+                for op_name, qubits, value in gate_lengths:
+                    prop = target[op_name][qubits]
+                    prop.duration = apply_prefix(value, gate_length_units)  # convert to seconds
+                    target.update_instruction_properties(op_name, qubits, prop)
+            all_qubit_properties = backend.target.qubit_properties
+            if not all_qubit_properties:
+                warn(
+                    f"Qiskit backend {backend} has no QubitProperties, so the resulting"
+                    " noise model will not include any thermal relaxation errors.",
+                    UserWarning,
+                )
+            dt = backend.dt
+        elif backend_interface_version <= 1:
+            # BackendV1 will be removed in Qiskit 2.0, so we will remove this soon
+            warn(
+                " from_backend using V1 based backend is deprecated as of Aer 0.15"
+                " and will be removed no sooner than 3 months from that release"
+                " date. Please use backends based on V2.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            properties = backend.properties()
+            configuration = backend.configuration()
+            basis_gates = configuration.basis_gates
+            all_qubit_properties = [
+                QubitProperties(
+                    t1=properties.t1(q), t2=properties.t2(q), frequency=properties.frequency(q)
+                )
+                for q in range(configuration.num_qubits)
+            ]
+            dt = getattr(configuration, "dt", 0)
+            if not properties:
+                raise NoiseError(f"Qiskit backend {backend} does not have a BackendProperties")
+        else:
+            raise NoiseError(f"{backend} is not a Qiskit backend")
+
+        noise_model = NoiseModel(basis_gates=basis_gates)
+
+        # Add single-qubit readout errors
+        if readout_error:
+            for qubits, error in basic_device_readout_errors(properties, target=target):
+                noise_model.add_readout_error(error, qubits, warnings=warnings)
+
+        # Add gate errors
+        with catch_warnings():
+            filterwarnings("ignore", category=DeprecationWarning, module="qiskit_aer.noise")
+            gate_errors = basic_device_gate_errors(
+                properties,
+                gate_error=gate_error,
+                thermal_relaxation=thermal_relaxation,
+                gate_lengths=gate_lengths,
+                gate_length_units=gate_length_units,
+                temperature=temperature,
+                warnings=warnings,
+                target=target,
+            )
+        for name, qubits, error in gate_errors:
+            noise_model.add_quantum_error(error, name, qubits, warnings=warnings)
+
+        if thermal_relaxation and all_qubit_properties:
+            # Add delay errors via RelaxationNiose pass
+            try:
+                excited_state_populations = [
+                    _excited_population(freq=q.frequency, temperature=temperature)
+                    for q in all_qubit_properties
+                ]
+            except ValueError:
+                excited_state_populations = None
+            try:
+                t1s = [prop.t1 for prop in all_qubit_properties]
+                t2s = [_truncate_t2_value(prop.t1, prop.t2) for prop in all_qubit_properties]
+                delay_pass = RelaxationNoisePass(
+                    t1s=[np.inf if x is None else x for x in t1s],  # replace None with np.inf
+                    t2s=[np.inf if x is None else x for x in t2s],  # replace None with np.inf
+                    dt=dt,
+                    op_types=Delay,
+                    excited_state_populations=excited_state_populations,
+                    target=target,
+                )
+                noise_model._custom_noise_passes.append(delay_pass)
+            except ValueError:
+                # Device does not have the required T1 or T2 information
+                # in its properties
+                pass
+
+        return noise_model
+
+    @classmethod
+    def from_backend_properties(
+        cls,
+        backend_properties: "BackendProperties",
+        gate_error: bool = True,
+        readout_error: bool = True,
+        thermal_relaxation: bool = True,
+        temperature: float = 0,
+        gate_lengths: Optional[list] = None,
+        gate_length_units: str = "ns",
+        dt: Optional[float] = None,
+    ):
+        """Return a noise model derived from a backend properties.
+        We assume the structure of the class `BackendProperties` in `qiskit-ibm-runtime`
+
+        This method basically generates a noise model in the same way as
+        :meth:`~.NoiseModel.from_backend`. One small difference is that the ``dt`` option is
+        required to be set manually if you want to add thermal relaxation noises to delay
+        instructions with durations in ``dt`` time unit. Because it is not supplied by a
+        :class:`BackendProperties` object unlike a :class:`Backend` object.
+        Note that the resulting noise model is the same as described in
+        :meth:`~.NoiseModel.from_backend` so please refer to it for the details.
+
+        Args:
+            backend_properties (BackendProperties): The property of backend.
+                We assume the structure of the class `BackendProperties` in `qiskit-ibm-runtime`
+            gate_error (Bool): Include depolarizing gate errors (Default: True).
+            readout_error (Bool): Include readout errors in model (Default: True).
+            thermal_relaxation (Bool): Include thermal relaxation errors (Default: True).
+                If no ``t1`` and ``t2`` values are provided (i.e. None) in ``target`` for a qubit,
+                an identity ``QuantumError` (i.e. effectively no thermal relaxation error)
+                will be added to the qubit even if this flag is set to True.
+                If no ``frequency`` is not defined (i.e. None) in ``target`` for a qubit,
+                no excitation is considered in the thermal relaxation error on the qubit
+                even with non-zero ``temperature``.
+            temperature (double): qubit temperature in milli-Kelvin (mK) for
+                                  thermal relaxation errors (Default: 0).
+            gate_lengths (Optional[list]): Custom gate times for thermal relaxation errors.
+                                  Used to extend or override the gate times in
+                                  the backend properties (Default: None))
+            gate_length_units (str): Time units for gate length values in
+                                     gate_lengths. Can be 'ns', 'ms', 'us',
+                                     or 's' (Default: 'ns').
+            dt (Optional[float]): Backend sample time (resolution) in seconds (Default: None).
+                        Required to convert time unit of durations to seconds
+                        if including thermal relaxation errors on delay instructions.
+
+        Returns:
+            NoiseModel: An approximate noise model for the device backend.
+
+        Raises:
+            NoiseError: If the input backend properties are not valid.
+        """
+        for required_field in ["gates", "qubits", "frequency", "t1", "t2"]:
+            if not hasattr(backend_properties, required_field):
+                raise NoiseError(
+                    f"Backend properties are missing the required field '{required_field}'"
+                )
+        basis_gates = set()
+        for prop in backend_properties.gates:
+            basis_gates.add(prop.gate)
+        basis_gates = list(basis_gates)
+        num_qubits = len(backend_properties.qubits)
+        noise_model = NoiseModel(basis_gates=basis_gates)
+
+        # Add single-qubit readout errors
+        if readout_error:
+            for qubits, error in basic_device_readout_errors(backend_properties):
+                noise_model.add_readout_error(error, qubits)
+
+        gate_errors = basic_device_gate_errors(
+            backend_properties,
+            gate_error=gate_error,
+            thermal_relaxation=thermal_relaxation,
+            gate_lengths=gate_lengths,
+            gate_length_units=gate_length_units,
+            temperature=temperature,
+        )
+        for name, qubits, error in gate_errors:
+            noise_model.add_quantum_error(error, name, qubits)
+
+        if thermal_relaxation:
+            # Add delay errors via RelaxationNiose pass
+            try:
+                excited_state_populations = [
+                    _excited_population(
+                        freq=backend_properties.frequency(q), temperature=temperature
+                    )
+                    for q in range(num_qubits)
+                ]
+            except ValueError:
+                excited_state_populations = None
+            try:
+                delay_pass = RelaxationNoisePass(
+                    t1s=[backend_properties.t1(q) for q in range(num_qubits)],
+                    t2s=[
+                        _truncate_t2_value(backend_properties.t1(q), backend_properties.t2(q))
+                        for q in range(num_qubits)
+                    ],
+                    dt=dt,
+                    op_types=Delay,
+                    excited_state_populations=excited_state_populations,
+                )
+                noise_model._custom_noise_passes.append(delay_pass)
+            except ValueError:
+                # Device does not have the required T1 or T2 information
+                # in its properties
+                pass
+
+        return noise_model
+
+    def is_ideal(self):  # pylint: disable=too-many-return-statements
+        """Return True if the noise model has no noise terms."""
+        # Get default errors
+        if self._default_quantum_errors:
+            return False
+        if self._default_readout_error:
+            return False
+        if self._local_quantum_errors:
+            return False
+        if self._local_readout_errors:
+            return False
+        if self._custom_noise_passes:
+            return False
+        return True
+
+    def __repr__(self):
+        """Noise model repr"""
+        return "<NoiseModel on {}>".format(list(self._noise_instructions))
+
+    def __str__(self):
+        """Noise model string representation"""
+
+        # Check if noise model is ideal
+        if self.is_ideal():
+            return "NoiseModel: Ideal"
+
+        # Get default errors
+        default_error_ops = []
+        for inst in self._default_quantum_errors:
+            default_error_ops.append("{}".format(inst))
+        if self._default_readout_error is not None:
+            if "measure" not in default_error_ops:
+                default_error_ops.append("measure")
+
+        # Get local errors
+        local_error_ops = []
+        for inst, dic in self._local_quantum_errors.items():
+            for qubits in dic.keys():
+                local_error_ops.append((inst, qubits))
+        for qubits in self._local_readout_errors:
+            tmp = ("measure", qubits)
+            if tmp not in local_error_ops:
+                local_error_ops.append(tmp)
+
+        output = "NoiseModel:"
+        output += "\n  Basis gates: {}".format(self.basis_gates)
+        if self._noise_instructions:
+            output += "\n  Instructions with noise: {}".format(list(self._noise_instructions))
+        if self._noise_qubits:
+            output += "\n  Qubits with noise: {}".format(list(self._noise_qubits))
+        if default_error_ops:
+            output += "\n  All-qubits errors: {}".format(default_error_ops)
+        if local_error_ops:
+            output += "\n  Specific qubit errors: {}".format(local_error_ops)
+        return output
+
+    def __eq__(self, other):
+        """Test if two noise models are equal."""
+        # This returns True if both noise models have:
+        # the same basis_gates
+        # the same noise_qubits
+        # the same noise_instructions
+        if (
+            not isinstance(other, NoiseModel)
+            or self.basis_gates != other.basis_gates
+            or self.noise_qubits != other.noise_qubits
+            or self.noise_instructions != other.noise_instructions
+        ):
+            return False
+        # Check default readout errors is equal
+        if not self._readout_errors_equal(other):
+            return False
+        # Check quantum errors equal
+        if not self._all_qubit_quantum_errors_equal(other):
+            return False
+        if not self._local_quantum_errors_equal(other):
+            return False
+        # If we made it here they are equal
+        return True
+
+    def reset(self):
+        """Reset the noise model."""
+        self.__init__()  # pylint: disable = unnecessary-dunder-call
+
+    def add_basis_gates(self, instructions):
+        """Add additional gates to the noise model basis_gates.
+
+        This should be used to add any gates that are identified by a
+        custom gate label in the noise model.
+
+        Args:
+            instructions (list[str] or
+                          list[Instruction]): the instructions error applies to.
+        """
+        for name, _ in self._instruction_names_labels(instructions):
+            # If the instruction is in the default basis gates for the
+            # AerSimulator we add it to the basis gates.
+            if name in BASIS_GATES["automatic"]:
+                if name not in ["measure", "reset", "initialize", "kraus", "superop", "roerror"]:
+                    self._basis_gates.add(name)
+
+    def add_all_qubit_quantum_error(self, error, instructions, warnings=True):
+        """
+        Add a quantum error to the noise model that applies to all qubits.
+
+        Args:
+            error (QuantumError): the quantum error object.
+            instructions (str or list[str] or
+                          Instruction or
+                          list[Instruction]): the instructions error applies to.
+            warnings (bool): Display warning if appending to an instruction that
+                             already has an error (Default: True).
+
+        Raises:
+            NoiseError: if the input parameters are invalid.
+
+        Additional Information:
+            If the error object is ideal it will not be added to the model.
+        """
+        # Format input as QuantumError
+        if not isinstance(error, BaseQuantumError):
+            try:
+                error = QuantumError(error)
+            except NoiseError as ex:
+                raise NoiseError("Input is not a valid quantum error.") from ex
+        # Check if error is ideal and if so don't add to the noise model
+        if error.ideal():
+            return
+
+        # Add instructions
+        for name, label in self._instruction_names_labels(instructions):
+            self._check_number_of_qubits(error, name)
+            if label in self._default_quantum_errors:
+                new_error = self._default_quantum_errors[label].compose(error)
+                self._default_quantum_errors[label] = new_error
+                if warnings:
+                    logger.warning(
+                        "WARNING: all-qubit error already exists for "
+                        'instruction "%s", '
+                        "composing with additional error.",
+                        label,
+                    )
+            else:
+                self._default_quantum_errors[label] = error
+            # Check if a specific qubit error has been applied for this instruction
+            if label in self._local_quantum_errors:
+                local_qubits = self._keys2str(self._local_quantum_errors[label].keys())
+                if warnings:
+                    logger.warning(
+                        "WARNING: all-qubit error for instruction "
+                        '"%s" will not apply to qubits: '
+                        "%s as specific error already exists.",
+                        label,
+                        local_qubits,
+                    )
+            self._noise_instructions.add(label)
+            self.add_basis_gates(name)
+
+    def add_quantum_error(self, error, instructions, qubits, warnings=True):
+        """
+        Add a quantum error to the noise model.
+
+        Args:
+            error (QuantumError): the quantum error object.
+            instructions (str or list[str] or
+                          Instruction or
+                          list[Instruction]): the instructions error applies to.
+            qubits (Sequence[int]): qubits instruction error applies to.
+            warnings (bool): Display warning if appending to an instruction that
+                             already has an error (Default: True).
+
+        Raises:
+            NoiseError: if the input parameters are invalid.
+
+        Additional Information:
+            If the error object is ideal it will not be added to the model.
+        """
+        # Error checking
+        if not isinstance(error, BaseQuantumError):
+            try:
+                error = QuantumError(error)
+            except NoiseError as ex:
+                raise NoiseError("Input is not a valid quantum error.") from ex
+        try:
+            qubits = tuple(qubits)
+        except TypeError as ex:
+            raise NoiseError("Qubits must be convertible to a tuple of integers") from ex
+        # Check if error is ideal and if so don't add to the noise model
+        if error.ideal():
+            return
+        # Add noise qubits
+        for qubit in qubits:
+            self._noise_qubits.add(qubit)
+        # Add instructions
+        for name, label in self._instruction_names_labels(instructions):
+            self._check_number_of_qubits(error, name)
+            if not isinstance(label, str):
+                raise NoiseError("QuantumCircuit invalid instructions.")
+            # Check number of qubits is correct for standard instructions
+            self._check_number_of_qubits(error, name)
+            if label in self._local_quantum_errors:
+                qubit_dict = self._local_quantum_errors[label]
+            else:
+                qubit_dict = {}
+
+            # Convert qubits list to hashable string
+            if error.num_qubits != len(qubits):
+                raise NoiseError(
+                    "Number of qubits ({}) does not match "
+                    " the error size ({})".format(len(qubits), error.num_qubits)
+                )
+            if qubits in qubit_dict:
+                new_error = qubit_dict[qubits].compose(error)
+                qubit_dict[qubits] = new_error
+                if warnings:
+                    logger.warning(
+                        "WARNING: quantum error already exists for "
+                        'instruction "%s" on qubits %s '
+                        ", appending additional error.",
+                        label,
+                        qubits,
+                    )
+            else:
+                qubit_dict[qubits] = error
+            # Add updated dictionary
+            self._local_quantum_errors[label] = qubit_dict
+
+            # Check if all-qubit error is already defined for this instruction
+            if label in self._default_quantum_errors:
+                if warnings:
+                    logger.warning(
+                        'WARNING: Specific error for instruction "%s" '
+                        "on qubits %s overrides previously defined "
+                        "all-qubit error for these qubits.",
+                        label,
+                        qubits,
+                    )
+            self._noise_instructions.add(label)
+            self.add_basis_gates(name)
+
+    def add_all_qubit_readout_error(self, error, warnings=True):
+        """
+        Add a single-qubit readout error that applies measure on all qubits.
+
+        Args:
+            error (ReadoutError): the quantum error object.
+            warnings (bool): Display warning if appending to an instruction that
+                             already has an error (Default: True)
+
+        Raises:
+            NoiseError: if the input parameters are invalid.
+
+        Additional Information:
+            If the error object is ideal it will not be added to the model.
+        """
+
+        # Error checking
+        if not isinstance(error, ReadoutError):
+            try:
+                error = ReadoutError(error)
+            except NoiseError as ex:
+                raise NoiseError("Input is not a valid readout error.") from ex
+
+        # Check if error is ideal and if so don't add to the noise model
+        if error.ideal():
+            return
+
+        # Check number of qubits is correct for standard instructions
+        if error.number_of_qubits != 1:
+            raise NoiseError("All-qubit readout errors must defined as single-qubit errors.")
+        if self._default_readout_error is not None:
+            if warnings:
+                logger.warning(
+                    "WARNING: all-qubit readout error already exists, "
+                    "overriding with new readout error."
+                )
+        self._default_readout_error = error
+
+        # Check if a specific qubit error has been applied for this instruction
+        if self._local_readout_errors:
+            local_qubits = self._keys2str(self._local_readout_errors.keys())
+            if warnings:
+                logger.warning(
+                    "WARNING: The all-qubit readout error will not "
+                    "apply to measure of qubits qubits: %s "
+                    "as specific readout errors already exist.",
+                    local_qubits,
+                )
+        self._noise_instructions.add("measure")
+
+    def add_readout_error(self, error, qubits, warnings=True):
+        """
+        Add a readout error to the noise model.
+
+        Args:
+            error (ReadoutError): the quantum error object.
+            qubits (list[int] or tuple[int]): qubits instruction error applies to.
+            warnings (bool): Display warning if appending to an instruction that
+                             already has an error [Default: True]
+
+        Raises:
+            NoiseError: if the input parameters are invalid.
+
+        Additional Information:
+            If the error object is ideal it will not be added to the model.
+        """
+
+        # Error checking
+        if not isinstance(error, ReadoutError):
+            try:
+                error = ReadoutError(error)
+            except NoiseError as ex:
+                raise NoiseError("Input is not a valid readout error.") from ex
+        try:
+            qubits = tuple(qubits)
+        except TypeError as ex:
+            raise NoiseError("Qubits must be convertible to a tuple of integers") from ex
+
+        # Check if error is ideal and if so don't add to the noise model
+        if error.ideal():
+            return
+
+        # Add noise qubits
+        for qubit in qubits:
+            self._noise_qubits.add(qubit)
+
+        # Check error matches qubit size
+        if error.number_of_qubits != len(qubits):
+            raise NoiseError(
+                "Number of qubits ({}) does not match the readout "
+                "error size ({})".format(len(qubits), error.number_of_qubits)
+            )
+        # Check if we are overriding a previous error
+        if qubits in self._local_readout_errors:
+            if warnings:
+                logger.warning(
+                    "WARNING: readout error already exists for qubits "
+                    "%s, overriding with new readout error.",
+                    qubits,
+                )
+        self._local_readout_errors[qubits] = error
+
+        # Check if all-qubit readout error is already defined
+        if self._default_readout_error is not None:
+            if warnings:
+                logger.warning(
+                    "WARNING: Specific readout error on qubits "
+                    "%s overrides previously defined "
+                    "all-qubit readout error for these qubits.",
+                    qubits,
+                )
+        self._noise_instructions.add("measure")
+
+    def to_dict(self, serializable=False):
+        """
+        Return the noise model as a dictionary.
+
+        Args:
+            serializable (bool): if `True`, return a dict containing only types
+                that can be serializable by the stdlib `json` module.
+
+        Returns:
+            dict: a dictionary for a noise model.
+        """
+        error_list = []
+
+        # Add default quantum errors
+        for name, error in self._default_quantum_errors.items():
+            error_dict = error.to_dict()
+            error_dict["operations"] = [name]
+            error_list.append(error_dict)
+
+        # Add specific qubit errors
+        for name, qubit_dict in self._local_quantum_errors.items():
+            for qubits, error in qubit_dict.items():
+                error_dict = error.to_dict()
+                error_dict["operations"] = [name]
+                error_dict["gate_qubits"] = [qubits]
+                error_list.append(error_dict)
+
+        # Add default readout error
+        if self._default_readout_error is not None:
+            error_dict = self._default_readout_error.to_dict()
+            error_list.append(error_dict)
+
+        # Add local readout error
+        for qubits, error in self._local_readout_errors.items():
+            error_dict = error.to_dict()
+            error_dict["gate_qubits"] = [qubits]
+            error_list.append(error_dict)
+
+        ret = {"errors": error_list}
+        if serializable:
+            ret = json.loads(json.dumps(ret, cls=AerJSONEncoder))
+
+        return ret
+
+    @staticmethod
+    def from_dict(noise_dict):
+        """
+        Load NoiseModel from a dictionary.
+        Args:
+            noise_dict (dict): A serialized noise model.
+        Returns:
+            NoiseModel: the noise model.
+        Raises:
+            NoiseError: if dict cannot be converted to NoiseModel.
+        """
+        warn(
+            "from_dict has been deprecated as of qiskit-aer 0.15.0"
+            " and will be removed no earlier than 3 months from that release date.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        def inst_dic_list_to_circuit(dic_list):
+            num_qubits = max(max(dic["qubits"]) for dic in dic_list) + 1
+            circ = QuantumCircuit(num_qubits)
+            for dic in dic_list:
+                if dic["name"] == "reset":
+                    circ.append(Reset(), qargs=dic["qubits"])
+                elif dic["name"] == "kraus":
+                    circ.append(
+                        Instruction(
+                            name="kraus",
+                            num_qubits=len(dic["qubits"]),
+                            num_clbits=0,
+                            params=dic["params"],
+                        ),
+                        qargs=dic["qubits"],
+                    )
+                elif dic["name"] == "unitary":
+                    circ.append(UnitaryGate(data=dic["params"][0]), qargs=dic["qubits"])
+                elif dic["name"] == "pauli":
+                    circ.append(PauliGate(dic["params"][0]), qargs=dic["qubits"])
+                else:
+                    with catch_warnings():
+                        filterwarnings(
+                            "ignore",
+                            category=DeprecationWarning,
+                            module="qiskit_aer.noise.errors.errorutils",
+                        )
+                        circ.append(
+                            UnitaryGate(
+                                label=dic["name"], data=_standard_gate_unitary(dic["name"])
+                            ),
+                            qargs=dic["qubits"],
+                        )
+            return circ
+
+        # Return noise model
+        noise_model = NoiseModel()
+
+        # Get error terms
+        errors = noise_dict.get("errors", [])
+
+        for error in errors:
+            error_type = error["type"]
+
+            # Add QuantumError
+            if error_type == "qerror":
+                circuits = [inst_dic_list_to_circuit(dics) for dics in error["instructions"]]
+                noise_ops = tuple(zip(circuits, error["probabilities"]))
+                qerror = QuantumError(noise_ops)
+                qerror._id = error.get("id", None) or qerror.id
+                instruction_names = error["operations"]
+                all_gate_qubits = error.get("gate_qubits", None)
+                if all_gate_qubits is not None:
+                    for gate_qubits in all_gate_qubits:
+                        # Add local quantum error
+                        noise_model.add_quantum_error(
+                            qerror, instruction_names, gate_qubits, warnings=False
+                        )
+                else:
+                    # Add all-qubit quantum error
+                    noise_model.add_all_qubit_quantum_error(
+                        qerror, instruction_names, warnings=False
+                    )
+
+            # Add ReadoutError
+            elif error_type == "roerror":
+                probabilities = error["probabilities"]
+                all_gate_qubits = error.get("gate_qubits", None)
+                roerror = ReadoutError(probabilities)
+                # Add local readout error
+                if all_gate_qubits is not None:
+                    for gate_qubits in all_gate_qubits:
+                        noise_model.add_readout_error(roerror, gate_qubits, warnings=False)
+                # Add all-qubit readout error
+                else:
+                    noise_model.add_all_qubit_readout_error(roerror, warnings=False)
+            # Invalid error type
+            else:
+                raise NoiseError("Invalid error type: {}".format(error_type))
+        return noise_model
+
+    def _instruction_names_labels(self, instructions):
+        """Return two lists of instruction name strings and label strings."""
+        if not isinstance(instructions, (list, tuple)):
+            instructions = [instructions]
+        names_labels = []
+        for inst in instructions:
+            # If instruction does not have a label we use the name
+            # as the label
+            if isinstance(inst, Instruction):
+                name = inst.name
+                label = getattr(inst, "label", inst.name)
+                names_labels.append((name, label))
+            elif isinstance(inst, str):
+                names_labels.append((inst, inst))
+            else:
+                raise NoiseError("Invalid instruction type {}".format(inst))
+        return names_labels
+
+    def _check_number_of_qubits(self, error, name):
+        """
+        Check if error is corrected number of qubits for standard instruction.
+
+        Args:
+            error (QuantumError): the quantum error object.
+            name (str): qobj instruction name to apply error to.
+
+        Raises:
+            NoiseError: If instruction and error qubit number do not match.
+        """
+
+        def error_message(gate_qubits):
+            msg = (
+                "{} qubit QuantumError".format(error.num_qubits)
+                + " cannot be applied to {} qubit".format(gate_qubits)
+                + ' instruction "{}".'.format(name)
+            )
+            return msg
+
+        if name in self._1qubit_instructions and error.num_qubits != 1:
+            raise NoiseError(error_message(1))
+        if name in self._2qubit_instructions and error.num_qubits != 2:
+            raise NoiseError(error_message(2))
+        if name in self._3qubit_instructions and error.num_qubits != 3:
+            raise NoiseError(error_message(3))
+
+    def _keys2str(self, keys):
+        """Convert dicitonary keys to comma seperated print string."""
+        tmp = "".join(["{}, ".format(key) for key in keys])
+        return tmp[:-2]
+
+    def _readout_errors_equal(self, other):
+        """Check two noise models have equal readout errors"""
+        # Check default readout error is equal
+        if self._default_readout_error != other._default_readout_error:
+            return False
+        # Check local readout errors are equal
+        if sorted(self._local_readout_errors.keys()) != sorted(other._local_readout_errors.keys()):
+            return False
+        for key, value in self._local_readout_errors.items():
+            if value != other._local_readout_errors[key]:
+                return False
+        return True
+
+    def _all_qubit_quantum_errors_equal(self, other):
+        """Check two noise models have equal local quantum errors"""
+        if sorted(self._default_quantum_errors.keys()) != sorted(
+            other._default_quantum_errors.keys()
+        ):
+            return False
+        for key, value in self._default_quantum_errors.items():
+            if value != other._default_quantum_errors[key]:
+                return False
+        return True
+
+    def _local_quantum_errors_equal(self, other):
+        """Check two noise models have equal local quantum errors"""
+        if sorted(self._local_quantum_errors.keys()) != sorted(other._local_quantum_errors.keys()):
+            return False
+        for key, value in self._local_quantum_errors.items():
+            inner_dict2 = other._local_quantum_errors[key]
+            if sorted(value.keys()) != sorted(inner_dict2.keys()):
+                return False
+            for inner_key, inner_value in value.items():
+                if inner_value != inner_dict2[inner_key]:
+                    return False
+            if value != other._local_quantum_errors[key]:
+                return False
+        return True
+
+    def _pass_manager(self) -> Optional[PassManager]:
+        """
+        Return the pass manager that add custom noises defined as noise passes
+        (stored in the _custom_noise_passes field). Note that the pass manager
+        does not include passes to add other noises (stored in the different field).
+        """
+        passes = []
+        passes.extend(self._custom_noise_passes)
+        if len(passes) > 0:
+            return PassManager(passes)
+        return None
+
+
+def _standard_gate_unitary(name):
+    # To be removed with from_dict
+    unitary_matrices = {
+        ("id", "I"): np.eye(2, dtype=complex),
+        ("x", "X"): np.array([[0, 1], [1, 0]], dtype=complex),
+        ("y", "Y"): np.array([[0, -1j], [1j, 0]], dtype=complex),
+        ("z", "Z"): np.array([[1, 0], [0, -1]], dtype=complex),
+        ("h", "H"): np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2),
+        ("s", "S"): np.array([[1, 0], [0, 1j]], dtype=complex),
+        ("sdg", "Sdg"): np.array([[1, 0], [0, -1j]], dtype=complex),
+        ("t", "T"): np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=complex),
+        ("tdg", "Tdg"): np.array([[1, 0], [0, np.exp(-1j * np.pi / 4)]], dtype=complex),
+        ("cx", "CX", "cx_01"): np.array(
+            [[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]], dtype=complex
+        ),
+        ("cx_10",): np.array(
+            [[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]], dtype=complex
+        ),
+        ("cz", "CZ"): np.array(
+            [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]], dtype=complex
+        ),
+        ("swap", "SWAP"): np.array(
+            [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=complex
+        ),
+        ("ccx", "CCX", "ccx_012", "ccx_102"): np.array(
+            [
+                [1, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 1, 0, 0],
+                [0, 0, 0, 0, 0, 0, 1, 0],
+                [0, 0, 0, 1, 0, 0, 0, 0],
+            ],
+            dtype=complex,
+        ),
+        ("ccx_021", "ccx_201"): np.array(
+            [
+                [1, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0, 0, 0, 0],
+                [0, 0, 0, 1, 0, 0, 0, 0],
+                [0, 0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 1, 0],
+                [0, 0, 0, 0, 0, 1, 0, 0],
+            ],
+            dtype=complex,
+        ),
+        ("ccx_120", "ccx_210"): np.array(
+            [
+                [1, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0, 0, 0, 0],
+                [0, 0, 0, 1, 0, 0, 0, 0],
+                [0, 0, 0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 1, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 1],
+                [0, 0, 0, 0, 0, 0, 1, 0],
+            ],
+            dtype=complex,
+        ),
+    }
+
+    return next((value for key, value in unitary_matrices.items() if name in key), None)