A Systematic Study of Noise Effects in Hybrid Quantum-Classical Machine Learning

This paper presents a systematic experimental study demonstrating that the combined presence of noisy classical inputs and quantum hardware noise significantly degrades the training stability and classification accuracy of variational quantum classifiers, highlighting the critical need to evaluate both noise sources simultaneously in NISQ-era machine learning.

The Gist

The Big Picture: A Noisy Kitchen in a Stormy World

Imagine you are trying to bake a perfect cake (the Quantum Machine Learning Model). In an ideal world, you would have:

1. Perfect Ingredients: Fresh, measured flour and sugar (Clean Data).
2. Perfect Tools: A pristine, high-tech oven that never fluctuates in temperature (Perfect Quantum Hardware).
3. Perfect Execution: You follow the recipe exactly without shaking your hand (Perfect Encoding).

However, in the real world (the NISQ Era or "Noisy Intermediate-Scale Quantum" era), things are messy.

• Your ingredients might be slightly damp or measured with a wobbly spoon (Classical Data Noise).
• Your oven might have a broken thermostat that randomly spikes the heat or cools it down too fast (Quantum Hardware Noise).

The Problem: Most scientists have been studying what happens when only the oven is broken. They assumed the ingredients were perfect. This paper asks a crucial question: "What happens to our cake if the ingredients are also bad, AND the oven is broken?"

---

The Experiment: The Titanic Dataset as a Test Kitchen

The authors used the famous Titanic dataset (predicting who survived the shipwreck based on age, ticket class, etc.) as their test kitchen. They built a "Hybrid Quantum-Classical" system. Think of this as a team where:

• The Classical Computer is the sous-chef who preps the ingredients.
• The Quantum Computer is the magical oven that does the heavy baking.

They wanted to see how robust this team is when things go wrong at different stages.

The Three Levels of "Noise" (The Chaos)

The authors injected "noise" (errors) at three specific points in the process:

1. The Ingredient Level (Dataset Noise)

Before the food even goes into the oven, they messed with the data.

• The Analogy: Imagine the flour is wet, the sugar has sand in it, or some measurements are missing entirely.
• The Types: They added "Gaussian noise" (a little bit of everything is slightly off), "Salt-and-Pepper noise" (random big chunks of data are missing or wrong), and "Dropout" (some ingredients are just gone).
• The Result: When the ingredients were bad, the cake was a little less perfect, but the team could still mostly figure out how to bake it. The model was surprisingly resilient to bad data if the oven was working perfectly.

2. The Recipe Translation Level (Encoding Noise)

To put classical data (numbers) into a quantum oven, you have to translate them into "angles" (like turning a dial).

• The Analogy: Imagine the sous-chef has to turn a dial to set the temperature. If their hand shakes slightly while turning the dial, the oven gets set to 352°F instead of 350°F.
• The Result: This "shaky hand" made the baking process slower and less precise, but again, it didn't completely ruin the cake.

3. The Oven Level (Circuit Noise)

This is the quantum hardware itself.

• The Analogy: The oven is old and broken. It randomly turns off, the heat fluctuates wildly, or the door opens and closes by itself.
• The Result: This was the disaster. When the "oven" was noisy, the cake didn't just get slightly worse; it turned into a brick. The accuracy of the model plummeted from ~76% (good) to ~39% (basically guessing).

The Shocking Discovery: The "Masking Effect"

This is the most important finding of the paper.

When they combined Bad Ingredients (Classical Noise) with a Broken Oven (Quantum Noise), they expected the cake to be a total disaster—worse than just a broken oven alone.

But that's not what happened.

• The Finding: Once the oven was broken, it didn't matter if the ingredients were slightly bad or totally rotten. The broken oven was the only thing that mattered. The model was already failing so hard due to the hardware that the bad data didn't make it any worse.
• The Metaphor: Imagine you are trying to listen to a radio station while standing next to a jet engine.
  • If the radio is clear but the jet is loud, you can't hear anything.
  • If the radio is also static-filled and the jet is loud, you still can't hear anything.
  • The jet engine (Quantum Noise) masks the static in the radio (Classical Noise). The jet engine is the dominant problem.

The "Amplitude Damping" Villain

Among all the types of oven breaks, one was the worst: Amplitude Damping.

• The Analogy: This is like the oven losing energy. The heat just leaks out, and the cake never gets hot enough to rise. In quantum terms, the "quantumness" (superposition) leaks away, and the computer acts like a regular, dumb computer. This caused the biggest drop in performance.

Why Does This Matter? (The Takeaway)

1. Don't Ignore the Hardware: If you want to build a Quantum AI, you can't just focus on cleaning your data. You have to fix the hardware first. No amount of data cleaning will save you if the quantum computer is too noisy.
2. The "NISQ" Reality: We are in the "Noisy Intermediate-Scale" era. The machines are inherently broken. We need to design our AI algorithms to expect this brokenness, rather than pretending the machines are perfect.
3. Future Work: The authors suggest that as we build bigger quantum computers (more qubits), the noise might get even worse. We need to invent "noise-resistant" recipes and better ways to clean up the data before it hits the noisy machine.

Summary in One Sentence

This paper proves that in today's imperfect quantum computers, a broken machine is the biggest problem, and it actually hides the fact that your data might also be messy; you need to fix the machine before you can worry about the data.

Technical Summary

1. Problem Statement

Near-term quantum machine learning (QML) operates within the Noisy Intermediate-Scale Quantum (NISQ) regime, where hardware limitations (decoherence, gate errors) and imperfect classical data acquisition coexist.

• The Gap: Existing robustness studies typically analyze quantum circuit noise and classical data corruption in isolation. They often assume "clean" classical inputs while simulating quantum noise, or vice versa.
• The Reality: Real-world deployment involves a pipeline where corrupted classical data (sensor noise, quantization, missing values) is encoded into quantum states, which are then processed by noisy quantum hardware.
• The Question: How do these two noise sources interact? Does classical data corruption amplify quantum decoherence, or does quantum noise dominate to the point where classical noise becomes negligible?

2. Methodology

The authors propose a unified hierarchical noise modeling framework to evaluate a Variational Quantum Classifier (VQC) under combined noise conditions. The study uses the Titanic dataset (binary classification) as a benchmark.

A. Pipeline Architecture

1. Data Preprocessing: Features are normalized to $[0, 1]$ and categorical variables are label-encoded.
2. Feature Encoding: A ZZFeatureMap is used to map classical features into a high-dimensional quantum Hilbert space using parameterized single-qubit rotations and pairwise ZZ entangling gates.
3. Variational Ansatz: A hardware-efficient Quantum Neural Network (QNN) consisting of layered parameterized rotation gates and entangling operations.
4. Optimization: The COBYLA optimizer (gradient-free) minimizes the Mean Squared Error (MSE) loss using the Qiskit Estimator primitive.

B. Noise Injection Framework

The study introduces controlled perturbations at three distinct levels:

1. Dataset-Level Noise (Classical): Applied to input features before encoding.
   • Models: Gaussian/Uniform additive noise, Salt-and-Pepper (impulse), Speckle/Multiplicative noise, Quantization noise, Feature dropout, and Random sign noise.
   • Parameters: Standard deviations ($\sigma$) and impulse ratios calibrated to realistic sensor inaccuracies (e.g., $\sigma=0.05$).
2. Encoding-Level Noise (Angle-Space): Applied to the rotation angles ($\theta$) during the mapping from classical to quantum.
   • Nature: Coherent control errors (calibration drift, pulse fluctuations).
   • Model: Zero-mean Gaussian noise wrapped in $[-\pi, \pi]$.
3. Circuit-Level Noise (Quantum): Applied during execution using Qiskit Aer simulators.
   • Models: Depolarizing, Amplitude Damping (T1), Phase Damping (T2), Pauli errors, and Readout errors.
   • Configurations: 16 distinct combinations of these channels (including the noise-free baseline).

C. Experimental Setup

• Simulator: Qiskit Aer (Statevector for ideal, Shot-based for noisy).
• Scale: Small-scale circuits (number of qubits = number of features).
• Metrics: Loss convergence, Training Accuracy, and Testing Accuracy.

3. Key Contributions

1. Unified Hierarchical Framework: The first systematic study to jointly model dataset-level, encoding-level, and circuit-level noise within a single VQC pipeline.
2. Interaction Analysis: Empirical investigation into how classical data corruption propagates through quantum feature encoding and interacts with hardware noise.
3. Comprehensive Robustness Evaluation: A granular assessment of 192 noise configurations (9 dataset types $\times$ 4 angle-space levels $\times$ 16 circuit combinations).
4. Identification of Dominant Factors: Quantitative evidence showing that while classical noise degrades performance, quantum circuit noise is the primary bottleneck in the NISQ era.

4. Key Results and Analysis

A. Baseline Performance

• Under ideal conditions (no noise), the VQC achieved ~76.4% training and ~76.1% testing accuracy, confirming the model's expressivity and stability.

B. Impact of Circuit-Level Noise (Dominant Factor)

• Introducing quantum hardware noise caused a catastrophic drop in performance, reducing accuracy from 76% to **39%**.
• Amplitude Damping was identified as the most destructive channel due to its irreversible energy relaxation mechanism, which suppresses gradients and induces "barren plateau"-like behavior.
• The training and testing accuracies converged to a common "noise floor," indicating that the degradation was due to a loss of trainability rather than overfitting.

C. Impact of Dataset-Level Noise

• Classical noise caused a gradual degradation (accuracy dropped by only 1–4% from the clean baseline when quantum hardware was ideal).
• The VQC remained trainable despite corrupted inputs, provided the quantum hardware was noise-free.

D. Combined Noise Effects (The "Masking" Phenomenon)

• Crucial Finding: When dataset noise and circuit noise were applied simultaneously, the performance remained near the circuit-noise-dominated floor (~39%).
• Interpretation: In the NISQ regime, hardware noise is so severe that it masks the additional impact of classical data corruption. The marginal degradation caused by bad data becomes negligible once the quantum circuit is already failing due to decoherence.
• Exception: In low-to-moderate circuit noise regimes, classical noise did exacerbate performance loss, suggesting a saturation effect.

E. Encoding-Level Noise

• Angle-space noise caused a smooth, progressive decline in accuracy. Unlike circuit noise, it did not cause abrupt collapse but distorted the optimization landscape, slowing convergence.

5. Significance and Implications

• Realistic Evaluation: The study challenges the assumption that classical data is "clean" in QML research. It highlights that while classical noise is less damaging than quantum noise, it cannot be ignored in the design of robust pipelines.
• NISQ Constraints: The results confirm that current NISQ hardware limitations (specifically decoherence) are the primary barrier to practical QML. Improving classical data preprocessing yields diminishing returns if the quantum hardware remains noisy.
• Future Directions:
  • Error Mitigation: The paper suggests that error mitigation techniques are essential before classical data robustness becomes a primary concern.
  • Noise-Aware Design: Future QML algorithms must be designed with "noise awareness," potentially using shallow ansatzes and robust classical preprocessing to minimize the compounded effects of noise.
  • Scalability: As problem sizes scale, the interaction between corrupted inputs and accumulated gate errors will likely become more severe, necessitating new strategies for hybrid quantum-classical scaling.

Conclusion

This paper establishes that while classical data corruption affects QML performance, quantum hardware noise is the dominant limiting factor in the NISQ era. The study provides a critical framework for evaluating QML models under realistic, multi-level noise conditions, emphasizing that future advancements must prioritize hardware error mitigation alongside data quality improvements.