qadence 1.7.7__py3-none-any.whl → 1.8.0__py3-none-any.whl

qadence/mitigations/analog_zne.py

@@ -15,7 +15,7 @@ from qadence.blocks.analog import ConstantAnalogRotation, InteractionBlock
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.operations import AnalogRot
 from qadence.transpile import apply_fn_to_blocks
 from qadence.utils import Endianness
@@ -44,7 +44,7 @@ def pulse_experiment(
     circuit: QuantumCircuit,
     observable: list[AbstractBlock],
     param_values: dict[str, Tensor],
-    noise: Noise,
+    noise: NoiseHandler,
     stretches: Tensor,
     endianness: Endianness,
     state: Tensor | None = None,
@@ -116,11 +116,12 @@ def noise_level_experiment(
     circuit: QuantumCircuit,
     observable: list[AbstractBlock],
     param_values: dict[str, Tensor],
-    noise: Noise,
+    noise: NoiseHandler,
     endianness: Endianness,
     state: Tensor | None = None,
 ) -> Tensor:
-    noise_probs = noise.options.get("noise_probs")
+    protocol, options = noise.protocol[-1], noise.options[-1]
+    noise_probs = options.get("noise_probs")
     zne_datasets: list = []
     # Get noisy density matrices.
     conv_circuit = backend.circuit(circuit)
@@ -152,7 +153,7 @@ def analog_zne(
     param_values: dict[str, Tensor] = {},
     state: Tensor | None = None,
     measurement: Measurements | None = None,
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     mitigation: Mitigations | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:
@@ -162,7 +163,7 @@ def analog_zne(
     backend = cast(Backend, backend)
     noise_model = mitigation.options.get("noise_model", None)
     if noise_model is None:
-        KeyError(f"A noise model should be choosen from {Noise.list()}. Got {noise_model}.")
+        raise KeyError("A noise model should be specified.")
     stretches = mitigation.options.get("stretches", None)
     if stretches is not None:
         extrapolated_exp_values = pulse_experiment(
@@ -195,7 +196,7 @@ def mitigate(
     param_values: dict[str, Tensor] = {},
     state: Tensor | None = None,
     measurement: Measurements | None = None,
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     mitigation: Mitigations | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:

qadence/mitigations/protocols.py

@@ -5,7 +5,7 @@ from collections import Counter
 from dataclasses import dataclass
 from typing import Callable, cast
 
-from qadence.noise.protocols import Noise
+from qadence.noise.protocols import NoiseHandler
 
 PROTOCOL_TO_MODULE = {
     "readout": "qadence.mitigations.readout",
@@ -45,7 +45,7 @@ class Mitigations:
 
 
 def apply_mitigation(
-    noise: Noise, mitigation: Mitigations, samples: list[Counter]
+    noise: NoiseHandler, mitigation: Mitigations, samples: list[Counter]
 ) -> list[Counter]:
     """Apply mitigation to samples."""
     mitigation_fn = mitigation.get_mitigation_fn()

qadence/mitigations/readout.py

@@ -11,8 +11,8 @@ from scipy.linalg import norm
 from scipy.optimize import LinearConstraint, minimize
 
 from qadence.mitigations.protocols import Mitigations
-from qadence.noise.protocols import Noise
-from qadence.types import ReadOutOptimization
+from qadence.noise.protocols import NoiseHandler
+from qadence.types import NoiseProtocol, ReadOutOptimization
 
 
 def corrected_probas(p_corr: npt.NDArray, T: npt.NDArray, p_raw: npt.NDArray) -> np.double:
@@ -69,7 +69,7 @@ def matrix_inv(K: npt.NDArray) -> npt.NDArray:
 
 
 def mitigation_minimization(
-    noise: Noise,
+    noise: NoiseHandler,
     mitigation: Mitigations,
     samples: list[Counter],
 ) -> list[Counter]:
@@ -88,7 +88,10 @@ def mitigation_minimization(
     Returns:
         Mitigated counts computed by the algorithm
     """
-    noise_matrices = noise.options.get("noise_matrix", noise.options["confusion_matrices"])
+    protocol, options = noise.protocol[-1], noise.options[-1]
+    if protocol != NoiseProtocol.READOUT:
+        raise ValueError("Specify a noise source of type NoiseProtocol.READOUT.")
+    noise_matrices = options.get("noise_matrix", options["confusion_matrices"])
     optimization_type = mitigation.options.get("optimization_type", ReadOutOptimization.MLE)
     n_qubits = len(list(samples[0].keys())[0])
     n_shots = sum(samples[0].values())
@@ -156,5 +159,5 @@ def mitigation_minimization(
     return corrected_counters
 
 
-def mitigate(noise: Noise, mitigation: Mitigations, samples: list[Counter]) -> list[Counter]:
+def mitigate(noise: NoiseHandler, mitigation: Mitigations, samples: list[Counter]) -> list[Counter]:
     return mitigation_minimization(noise=noise, mitigation=mitigation, samples=samples)

qadence/ml_tools/config.py

@@ -447,6 +447,13 @@ class FeatureMapConfig:
     assign `t, x = xs[:,0], xs[:,1]`.
     """
 
+    tag: str | None = None
+    """
+    String to indicate the name tag of the feature map.
+
+    Defaults to None, in which case no tag will be applied.
+    """
+
     def __post_init__(self) -> None:
         if self.multivariate_strategy == MultivariateStrategy.PARALLEL and self.num_features > 1:
             assert (
@@ -606,6 +613,13 @@ class AnsatzConfig:
     param_prefix: str = "theta"
     """The base bame of the variational parameter."""
 
+    tag: str | None = None
+    """
+    String to indicate the name tag of the ansatz.
+
+    Defaults to None, in which case no tag will be applied.
+    """
+
     def __post_init__(self) -> None:
         if self.ansatz_type == AnsatzType.IIA:
             assert (

qadence/ml_tools/constructors.py

@@ -7,7 +7,7 @@ from qadence.backend import BackendConfiguration
 from qadence.blocks import chain, kron
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.composite import ChainBlock, KronBlock
-from qadence.blocks.utils import add
+from qadence.blocks.utils import add, tag
 from qadence.circuit import QuantumCircuit
 from qadence.constructors import (
     analog_feature_map,
@@ -21,7 +21,7 @@ from qadence.constructors import (
 from qadence.constructors.ansatze import hea_digital, hea_sDAQC
 from qadence.constructors.hamiltonians import ObservableConfig, TDetuning
 from qadence.measurements import Measurements
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.operations import CNOT, RX, RY, I, N, Z
 from qadence.parameters import Parameter
 from qadence.register import Register
@@ -740,7 +740,7 @@ def build_qnn_from_configs(
     backend: BackendName = BackendName.PYQTORCH,
     diff_mode: DiffMode = DiffMode.AD,
     measurement: Measurements | None = None,
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     configuration: BackendConfiguration | dict | None = None,
     input_diff_mode: InputDiffMode | str = InputDiffMode.AD,
 ) -> QNN:
@@ -774,10 +774,15 @@ def build_qnn_from_configs(
             fm_blocks=fm_blocks,
             ansatz_config=ansatz_config,
         )
+        if isinstance(fm_config.tag, str):
+            tag(full_fm, fm_config.tag)
         inputs = fm_config.inputs
         blocks.append(full_fm)
 
-    blocks.append(create_ansatz(register=register, config=ansatz_config))
+    ansatz = create_ansatz(register=register, config=ansatz_config)
+    if isinstance(ansatz_config.tag, str):
+        tag(ansatz, ansatz_config.tag)
+    blocks.append(ansatz)
 
     circ = QuantumCircuit(register, *blocks)
 

qadence/ml_tools/models.py

@@ -16,7 +16,7 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.ml_tools.config import AnsatzConfig, FeatureMapConfig
 from qadence.model import QuantumModel
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.register import Register
 from qadence.types import BackendName, DiffMode, Endianness, InputDiffMode, ParamDictType
 
@@ -139,7 +139,7 @@ class QNN(QuantumModel):
         backend: BackendName = BackendName.PYQTORCH,
         diff_mode: DiffMode = DiffMode.AD,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         configuration: BackendConfiguration | dict | None = None,
         inputs: list[sympy.Basic | str] | None = None,
         input_diff_mode: InputDiffMode | str = InputDiffMode.AD,
@@ -218,7 +218,7 @@ class QNN(QuantumModel):
         backend: BackendName = BackendName.PYQTORCH,
         diff_mode: DiffMode = DiffMode.AD,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         configuration: BackendConfiguration | dict | None = None,
         input_diff_mode: InputDiffMode | str = InputDiffMode.AD,
     ) -> QNN:
@@ -311,7 +311,7 @@ class QNN(QuantumModel):
         values: dict[str, Tensor] | Tensor = None,
         state: Tensor | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         """Forward pass of the model.
@@ -360,7 +360,7 @@ class QNN(QuantumModel):
         values: Tensor | dict[str, Tensor] = {},
         n_shots: int = 1000,
         state: Tensor | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -379,7 +379,7 @@ class QNN(QuantumModel):
         observable: list[ConvertedObservable] | ConvertedObservable | None = None,
         state: Tensor | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -423,7 +423,7 @@ class QNN(QuantumModel):
                 backend=qm_dict["backend"],
                 diff_mode=qm_dict["diff_mode"],
                 measurement=Measurements._from_dict(qm_dict["measurement"]),
-                noise=Noise._from_dict(qm_dict["noise"]),
+                noise=NoiseHandler._from_dict(qm_dict["noise"]),
                 configuration=config_factory(qm_dict["backend"], qm_dict["backend_configuration"]),
                 inputs=qm_dict["inputs"],
             )

qadence/ml_tools/printing.py

@@ -27,8 +27,9 @@ def print_metrics(loss: float | None, metrics: dict, iteration: int) -> None:
 
 
 def write_tensorboard(
-    writer: SummaryWriter, loss: float = None, metrics: dict = {}, iteration: int = 0
+    writer: SummaryWriter, loss: float = None, metrics: dict | None = None, iteration: int = 0
 ) -> None:
+    metrics = metrics or dict()
     if loss is not None:
         writer.add_scalar("loss", loss, iteration)
     for key, arg in metrics.items():

qadence/ml_tools/train_grad.py

@@ -213,21 +213,48 @@ def train(
     ]
 
     # writing metrics
+    # we specify two writers,
+    # to write at evaluation time and before evaluation
     callbacks += [
         Callback(
             lambda opt_res: write_tracker(
                 writer,
                 opt_res.loss,
                 opt_res.metrics,
-                opt_res.iteration,
+                opt_res.iteration - 1,  # loss returned be optimized_step is at -1
+                tracking_tool=config.tracking_tool,
+            ),
+            called_every=config.write_every,
+            call_end_epoch=True,
+        ),
+        Callback(
+            lambda opt_res: write_tracker(
+                writer,
+                opt_res.loss,
+                opt_res.metrics,
+                opt_res.iteration,  # after_opt we match the right loss function
                 tracking_tool=config.tracking_tool,
             ),
             called_every=config.write_every,
-            call_before_opt=False,
+            call_end_epoch=False,
             call_after_opt=True,
-            call_during_eval=True,
-        )
+        ),
     ]
+    if perform_val:
+        callbacks += [
+            Callback(
+                lambda opt_res: write_tracker(
+                    writer,
+                    None,
+                    opt_res.metrics,
+                    opt_res.iteration,
+                    tracking_tool=config.tracking_tool,
+                ),
+                called_every=config.write_every,
+                call_before_opt=True,
+                call_during_eval=True,
+            )
+        ]
 
     # checkpointing
     if config.folder and config.checkpoint_every > 0 and not config.checkpoint_best_only:
@@ -332,17 +359,22 @@ def train(
                 logger.info("Terminating training gracefully after the current iteration.")
                 break
 
-        # Handling printing the last training loss
+        # For handling printing/writing the last training loss
         # as optimize_step does not give the loss value at the last iteration
         try:
             loss, metrics, *_ = next_loss_iter(dl_iter)
-            if iteration % config.print_every == 0 and config.verbose:
-                print_metrics(loss, metrics, iteration)
+            if isinstance(loss, Tensor):
+                loss = loss.item()
+            if perform_val:
+                # reputting val_loss as already evaluated before
+                metrics["val_loss"] = val_loss
+            print_metrics(loss, metrics, iteration)
 
         except KeyboardInterrupt:
             logger.info("Terminating training gracefully after the current iteration.")
 
     # Final callbacks, by default checkpointing and writing
+    opt_result = OptimizeResult(iteration, model, optimizer, loss, metrics)
     callbacks_after_opt = [callback for callback in callbacks if callback.call_after_opt]
     run_callbacks(callbacks_after_opt, opt_result, is_last_iteration=True)
 

qadence/model.py

@@ -24,7 +24,7 @@ from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.parameters import Parameter
 from qadence.types import DiffMode, Endianness
 
@@ -83,7 +83,7 @@ class QuantumModel(nn.Module):
         backend: BackendName | str = BackendName.PYQTORCH,
         diff_mode: DiffMode = DiffMode.AD,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         configuration: BackendConfiguration | dict | None = None,
     ):
@@ -249,7 +249,7 @@ class QuantumModel(nn.Module):
         values: dict[str, torch.Tensor] = {},
         n_shots: int = 1000,
         state: torch.Tensor | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -287,7 +287,7 @@ class QuantumModel(nn.Module):
         observable: list[ConvertedObservable] | ConvertedObservable | None = None,
         state: Optional[Tensor] = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -415,7 +415,7 @@ class QuantumModel(nn.Module):
                 backend=qm_dict["backend"],
                 diff_mode=qm_dict["diff_mode"],
                 measurement=Measurements._from_dict(qm_dict["measurement"]),
-                noise=Noise._from_dict(qm_dict["noise"]),
+                noise=NoiseHandler._from_dict(qm_dict["noise"]),
                 configuration=config_factory(qm_dict["backend"], qm_dict["backend_configuration"]),
             )
 

qadence/noise/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from .protocols import Noise
+from .protocols import NoiseHandler, apply_readout_noise
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["Noise"]
+__all__ = ["NoiseHandler", "apply_readout_noise"]

qadence/noise/protocols.py

@@ -1,54 +1,241 @@
 from __future__ import annotations
 
 import importlib
-from dataclasses import dataclass
-from typing import Callable, Counter, cast
+from itertools import compress
+from typing import Any, Callable, Counter, cast
+
+from qadence.types import NoiseEnum, NoiseProtocol
 
 PROTOCOL_TO_MODULE = {
-    "readout": "qadence.noise.readout",
+    "Readout": "qadence.noise.readout",
 }
 
 
-@dataclass
-class Noise:
-    DEPHASING = "dephasing"
-    DEPOLARIZING = "depolarizing"
-    READOUT = "readout"
+class NoiseHandler:
+    """A container for multiple sources of noise.
+
+    Note `NoiseProtocol.ANALOG` and `NoiseProtocol.DIGITAL` sources cannot be both present.
+    Also `NoiseProtocol.READOUT` can only be present once as the last noise sources, and only
+    exclusively with `NoiseProtocol.DIGITAL` sources.
+
+    Args:
+        protocol: The protocol(s) applied. To be defined from `NoiseProtocol`.
+        options: A list of options defining the protocol.
+            For `NoiseProtocol.ANALOG`, options should contain a field `noise_probs`.
+            For `NoiseProtocol.DIGITAL`, options should contain a field `error_probability`.
+
+    Examples:
+    ```
+        from qadence import NoiseProtocol, NoiseHandler
+
+        analog_options = {"noise_probs": 0.1}
+        digital_options = {"error_probability": 0.1}
+        readout_options = {"error_probability": 0.1, "seed": 0}
+
+        # single noise sources
+        analog_noise = NoiseHandler(NoiseProtocol.ANALOG.DEPOLARIZING, analog_options)
+        digital_depo_noise = NoiseHandler(NoiseProtocol.DIGITAL.DEPOLARIZING, digital_options)
+        readout_noise = NoiseHandler(NoiseProtocol.READOUT, readout_options)
+
+        # init from multiple sources
+        protocols: list = [NoiseProtocol.DIGITAL.DEPOLARIZING, NoiseProtocol.READOUT]
+        options: list = [digital_options, readout_noise]
+        noise_combination = NoiseHandler(protocols, options)
+
+        # Appending noise sources
+        noise_combination = NoiseHandler(NoiseProtocol.DIGITAL.BITFLIP, digital_options)
+        noise_combination.append([digital_depo_noise, readout_noise])
+    ```
+    """
+
+    def __init__(
+        self,
+        protocol: NoiseEnum | list[NoiseEnum],
+        options: dict | list[dict] = dict(),
+    ) -> None:
+        self.protocol = protocol if isinstance(protocol, list) else [protocol]
+        self.options = options if isinstance(options, list) else [options] * len(self.protocol)
+        self.verify_all_protocols()
 
-    def __init__(self, protocol: str, options: dict = dict()) -> None:
-        self.protocol: str = protocol
-        self.options: dict = options
+    def _verify_single_protocol(self, protocol: NoiseEnum, option: dict) -> None:
+        if protocol != NoiseProtocol.READOUT:
+            name_mandatory_option = (
+                "noise_probs" if isinstance(protocol, NoiseProtocol.ANALOG) else "error_probability"
+            )
+            noise_probs = option.get(name_mandatory_option, None)
+            if noise_probs is None:
+                error_txt = f"A `{name_mandatory_option}` option"
+                error_txt += f"should be passed for protocol {protocol}."
+                raise KeyError(error_txt)
 
-    def get_noise_fn(self) -> Callable:
+    def verify_all_protocols(self) -> None:
+        """Make sure all protocols are correct in terms and their combination too."""
+
+        if len(self.protocol) == 0:
+            raise ValueError("NoiseHandler should be specified with one valid configuration.")
+
+        if len(self.protocol) != len(self.options):
+            raise ValueError("Specify lists of same length when defining noises.")
+
+        for protocol, option in zip(self.protocol, self.options):
+            self._verify_single_protocol(protocol, option)
+
+        types = [type(p) for p in self.protocol]
+        unique_types = set(types)
+        if NoiseProtocol.DIGITAL in unique_types and NoiseProtocol.ANALOG in unique_types:
+            raise ValueError("Cannot define a config with both Digital and Analog noises.")
+
+        if NoiseProtocol.ANALOG in unique_types:
+            if NoiseProtocol.READOUT in unique_types:
+                raise ValueError("Cannot define a config with both READOUT and Analog noises.")
+            if types.count(NoiseProtocol.ANALOG) > 1:
+                raise ValueError("Multiple Analog Noises are not supported yet.")
+
+        if NoiseProtocol.READOUT in self.protocol:
+            if (
+                self.protocol[-1] != NoiseProtocol.READOUT
+                or self.protocol.count(NoiseProtocol.READOUT) > 1
+            ):
+                raise ValueError("Only define a NoiseHandler with one READOUT as the last Noise.")
+
+    def __repr__(self) -> str:
+        return "\n".join(
+            [
+                f"Noise({protocol}, {str(option)})"
+                for protocol, option in zip(self.protocol, self.options)
+            ]
+        )
+
+    def get_noise_fn(self, index_protocol: int) -> Callable:
         try:
-            module = importlib.import_module(PROTOCOL_TO_MODULE[self.protocol])
+            module = importlib.import_module(PROTOCOL_TO_MODULE[self.protocol[index_protocol]])
         except KeyError:
-            ImportError(f"The module corresponding to the protocol {self.protocol} is not found.")
+            ImportError(
+                f"The module for the protocol {self.protocol[index_protocol]} is not found."
+            )
         fn = getattr(module, "add_noise")
         return cast(Callable, fn)
 
+    def append(self, other: NoiseHandler | list[NoiseHandler]) -> None:
+        """Append noises.
+
+        Args:
+            other (NoiseHandler | list[NoiseHandler]): The noises to add.
+        """
+        # To avoid overwriting the noise_sources list if an error is raised, make a copy
+        other_list = other if isinstance(other, list) else [other]
+        protocols = self.protocol[:]
+        options = self.options[:]
+
+        for noise in other_list:
+            protocols += noise.protocol
+            options += noise.options
+
+        # init may raise an error
+        temp_handler = NoiseHandler(protocols, options)
+        # if verify passes, replace protocols and options
+        self.protocol = temp_handler.protocol
+        self.options = temp_handler.options
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NoiseHandler):
+            raise TypeError(f"Cant compare {type(self)} to {type(other)}")
+        if isinstance(other, type(self)):
+            protocols_equal = all([p1 == p2 for p1, p2 in zip(self.protocol, other.protocol)])
+            options_equal = all([o1 == o2 for o1, o2 in zip(self.options, other.options)])
+            return protocols_equal and options_equal
+
+        return False
+
     def _to_dict(self) -> dict:
-        return {"protocol": self.protocol, "options": self.options}
+        return {
+            "protocol": self.protocol,
+            "options": self.options,
+        }
 
     @classmethod
-    def _from_dict(cls, d: dict) -> Noise | None:
-        if d:
-            return cls(d["protocol"], **d["options"])
+    def _from_dict(cls, d: dict | None) -> NoiseHandler | None:
+        if d is not None and d.get("protocol", None):
+            return cls(d["protocol"], d["options"])
         return None
 
     @classmethod
     def list(cls) -> list:
         return list(filter(lambda el: not el.startswith("__"), dir(cls)))
 
+    def filter(self, protocol: NoiseEnum) -> NoiseHandler | None:
+        is_protocol: list = [isinstance(p, protocol) for p in self.protocol]  # type: ignore[arg-type]
+        return (
+            NoiseHandler(
+                list(compress(self.protocol, is_protocol)),
+                list(compress(self.options, is_protocol)),
+            )
+            if len(is_protocol) > 0
+            else None
+        )
+
+    def bitflip(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.BITFLIP, *args, **kwargs))
+        return self
+
+    def phaseflip(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PHASEFLIP, *args, **kwargs))
+        return self
+
+    def digital_depolarizing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.DEPOLARIZING, *args, **kwargs))
+        return self
+
+    def pauli_channel(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PAULI_CHANNEL, *args, **kwargs))
+        return self
+
+    def amplitude_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.AMPLITUDE_DAMPING, *args, **kwargs))
+        return self
+
+    def phase_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PHASE_DAMPING, *args, **kwargs))
+        return self
+
+    def generalized_amplitude_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(
+            NoiseHandler(NoiseProtocol.DIGITAL.GENERALIZED_AMPLITUDE_DAMPING, *args, **kwargs)
+        )
+        return self
+
+    def analog_depolarizing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.ANALOG.DEPOLARIZING, *args, **kwargs))
+        return self
+
+    def dephasing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.ANALOG.DEPHASING, *args, **kwargs))
+        return self
+
+    def readout(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.READOUT, *args, **kwargs))
+        return self
+
+
+def apply_readout_noise(noise: NoiseHandler, samples: list[Counter]) -> list[Counter]:
+    """Apply readout noise to samples if provided.
+
+    Args:
+        noise (NoiseHandler): Noise to apply.
+        samples (list[Counter]): Samples to alter
 
-def apply_noise(noise: Noise, samples: list[Counter]) -> list[Counter]:
-    """Apply noise to samples."""
-    error_fn = noise.get_noise_fn()
-    # Get the number of qubits from the sample keys.
-    n_qubits = len(list(samples[0].keys())[0])
-    # Get the number of shots from the sample values.
-    n_shots = sum(samples[0].values())
-    noisy_samples: list = error_fn(
-        counters=samples, n_qubits=n_qubits, options=noise.options, n_shots=n_shots
-    )
-    return noisy_samples
+    Returns:
+        list[Counter]: Altered samples.
+    """
+    if noise.protocol[-1] == NoiseProtocol.READOUT:
+        error_fn = noise.get_noise_fn(-1)
+        # Get the number of qubits from the sample keys.
+        n_qubits = len(list(samples[0].keys())[0])
+        # Get the number of shots from the sample values.
+        n_shots = sum(samples[0].values())
+        noisy_samples: list = error_fn(
+            counters=samples, n_qubits=n_qubits, options=noise.options[-1], n_shots=n_shots
+        )
+        return noisy_samples
+    else:
+        return samples