As established, NISQ-era quantum processors are inherently noisy. This noise isn't just a minor inconvenience; it fundamentally alters the behavior and performance of Quantum Machine Learning algorithms executed on these devices. Understanding how noise impacts computation is essential for interpreting results and developing effective QML applications.

Recall that quantum noise generally manifests as unwanted interactions between the qubits and their environment, or as imperfections in the control pulses used to implement quantum gates. These processes lead to deviations from the intended quantum evolution. Common noise models include:

Depolarizing Noise: Randomly applies Pauli operators ( $X, Y, Z$ ) with some probability, effectively mixing the state towards the maximally mixed state ( $I/2^n$ ).
Amplitude Damping: Models energy relaxation (e.g., a qubit decaying from $\vert 1 \rangle$ to $\vert 0 \rangle$ ).
Phase Damping (Dephasing): Models the loss of phase coherence between $\vert 0 \rangle$ and $\vert 1 \rangle$ without energy exchange.
Gate Errors: Imperfections in the implementation of single-qubit and multi-qubit gates, causing the applied operation to differ from the ideal unitary transformation.
Readout Errors: Errors during the measurement process, where the recorded classical bit value doesn't match the qubit's final state before measurement.

Mathematically, noise transforms ideal pure states $\vert \psi \rangle$ into mixed states, which are correctly described by density matrices $\rho$ . An ideal operation transforms a state as $\rho_{out} = U \rho_{in} U^\dagger$ , where $U$ is the ideal unitary. A noisy operation, however, is typically represented by a quantum channel, often expressed using the operator-sum representation:

\mathcal{E}(\rho_{in}) = \sum_k E_k \rho_{in} E_k^\dagger

where the $E_k$ are Kraus operators satisfying $\sum_k E_k^\dagger E_k = I$ . This transformation generally increases the entropy of the state and reduces its purity ( $\text{Tr}(\rho^2) < 1$ ).

How Noise Degrades QML Algorithm Components

Noise affects every stage of a typical QML workflow, from data encoding to measurement, accumulating errors and degrading the quality of the final result.

Impact on Data Encoding and Feature Maps

Quantum feature maps encode classical data $x$ into quantum states $\vert \phi(x) \rangle$ . Noise occurring during the execution of the encoding circuit $\mathcal{U}_{\phi(x)}$ means the actual state produced is a mixed state $\rho_x = \mathcal{E}_{enc}(\vert 0 \rangle \langle 0 \vert)$ , where $\mathcal{E}_{enc}$ represents the noisy encoding channel.

This has direct consequences:

Distorted Feature Space Geometry: The inner products between encoded states, $|\langle \phi(x_i) | \phi(x_j) \rangle|^2$ , form the basis of quantum kernel methods. Noise alters these inner products: $\text{Tr}(\rho_{x_i} \rho_{x_j})$ will differ from the ideal value. This distortion changes the geometry of the data representation in Hilbert space, potentially making distinct data points appear closer or similar points appear farther apart than intended. The separability of classes can be reduced.
Reduced Expressivity: Noise tends to contract the volume of the state space reachable by the feature map, potentially limiting the complexity of functions the QML model can learn.

Impact on Variational Circuits (PQCs) and Training

Variational algorithms lie at the heart of many QML approaches. They involve optimizing the parameters $\theta$ of a Parameterized Quantum Circuit (PQC), $U(\theta)$ , to minimize a cost function $C(\theta)$ , typically derived from expectation values of observables $\langle O \rangle_{\theta} = \text{Tr}(O \, U(\theta) \rho_{in} U(\theta)^\dagger)$ . Noise corrupts this process severely:

Inaccurate Expectation Values: Noise during the PQC execution means the final state before measurement is a noisy mixed state $\rho_{out}(\theta) = \mathcal{E}_{PQC}(U(\theta) \rho_{in} U(\theta)^\dagger)$ . The measured expectation value becomes $\langle O \rangle_{\theta, noisy} = \text{Tr}(O \, \rho_{out}(\theta))$ . This value deviates from the ideal $\langle O \rangle_{\theta, ideal}$ . Consequently, the cost function $C_{noisy}(\theta)$ being evaluated is different from the target $C_{ideal}(\theta)$ . The optimization might proceed on a distorted cost landscape.
Faulty Gradients: Gradient-based optimization relies on accurately estimating $\nabla_{\theta} C(\theta)$ . Methods like the parameter-shift rule compute gradients from differences in expectation values evaluated at shifted parameters. Noise introduces errors into these expectation values, leading to inaccurate gradient estimates $\nabla_{\theta} C_{noisy}(\theta)$ . Noisy gradients can slow down convergence, cause the optimizer to get stuck in local minima unrelated to the ideal cost function's minima, or even prevent convergence entirely.
Noise-Induced Barren Plateaus (NIBPs): While barren plateaus (vanishing gradients) can occur even in ideal deep PQCs, noise can induce similar phenomena even in shallow circuits. Noise effectively averages out gradient information, particularly in globally defined cost functions, making optimization extremely difficult.
Altered Training Dynamics: The entire optimization trajectory can be altered. The model might converge to a different set of parameters compared to the noiseless case, often resulting in poorer generalization performance on unseen data.

Convergence comparison for a simple Variational Quantum Classifier training under ideal (noiseless) conditions versus a simulation including moderate depolarizing noise. Noise clearly hinders the optimization, leading to a higher final cost value.

Impact on Measurement and Readout

Even if the quantum state is prepared correctly before measurement, readout errors introduce a final layer of corruption. A classical bit '0' might be recorded when the true state was $\vert 1 \rangle$ , and vice versa. This can be modeled by a confusion matrix or probability assignments $P(\text{read } i | \text{true } j)$ . Readout errors directly bias the statistics of measurement outcomes, affecting the estimation of expectation values and, consequently, the cost function and gradients.

Consequences for Specific QML Algorithms

Quantum Support Vector Machines (QSVM): The performance of QSVM relies entirely on the quality of the quantum kernel matrix $K_{ij} = f(\text{Tr}(\rho_{x_i} \rho_{x_j}))$ , where $f$ is typically $|\cdot|^2$ or related fidelity measures. Noise distorts these kernel entries. If the distortion is significant, the kernel matrix might lose its desired properties (like representing the data structure well) or even cease to be positive semi-definite, rendering the subsequent classical SVM optimization invalid or ineffective. Noise can also worsen kernel concentration issues, making distinct data points appear uniformly similar.
Variational Quantum Classifiers (VQC): As detailed above, noisy execution leads to inaccurate cost evaluations and gradients. This makes it difficult to train the VQC effectively. The learned decision boundary in the feature space will likely be suboptimal compared to the ideal case, resulting in lower classification accuracy.
Quantum Generative Models (QGANs, QCBMs): Noise fundamentally limits the ability of these models to learn and represent the target probability distribution accurately. For QCBMs, the output distribution sampled from the noisy circuit will deviate from the target distribution. For QGANs, the training dynamics become even more complex and unstable, as both the quantum generator and potentially a quantum discriminator are affected by noise, making it harder to reach a satisfactory equilibrium. The quality of generated samples (e.g., measured by fidelity or divergence metrics) will be lower.

Comparison of ideal vs. noisy QML workflows. Noise sources (gate errors, decoherence, readout errors) affect each stage, leading to deviations from the intended computation and degraded output.

In summary, quantum hardware noise is a critical bottleneck for QML. It distorts data representation, hinders optimization by corrupting cost functions and gradients, biases measurement outcomes, and ultimately degrades the predictive or generative performance of QML models. Recognizing these specific impacts is the first step towards devising and applying strategies to counteract them, which is the focus of the subsequent sections on error mitigation.