Improving Quantum Recurrent Neural Networks with Amplitude Encoding

This paper enhances Quantum Recurrent Neural Networks (QRNNs) by integrating EnQode for approximate amplitude encoding, introducing a pre-processing technique that augments inputs with pre-normalized magnitudes to improve generalization, and proposing a novel circuit architecture that significantly reduces depth while maintaining mathematical equivalence.

The Gist

Imagine you are trying to teach a robot to predict the stock market. You have a very powerful, futuristic robot brain called a Quantum Recurrent Neural Network (QRNN). This brain is special because it can remember past events (like a human remembering yesterday's weather to predict today's) and process information using the strange laws of quantum physics.

However, building this robot brain is tricky. The paper by Jack Morgan and his team is like a "User Manual for Upgrades." They found three specific ways to make this quantum brain smarter, faster, and less prone to breaking down.

Here is a simple breakdown of their three upgrades:

1. The "Volume Knob" Problem (Preprocessing)

The Issue:
To feed data into a quantum computer, you have to turn numbers into "quantum waves." The standard way to do this is to normalize the data, which is like turning all the volume knobs on a stereo to the exact same level so they fit on the dial.

• The Analogy: Imagine you have two songs. One is played at a whisper, and the other is played at a roar. If you normalize them, the quantum computer hears them as identical because it only looks at the shape of the sound, not how loud it was. It loses the information about the "volume" (magnitude).
• The Fix: The authors suggest adding a "Volume Knob" feature to the data before it goes in. They take the original loudness of the data, squeeze it into a new number, and feed that in as an extra ingredient.
• The Result: Now, the quantum brain can tell the difference between a whisper and a roar. They found that using a specific way to scale this "volume" (which they call MaxMin) helped the robot make better predictions on financial data.

2. The "Perfect vs. Good Enough" Dilemma (EnQode)

The Issue:
Creating the perfect quantum wave for a specific set of data is incredibly hard. It's like trying to build a perfect, custom-made suit for every single person who walks into a shop. It takes so much time and effort (circuit depth) that the robot gets tired and makes mistakes (decoherence) before it finishes.

• The Analogy: Instead of tailoring a perfect suit for every single person, what if you had a few "standard sizes" (centroids) that fit most people well enough?
• The Fix: They used a tool called EnQode. Instead of building a perfect quantum state from scratch every time, EnQode finds the closest "standard size" and tweaks it slightly. It's an approximation.
• The Result: While the suit isn't perfectly tailored, it's good enough (about 94% accurate). The huge benefit is that it takes a fraction of the time to make. On a real quantum computer, being fast and simple is better than being perfect but slow, because the computer stops working if you take too long.

3. The "Assembly Line" Upgrade (Circuit Structure)

The Issue:
In the old design, the robot had to do everything one step at a time. It had to finish preparing the data for "Today," then finish processing it, then prepare "Tomorrow," then process that. It was like a single-lane road where traffic jams caused delays and errors.

• The Analogy: Imagine a factory. The old way was: Build the frame, paint it, dry it, then build the next frame. The new way is a two-lane assembly line. While the workers are painting the frame for "Today," a different team is already building the frame for "Tomorrow."
• The Fix: They introduced Alternating Feature Registers. They use two different "workspaces" (registers) that take turns. While one is being filled with new data, the other is being processed.
• The Result: This creates a much shorter "circuit depth" (the length of the assembly line). It makes the robot faster and less likely to lose its memory (decoherence) before the job is done.

The Bottom Line

The authors tested these three upgrades on financial data (predicting stock returns). They found that:

1. Adding the "volume" feature helped the model understand the data better.
2. Using the "good enough" approximation (EnQode) made the system fast enough to actually run on real hardware without losing too much accuracy.
3. The new "assembly line" design made the whole process shorter and more efficient.

By combining these three tricks, they created a new "Best Practice" guide for anyone trying to build a Quantum Recurrent Neural Network, making it more practical for the quantum computers we have today.

Technical Summary

Technical Summary: Improving Quantum Recurrent Neural Networks with Amplitude Encoding

Problem Statement

Recurrent Neural Networks (RNNs) are standard for modeling temporal dependencies, yet their quantum counterparts (QRNNs) face significant hurdles regarding hardware feasibility and generalization. While Quantum RNNs (QRNNs) utilizing parameterized quantum circuits (PQCs) offer potential advantages in expressibility and energy efficiency, existing implementations often rely on angle encoding, which scales linearly with the number of features ($O(N)$ qubits). Amplitude encoding offers superior qubit efficiency ($O(\log N)$) and has demonstrated higher accuracy in other quantum machine learning tasks, but it remains under-explored in fully quantum QRNNs due to two primary constraints:

1. State Preparation Complexity: Exact Quantum State Preparation (QSP) requires circuits with exponential depth, rendering them infeasible for near-term devices.
2. Information Loss: Standard amplitude encoding requires input normalization, which discards the global magnitude (amplitude) of feature vectors. This loss of magnitude information can distort sequence modeling, as vectors with different magnitudes but identical directions are encoded identically.

Furthermore, executing QRNNs on noisy hardware introduces coherence errors, particularly in the latent state register, which degrades performance.

Methodology

The authors propose three specific modifications to the canonical QRNN architecture to address these limitations. The study utilizes two financial datasets (Yahoo Finance and Oxford-Man Institute) to forecast S&P 500 daily returns, employing 8-day sequences. The models are simulated on Qiskit's AerSimulator (both noiseless and with the IBM Torino Heron r1 noise model).

1. Pre-normalized Amplitude Feature Augmentation

To mitigate the loss of magnitude information inherent in amplitude encoding, the authors introduce a preprocessing step. Before normalizing the feature vector for quantum encoding, they append a new feature representing the $\ell_2$ norm (pre-normalized amplitude) of the original vector.

• Implementation: The original $N$ features are MinMax scaled. The new amplitude feature is then scaled using either a MinMax or MaxMin scaler before the entire $N+1$ dimensional vector is normalized.
• Hypothesis: The MaxMin scaling of the amplitude feature preserves the relative relationships between samples better than MinMax scaling, allowing the model to distinguish between vectors of different magnitudes.

2. EnQode Approximate Amplitude Encoding

To overcome the exponential depth of exact QSP, the paper integrates EnQode, a classical machine learning approach for approximate state preparation.

• Mechanism: EnQode uses k-means clustering on the normalized dataset to identify centroids. A PQC Ansatz is trained classically (using symbolic representation and backpropagation) to prepare the quantum state corresponding to each centroid.
• Application: During inference, the nearest centroid to a new sample is identified, and the pre-trained parameters for that centroid are used to generate an approximate amplitude-encoded state $|\tilde{x}_t\rangle$. This allows for logarithmic scaling in circuit depth and qubit count.

3. Alternating Feature Map Register Circuit

To reduce circuit depth and decoherence errors, the authors propose a new circuit layout utilizing alternating feature map (F) registers.

• Mechanism: Instead of reusing a single F register (which requires resetting and re-encoding between time steps while preserving the hidden state), the new architecture uses two F registers. While the Ansatz PQC processes the state from time step $t-1$ in one register, the next input state $|x_t\rangle$ is prepared in the second register.
• Equivalence: Unlike the "Staggered QRNN" (SQRNN) which discards information to reset qubits, this alternating structure is mathematically equivalent to the canonical QRNN on an ideal processor but significantly reduces the required circuit depth.

Key Results

Performance Comparison (Base Models)

• Amplitude vs. Angle Encoding: The Amplitude QRNN (without modifications) achieved a lower test Mean Squared Error (MSE) of 0.009 compared to the Angle QRNN (0.015) and the classical RNN (0.012), despite having fewer trainable parameters (28 vs. 44). This confirms that amplitude encoding offers better generalization for this task.

Impact of Preprocessing

• Amplitude Feature: Adding the pre-normalized amplitude feature improved performance.
  • MinMax Scaling: Converged faster on training data but showed lower generalization.
  • MaxMin Scaling: Achieved the best generalization, reducing the test MSE to 0.0056 (a 36% improvement over the baseline Amplitude QRNN).

Impact of Approximate Encoding (EnQode)

• Fidelity vs. Depth: EnQode achieved an average state preparation fidelity of 0.94.
• Noiseless Simulation: Using EnQode increased the test loss by 40% compared to exact QSP due to state preparation errors.
• Noisy Simulation: When simulating the IBM Torino noise model, the EnQode model outperformed the exact QSP model. The reduction in circuit depth (and subsequent reduction in decoherence errors) outweighed the penalty of the 6% state preparation infidelity.

Impact of Circuit Structure

• Depth Scaling: The alternating F register architecture reduced circuit depth compared to the standard architecture.
• Scalability: While the depth difference was negligible for small feature sets (4-8 features), the paper demonstrates that the depth of the alternating structure scales more favorably as the number of features increases, particularly on processors with limited connectivity where swap gates are required.

Significance and Claims

The paper establishes a new set of best practices for implementing QRNNs on near-term hardware. The authors claim that:

1. Generalization: Augmenting amplitude-encoded inputs with pre-normalized amplitude features (specifically using MaxMin scaling) significantly improves model generalization by preserving magnitude information.
2. Feasibility: EnQode approximate amplitude encoding is a viable strategy for QRNNs. While it introduces state preparation error, the resulting reduction in circuit depth makes it superior to exact encoding in noisy environments.
3. Efficiency: The alternating F register circuit structure provides a mathematically equivalent but shallower implementation of QRNNs, directly addressing coherence constraints.

The authors conclude that these techniques are not limited to QRNNs but are applicable to other quantum sequence-learning frameworks, such as Quantum Reservoir Computing (QRC), Quantum Extreme Learning Machines (QELMs), and Quantum Hidden Markov Models (QHMMs), which share similar latent register and data encoding structures.