Quantum Recurrent Neural Networks: Predicting the Dynamics of Oscillatory and Chaotic Systems

Abstract

In this study, we investigate Quantum Long Short-Term Memory and Quantum Gated Recurrent Unit integrated with Variational Quantum Circuits in modeling complex dynamical systems, including the Van der Pol oscillator, coupled oscillators, and the Lorenz system. We implement these advanced quantum machine learning techniques and compare their performance with traditional Long Short-Term Memory and Gated Recurrent Unit models. The results of our study reveal that the quantum-based models deliver superior precision and more stable loss metrics throughout 100 epochs for both the Van der Pol oscillator and coupled harmonic oscillators, and 20 epochs for the Lorenz system. The Quantum Gated Recurrent Unit outperforms competing models, showcasing notable performance metrics. For the Van der Pol oscillator, it reports MAE 0.0902 and RMSE 0.1031 for variable x and MAE 0.1500 and RMSE 0.1943 for y; for coupled oscillators, Oscillator 1 shows MAE 0.2411 and RMSE 0.2701 and Oscillator 2 MAE is 0.0482 and RMSE 0.0602; and for the Lorenz system, the results are MAE 0.4864 and RMSE 0.4971 for x, MAE 0.4723 and RMSE 0.4846 for y, and MAE 0.4555 and RMSE 0.4745 for z. These outcomes mark a significant advancement in the field of quantum machine learning.

1. Introduction

Ordinary differential equations (ODEs) are foundational mathematical models that play a critical role across diverse domains, such as physics [1], biology [2,3], and economics [4]. The numerical resolution of ODE systems is pivotal for understanding the dynamics of these varied processes. To this end, numerous methodologies have been devised, including linear multistep methods [5,6] and Runge–Kutta methods [7,8]. Nevertheless, the practical application of these methods frequently encounters the complexity of systems characterized by nonlinear and time-varying elements, alongside a pronounced sensitivity to initial conditions. Such complexities [9] significantly challenge the efficacy of traditional analytical and numerical strategies, especially in terms of achieving desired levels of precision, stability, and computational efficiency. Given these considerations, there is a pressing need for more sophisticated techniques capable of navigating the intricate landscape of ODE systems.

In recent years, recurrent neural networks (RNNs) have achieved significant breakthroughs in processing sequential data. RNNs have been used extensively in various domains, including but not limited to, time series data prediction [10,11,12], machine translation [13], and speech recognition [14]. Notably, RNNs have also played a critical role in scientific research [15,16], an area of particular interest to us. Within this framework, RNNs and their specific variants, such as Long Short-Term Memory (LSTM) [17] and Gated Recurrent Units (GRUs) [18], have proven to be efficacious in learning or forecasting complex, nonlinear challenges. The intrinsic nature of RNNs, which are capable of capturing temporal dependencies and learning from sequential data, makes them particularly suited for modeling dynamical systems. Unlike conventional approaches that require explicit numerical schemes for integration over time, RNNs can implicitly learn the underlying dynamics from data, offering a way to bypass the complexities of directly solving ordinary differential equations (ODEs). This capability allows for the modeling of complex systems with high degrees of freedom and nonlinearity, providing a flexible and potentially more accurate alternative to traditional methods. Consequently, the use of RNNs in solving ODEs, especially systems of ODEs, represents a significant shift towards data-driven approaches in the prediction of dynamical [19,20,21,22] and time series chaotic systems [23,24,25,26].

Concurrently, quantum computing has been advancing rapidly, spearheaded by technology giants such as IBM [27], Google [28], PennyLane [29], and D-Wave Systems [30]. These quantum systems offer theoretical advantages for specific computational tasks and simulations of intricate quantum phenomena. However, the practical utility of current Noisy Intermediate-Scale Quantum (NISQ) devices is constrained by limitations in quantum error correction [31,32,33]. This limitation poses a significant challenge, as it restricts the reliability and scalability of quantum computations, impeding their broader application in complex problems.

The advent of variational quantum algorithms and circuits, pioneered by Mitarai et al. [34], has been a landmark development in the integration of quantum computing with machine learning. These algorithms leverage quantum entanglement to address fundamental machine learning challenges, such as function approximation and classification [34,35]. More studies about variational quantum algorithms and circuits can be found here [36]. This innovation has facilitated the development of hybrid quantum–classical algorithms, adaptable for use on existing Noisy Intermediate-Scale Quantum (NISQ) devices. Such hybrid approaches have shown promise across various domains, including classification [37,38], generative adversarial learning [39], and deep reinforcement learning [40]. Furthermore, the exploration of quantum machine learning [41,42,43,44,45,46] has opened a new path for processing and analyzing data, harnessing the unique computational capabilities of quantum systems.

Among the studies, the study by Chen et al. [47,48] innovated in the quantum machine learning domain by introducing Quantum LSTM (QLSTM) and Quantum GRU (QGRU), integrating variational quantum circuits (VQCs) with recurrent neural network architectures. Designed for Noisy Intermediate-Scale Quantum (NISQ) devices, these quantum models utilize quantum entanglement to enhance learning efficiency and stability. Their research showcases that QLSTM and QGRU outperform traditional LSTM models in terms of learning efficiency and convergence stability, marking a significant step in sequential data learning within the quantum computing sphere. However, the scenarios examined in Chen’s studies [47,48] only involved singular ODEs, which prompted us to explore the application of QRNN to systems of ODEs.

In this research, we explore the application of Quantum Long Short-Term Memory (QLSTM) and Quantum Gated Recurrent Unit (QGRU) models, based on the Variational Quantum Circuits (VQCs) developed by Chen et al. [47,48], to complex dynamical systems described by ODEs. Our approach involves a nuanced modification to the VQC, thereby refining its compatibility with QLSTM and QGRU models for their application in this context. Our focus is on the Van der Pol oscillator, two coupled damped harmonic oscillators, and the Lorenz equations. We conduct a comparative analysis of these quantum models against their classical counterparts, LSTM and GRU, focusing on error metrics and loss evolution across epochs. This comparison aims to evaluate their effectiveness in modeling and predicting the dynamics of nonlinear and chaotic systems.

The structure of this paper is organized as follows: Section 2 presents an overview of fundamental concepts in quantum computing, including qubits, superposition, quantum gates, and entanglement. In Section 3, we introduce the computational models under investigation, namely variational quantum circuits, classical Long Short-Term Memory (LSTM), classical Gated Recurrent Unit (GRU), Quantum Long Short-Term Memory (QLSTM), and Quantum Gated Recurrent Unit (QGRU). Section 4 introduces three numerical experiments conducted to evaluate these models, including the Van der Pol oscillator, two coupled damped harmonic oscillators, and the Lorenz equations system. Section 5 is the discussion and Section 6 is the conclusion.

2. Fundamental Quantum Computing Concepts

2.1. Qubits

The core distinction between classical and quantum computing lies in their fundamental units of information: the classical bit and the quantum bit (qubit), respectively. In classical computing, a bit is a binary unit that can exist in one of two states, either 0 or 1. This binary nature underpins all classical computing processes, with data storage and computations executed through combinations of these binary states.

In contrast, the qubit, the fundamental unit of quantum computing, transcends this binary limitation. A qubit differs from a classical bit in its ability to exist in a superposition of states. Rather than being limited to a strict 0 or 1, a qubit can represent both 0 and 1 simultaneously, a phenomenon that is central to quantum computing’s potential for processing complexity.

This unique property of qubits arises from the principles of quantum mechanics. Unlike classical bits, whose state is definite and observable, a qubit’s state is described probabilistically. The actual state of a qubit is not determined until it is measured. Before measurement, a qubit exists in a superposition of the states $|0\rangle$ and $|1\rangle$, where the probabilities of these states are determined by quantum amplitudes. These amplitudes, which are complex numbers, dictate the likelihood of the qubit collapsing into either the $|0\rangle$ or $|1\rangle$ state upon measurement.

The concept of superposition enables qubits to perform computations on a scale and at a speed unattainable by classical bits. This capability forms the basis for quantum computing’s potential to solve problems that are currently intractable for classical computers, which will be introduced in the following section.

2.2. Superpositions

Superposition in a quantum system allows a qubit to exist in multiple states simultaneously until it is measured. This characteristic differentiates a quantum bit from a classical bit, which can only be in one state at any given time. In a single qubit system, the state of a qubit can be described as a linear combination of the basis states $|0\rangle$ and $|1\rangle$. Mathematically, this is represented as:

$$\begin{array}{c}\hfill |\psi \rangle =\alpha |0\rangle +\beta |1\rangle ,\end{array}$$

(1)

where $\alpha$ and $\beta$ are complex numbers representing the probability amplitudes for the qubit being in state $|0\rangle$ and $|1\rangle$, respectively. According to the Born’s rule, the probabilities of finding the qubit in either state upon measurement are ${\left|\alpha \right|}^2$ and ${\left|\beta \right|}^2$, with the condition that ${\left|\alpha \right|}^2+{\left|\beta \right|}^2=1$.

For example, if $\alpha =\sqrt{0.3}$ and $\beta =\sqrt{0.7}$, the qubit has a 30% probability of being measured in state $|0\rangle$ and a 70% probability of being in state $|1\rangle$.

Extending the concept of superposition to a two-qubit system, we find a more complex scenario. In a two-qubit system, the combined state can be represented as a superposition of all four possible states of the two qubits. The state vector for such a system is given by:

$$\begin{array}{c}\hfill |\Psi \rangle =\alpha |00\rangle +\beta |01\rangle +\gamma |10\rangle +\delta |11\rangle ,\end{array}$$

(2)

where $\alpha ,\beta ,\gamma ,$ and $\delta$ are complex probability amplitudes corresponding to each of the four states. As per the normalization condition, the sum of the squares of the absolute values of these amplitudes must equal one:

$$\begin{array}{c}\hfill {\left|\alpha \right|}^2+{\left|\beta \right|}^2+{\left|\gamma \right|}^2+{\left|\delta \right|}^2=1.\end{array}$$

(3)

For instance, if the amplitudes are $\alpha =\sqrt{0.1},\beta =\sqrt{0.2},\gamma =\sqrt{0.3}, \mathrm{and} \delta =\sqrt{0.4}$, the probabilities of measuring the system in the states $|00\rangle ,|01\rangle ,|10\rangle ,$ and $|11\rangle$ are 10%, 20%, 30%, and 40%, respectively.

In both single and two-qubit systems, superposition allows quantum computers to process and encode information in ways that are fundamentally different from classical computers, enabling them to perform complex calculations more efficiently.

In traditional computing, gates are fundamental building blocks that process binary information, operating on bits that exist in one of two states: 0 or 1. Common logic gates include AND, OR, NOT, and XOR, each performing a specific logical operation for computational tasks.

Similarly, quantum computing has quantum gates, which manipulate qubits, such as the Hadamard, Pauli-X, Y, Z, and Controlled-NOT (CNOT) gates, operating on these qubits, enabling complex operations that can entangle qubits, and creating correlations between them that are essential for quantum computation’s power. These gates are unitary, meaning they are reversible, a property that contrasts with some irreversible classical gates.

Here, we introduce one of the fundamental gates in quantum computing, the Hadamard gate, often used to create a superposition of states. The Hadamard gate acts on a single qubit and transforms it into a superposition of its basis states.

The Hadamard gate is represented by the following matrix:

$$\begin{array}{c}\hfill H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right).\end{array}$$

(4)

This matrix operates on a qubit state vector, transforming it from a definite state ($|0\rangle$ or $|1\rangle$) into a superposition. When the Hadamard gate acts on the state $|0\rangle$ (represented by the vector $\left(\begin{array}{c}1\\ 0\end{array}\right)$), the resulting state is:

$$\begin{array}{c}\hfill H|0\rangle =\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)\left(\begin{array}{c}1\\ 0\end{array}\right)=\frac{1}{\sqrt{2}}\left(\begin{array}{c}1\\ 1\end{array}\right)=\frac{|0\rangle +|1\rangle }{\sqrt{2}}.\end{array}$$

(5)

Similarly, when it acts on the state $|1\rangle$ (represented by the vector $\left(\begin{array}{c}0\\ 1\end{array}\right)$), the output is:

$$\begin{array}{c}\hfill H|1\rangle =\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)\left(\begin{array}{c}0\\ 1\end{array}\right)=\frac{1}{\sqrt{2}}\left(\begin{array}{c}1\\ -1\end{array}\right)=\frac{|0\rangle -|1\rangle }{\sqrt{2}}.\end{array}$$

(6)

The Hadamard gate, therefore, creates an equal superposition of the $|0\rangle$ and $|1\rangle$ states.

2.3. Quantum Entanglement

Quantum entanglement is a phenomenon in which multiple qubits become interconnected in such a way that the state of one qubit cannot be described independently of the state of the other qubits, even when the qubits are separated by large distances.

To explain the significance of entanglement in this study, consider an analogy involving the conventional method of information exchange between two individuals. The most traditional method of information exchange involves one individual physically moving within audible distance to relay news to another person. This method, while effective, is indeed time-consuming and limits the speed of information transfer. However, by incorporating quantum entanglement into our framework to enable instantaneous information exchange between two entangled parties we significantly enhance the efficiency and speed of learning. This quantum advantage mirrors the leap from having to physically move towards someone to share information, to an immediate and direct exchange of knowledge.

Entanglement can be achieved using certain quantum gates. For instance, the combination of a Hadamard gate followed by a Controlled-NOT (CNOT) gate is commonly used to entangle two qubits.

First, the Hadamard gate is applied to one of the qubits to create a superposition, as previously discussed. Then, the CNOT gate, which flips the state of the second qubit if the first qubit is in the $|1\rangle$ state, is applied. The operation of the CNOT gate can be described by the following matrix:

$$\begin{array}{c}\hfill \mathrm{CNOT}=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right).\end{array}$$

(7)

This operation creates entanglement between the two qubits.

Consider two qubits, initially in the state $|00\rangle$. Applying a Hadamard gate to the first qubit creates the superposition $\frac{|0\rangle +|1\rangle }{\sqrt{2}}$ for the first qubit. Now, the combined state of the two qubits is $\frac{|00\rangle +|10\rangle }{\sqrt{2}}$. Applying a CNOT gate afterward results in the entangled state $\frac{|00\rangle +|11\rangle }{\sqrt{2}}$, where the state of each qubit cannot be described independently of the other.

3. Methodology

3.1. Variational Quantum Circuits (VQCs)

Variational Quantum Circuits (VQCs) are the unique part of the architecture of quantum recurrent neural networks. The specific VQC components used in this context are structured in three main parts: an encoding layer, a variational layer, and a quantum measurement layer. Figure 1 shows an example of a VQC.

The left-hand part of the figure is the encoding layer, which contains a Hadamard gate, two angle embedding layers working as $R_y$ and $R_z$ gates in the quantum concept. The middle part is the variational layer (entanglement layer). It is worth mentioning that the number of qubits (in this example is 4), and the number of variational layers (in this example is 2), can be modified to increase the capability to learn the data.

3.1.1. Encoding Layer

The encoding layer’s primary function is to map classical data values into quantum amplitudes. It starts with initializing the circuit in the ground state and applying Hadamard gates to create an unbiased initial state. The state of an N-qubit quantum system can be represented as:

$$\begin{array}{c}\hfill |\psi \rangle =\sum _{(q_1,q_2,\dots ,q_N)\in {\{0,1\}}^N}{c}_{q_1,q_2,\dots ,q_N}|q_1\rangle \otimes |q_2\rangle \otimes \dots \otimes |q_N\rangle ,\end{array}$$

(8)

where $c_{q_1,\dots ,q_N}\in \mathbb{C}$ is the complex amplitude for each basis state and ⊗ stands for tensor product. Again, by the Born’s rule, we know that:

$$\begin{array}{c}\hfill \sum _{(q_1,q_2,\dots ,q_N)\in {\{0,1\}}^N}{\parallel c_{q_1,\dots ,q_N}\parallel }^2=1.\end{array}$$

(9)

The encoding layer first transforms the input data into rotation angles to the rotation of each single qubit. We apply the Hadamard gate here and transform the initial state into a superposition, also called the unbiased state. After applying the Hadamard gate H N times (once to each qubit), we will obtain:

$$\begin{array}{c}\hfill {\left(H\right|0\rangle )}^{\otimes N}={\left(\frac{1}{\sqrt{2}}\left(\right|0\rangle +|1\rangle )\right)}^{\otimes N}.\end{array}$$

(10)

The resulting state after applying the Hadamard gate N times is a uniform superposition of all possible states of N qubits, which can be expressed as:

$$\begin{array}{c}\hfill \frac{1}{\sqrt{2^N}}\left({|0\rangle }^{\otimes N}+\cdots +{|1\rangle }^{\otimes N}\right).\end{array}$$

(11)

Hence,

$$\begin{array}{c}\hfill \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|i\rangle .\end{array}$$

(12)

Here, i is used as an index to sum over all possible states, where i represents the decimal equivalent of the binary numbers formed by the qubits. For example, for $N=2$, the sum would run over $|00\rangle$, $|01\rangle$, $|10\rangle$, and $|11\rangle$, which correspond to decimal 0, 1, 2, and 3, respectively.

The encoding process involves using two-angle encoding, where each data value is encoded to a qubit with a series of two gates, $R_y$ and $R_z$. In this study, a template named $qml.templates.AngleEmbedding$ is used to play the role of $R_y$ and $R_z$.

The $qml.templates.AngleEmbedding$ template effectively maps classical information onto the quantum states by applying specific rotation gates to each qubit in the system. This template can be customized for various aspects of the embedding, including selecting the axis of rotation $R_x$, $R_y$, or $R_z$. This adaptability makes the template well-suited for a broad spectrum of applications within the domain of quantum neural networks and other machine learning models.

After transforming the initial states into unbiased states, we will use $2N$ rotational angles from an N-dimensional input vector, $\overrightarrow{v}=(x_1,x_2,\dots ,x_N)$. For each component $x_i$ of $\overrightarrow{v}$, in Chen’s original paper, the two angles are calculated: ${\theta }_{i,1}=arctan\left(x_i\right)$ for y-axis rotation and ${\theta }_{i,2}=arctan\left(x_i^2\right)$ for z-axis rotation, where the rotations are effected through $R_y\left({\theta }_{i,1}\right)$ and $R_z\left({\theta }_{i,2}\right)$ gates, respectively.

Despite normalizing the input data before the encoding layer, this work introduces a distinct methodology. Rather than employing arctan functions, we select the sin and cos functions for the $R_y\left({\theta }_{i,1}\right)$ and $R_z\left({\theta }_{i,2}\right)$ gates, respectively. This entails setting ${\theta }_{i,1}=sin\left(x_i\right)$ for the $R_y$ gate and ${\theta }_{i,2}=cos\left(x_i^2\right)$ for the $R_z$ gate, diverging from conventional arctan applications. This method represents a preliminary attempt in practice and it can be improved in future work, which is not covered within this paper. More studies related to this aspect can be found in Mitarai’s paper [34].

3.1.2. Variational Circuit

The variational circuit is the trainable part of the VQC, consisting of parameterized unitary transformations. This section of the circuit includes multiple CNOT gates for qubit entanglement and unitary rotation gates controlled by learnable parameters $\alpha ,\beta ,$ and $\gamma$. It is worth mentioning that the variational circuit can be repeated more than one time in practice to increase the number of parameters and the model’s expressive capacity.

3.1.3. Quantum Measurement

Quantum measurement is used for extracting classical information from the quantum circuit. It involves measuring the qubits, which, due to the probabilistic nature of quantum systems, yield varying bit strings upon each measurement. The expectation value of an operator $\hat{O}$ for a state $|\psi \rangle$ is given by:

$$\begin{array}{c}\hfill E\left[\hat{O}\right]=\langle \psi |\hat{O}|\psi \rangle .\end{array}$$

(13)

The expectation values can be either calculated analytically in a quantum simulation or obtained through multiple samplings in practical quantum devices with specific noise models.

The VQC architecture described here is pivotal in the QLSTM and QGRU, as a quantum-enhanced approach to processing and learning from data.

3.2. Long Short-Term Memory (LSTM)

Long Short-Term Memory (LSTM) networks are a type of recurrent neural network (RNN) particularly adept at learning from sequences of data. LSTMs are designed to overcome the limitations of traditional RNNs, especially issues related to long-term dependencies in data sequences. Figure 2 shows the structure of a single LSTM unit.

An LSTM unit is composed of a cell, an input gate, an output gate, and a forget gate. These components work together to regulate the flow of information into and out of the cell, and to decide which information to store and which to discard.

The key equations governing the operations within an LSTM unit are as follows:

$$\begin{array}{cc}\hfill f_t& =\sigma (W_f·[h_{t-1},x_t]+b_f),\hfill \end{array}$$

(14)

$$\begin{array}{cc}\hfill i_t& =\sigma (W_i·[h_{t-1},x_t]+b_i),\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill {\tilde{C}}_t& =tanh(W_C·[h_{t-1},x_t]+b_C),\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill C_t& =f_t\ast C_{t-1}+i_t\ast {\tilde{C}}_t,\hfill \end{array}$$

(17)

$$\begin{array}{cc}\hfill o_t& =\sigma (W_o·[h_{t-1},x_t]+b_o),\hfill \end{array}$$

(18)

$$\begin{array}{cc}\hfill h_t& =o_t\ast tanh\left(C_t\right).\hfill \end{array}$$

(19)

Here, $f_t$, $i_t$, and $o_t$ represent the activations of the forget, input, and output gates, respectively, at time t. $\sigma$ denotes the sigmoid function, and ∗ represents element-wise multiplication. $C_t$ is the cell state at time t, and $h_t$ is the hidden state. W and b are the weights and biases associated with the respective gates and cell state updates.

3.3. Gated Recurrent Units (GRU)

Gated Recurrent Unit (GRU) is a variation of recurrent neural networks that aims to solve the vanishing gradient problem, similar to LSTM. GRUs simplify the architecture seen in LSTM by combining certain gates and states, which often results in more efficient training for certain types of problems. The structure of a single GRU is shown in Figure 3.

The GRU architecture is built around two gates: the update gate and the reset gate. These gates determine how much of the past information needs to be passed along to the future. The key equations defining a GRU are:

$$\begin{array}{cc}\hfill z_t& =\sigma (W_z·[h_{t-1},x_t]+b_z),\hfill \end{array}$$

(20)

$$\begin{array}{cc}\hfill r_t& =\sigma (W_r·[h_{t-1},x_t]+b_r),\hfill \end{array}$$

(21)

$$\begin{array}{cc}\hfill {\tilde{h}}_t& =tanh(W·[r_t\ast h_{t-1},x_t]+b),\hfill \end{array}$$

(22)

$$\begin{array}{cc}\hfill h_t& =(1-z_t)\ast h_{t-1}+z_t\ast {\tilde{h}}_t.\hfill \end{array}$$

(23)

In Equations (20)–(23), $z_t$ and $r_t$ represent the activations of the update and reset gates at time t, respectively. $h_t$ is the hidden state at time t, and ${\tilde{h}}_t$ is the candidate hidden state. W and b are the weights and biases associated with the respective gates and hidden state updates. The symbol ∗ denotes element-wise multiplication, and $\sigma$ represents the sigmoid activation function.

GRUs provide an efficient alternative to LSTM and are particularly useful in modeling sequences where LSTM’s complex structure may not be necessary.

We need to consider the hardware realization of two activation functions here, which are the $tanh$ and $sigmoid$ functions. On classical hardware, $tanh$ and $sigmoid$ functions are computed directly, introducing nonlinearity in neural networks crucial for learning complex patterns:

$$\begin{array}{cc}\hfill tanh\left(x\right)& =\frac{e^{2x}-1}{e^{2x}+1},\hfill \end{array}$$

(24)

$$\begin{array}{cc}\hfill \sigma \left(x\right)& =\frac{1}{1+e^{-x}}.\hfill \end{array}$$

(25)

Classical computers execute these operations efficiently using their processing capabilities. However, quantum hardware employs a different approach due to its linear operation nature, making direct computation of $tanh$ and $sigmoid$ functions non-trivial. The encoding and variational layers in the VQCs allow the quantum-based models to catch the nonlinear trends across data inputs. Additionally, the measurement layer outputs values within the range of $[-1,1]$, which can then be processed classically to implement these nonlinear functions.

3.4. Quantum Long Short-Term Memory (QLSTM)

Quantum Long Short-Term Memory (QLSTM) is a quantum-enhanced version of the traditional LSTM networks. QLSTM integrates VQCs into the LSTM architecture, aiming to leverage the computational advantages of quantum mechanics. The structure of a single QLSTM unit is shown in Figure 4.

In a QLSTM, two key memory components are present: the hidden state $h_t$ and the cell or internal state $c_t$. The functioning of a QLSTM cell can be mathematically described by the following equations:

$$\begin{array}{cc}\hfill f_t& =\sigma \left(\mathrm{VQC}1\left(v_t\right)\right),\hfill \end{array}$$

(26)

$$\begin{array}{cc}\hfill i_t& =\sigma \left(\mathrm{VQC}2\left(v_t\right)\right),\hfill \end{array}$$

(27)

$$\begin{array}{cc}\hfill {\tilde{C}}_t& =tanh\left(\mathrm{VQC}3\left(v_t\right)\right),\hfill \end{array}$$

(28)

$$\begin{array}{cc}\hfill c_t& =f_t\ast c_{t-1}+i_t\ast {\tilde{C}}_t,\hfill \end{array}$$

(29)

$$\begin{array}{cc}\hfill o_t& =\sigma \left(\mathrm{VQC}4\left(v_t\right)\right),\hfill \end{array}$$

(30)

$$\begin{array}{cc}\hfill h_t& =\mathrm{VQC}5(o_t\ast tanh\left(c_t\right)),\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill {\tilde{y}}_t& =\mathrm{VQC}6(o_t\ast tanh\left(c_t\right)),\hfill \end{array}$$

(32)

$$\begin{array}{cc}\hfill y_t& =\mathrm{NN}\left({\tilde{y}}_t\right).\hfill \end{array}$$

(33)

In Equations (26)–(33), $\sigma$ represents the sigmoid function, and ∗ denotes element-wise multiplication. The input to the QLSTM cell at each time step is the concatenation $v_t$ of the previous hidden state $h_{t-1}$ and the current input vector $x_t$. The VQCs mentioned in the equations refer to Variational Quantum Circuits.

3.5. Quantum Gated Recurrent Unit (QGRU)

Quantum Gated Recurrent Unit (QGRU) represents an evolution of traditional GRU networks, integrating with VQCs. The structure of a single QGRU unit is shown in Figure 5.

A QGRU cell operates based on the following equations:

$$\begin{array}{cc}\hfill r_t& =\sigma \left(\mathrm{VQC}1\left(v_t\right)\right),\hfill \end{array}$$

(34)

$$\begin{array}{cc}\hfill z_t& =\sigma \left(\mathrm{VQC}2\left(v_t\right)\right),\hfill \end{array}$$

(35)

$$\begin{array}{cc}\hfill o_t& =\mathrm{cat}(x_t,r_t\ast H_{t-1}),\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill {\tilde{H}}_t& =tanh\left(\mathrm{VQC}3\left(o_t\right)\right),\hfill \end{array}$$

(37)

$$\begin{array}{cc}\hfill H_t& =z_t\ast H_{t-1}+(1-z_t)\ast {\tilde{H}}_t,\hfill \end{array}$$

(38)

$$\begin{array}{cc}\hfill y_t& =\mathrm{NN}\left(H_t\right).\hfill \end{array}$$

(39)

In Equations (34)–(39), $r_t$ and $z_t$ represent the reset and update gates of the QGRU at time t, respectively. $H_t$ denotes the hidden state, and ${\tilde{H}}_t$ is the candidate hidden state. The input to the QGRU cell, $v_t$, is the concatenation of the previous hidden state $H_{t-1}$ and the current input vector $x_t$. The VQCs are used to process the quantum aspects of the data.

4. Numerical Experiments

4.1. Hyperparameter Configuration

For the numerical experiments conducted in this study, specific hyperparameters were chosen to optimize the performance of the quantum models.

Table 1. Hyperparameter configuration.

Hyperparameter	QRNNs Value	RNNs Value
Optimizer	RMSprop	Adam
Loss Function	MSE	MSE
Backend	default.qubit	-
Number of Qubits	4	-
Layer of Entanglements	4	-
Number of Data Points	250	250
Percentage of Train Set	67%	67%
Percentage of Test Set	33%	33%
Learning Rate	0.01	0.01

outlines the hyperparameter configuration used in the Van der Pol oscillator simulation and the simulation of two coupled damped harmonic oscillators:

More specifically, we are using a single-layer model with hidden size 4, and the models are evaluating over 100 epochs. We are using the backend $default.qubit$ by PennyLane [16].

4.2. Van der Pol Oscillator Simulation

In the first experiment, we consider the Van der Pol oscillator, a classical example of a non-conservative oscillator with nonlinear damping. The oscillator is modeled by the following second-order differential equation:

$$\frac{d^{2}x}{d{t}^2}-\mu (1-x^2)\frac{dx}{dt}+x=0.$$

(40)

The parameter $\mu$, representing the nonlinearity and strength of the damping, is set to $1.0$ in our simulations. This choice of $\mu$ provides a balance between linear and nonlinear dynamical behaviors, also making the system ideal for predicting a wide range of oscillatory patterns.

The initial conditions for the oscillator are chosen as $x_0=2.0$ and $y_0=0.0$, where $x_0$ and $y_0$ represent the initial position and velocity, respectively.

To numerically solve the Van der Pol differential equation, we convert it into a system of first-order equations:

$$\begin{array}{cc}\hfill \frac{dx}{dt}& =y,\hfill \\ \hfill \frac{dy}{dt}& =\mu (1-x^2)y-x.\hfill \end{array}$$

(41)

The numerical solution is obtained over a time span of 0 to 50 s, discretized into 250 time steps.

Following the numerical solution of the differential equations, the resultant time series data of x and y are normalized and prepared for analysis. The data are reshaped to fit the input requirements of RNN models, enabling us to predict the Van der Pol oscillator’s dynamics.

Simulation Results for the Van der Pol Oscillator

The behavior of the Van der Pol oscillator was examined through the LSTM, QLSTM, GRU, and QGRU models by evaluating their performance on the Mean Absolute Error (MAE) and Root Mean Square Error (RMSE) metrics.

Mean Absolute Error (MAE) is a measure of errors between paired observations. It is calculated as the average of the absolute differences between the predicted values and the actual values, disregarding the direction of the error. The MAE is given by the formula:

$$MAE=\frac{1}{n}\sum _{i=1}^n\left|y_i-{\hat{y}}_i\right|.$$

(42)

Root Mean Square Error (RMSE) is a quadratic scoring rule that also measures the average magnitude of the error. It is the square root of the average of squared differences between prediction and actual observation. The RMSE is given by the formula:

$$RMSE=\sqrt{\frac{1}{n}\sum _{i=1}^n{\left(y_i-{\hat{y}}_i\right)}^2},$$

(43)

where:

• n is the number of observations;
• $y_i$ is the actual value of the ith observation;
• ${\hat{y}}_i$ is the predicted value of the ith observation.

Data from the numerical solution of the Van der Pol differential equations formed the basis for training and testing these models. A comparative analysis of the models’ performance is summarized in

Table 2. Comparison of train and test MAE and RMSE for the state of x.

Model	Train MAE	Test MAE	Train RMSE	Test RMSE
LSTM	0.2601	0.2585	0.3002	0.2986
QLSTM	0.1411	0.1397	0.1648	0.1641
GRU	0.1597	0.1591	0.1845	0.1850
QGRU	0.0868	0.0902	0.1013	0.1031

and

Table 3. Comparison of train and test MAE and RMSE for the state of y.

Model	Train MAE	Test MAE	Train RMSE	Test RMSE
LSTM	0.3224	0.3294	0.3737	0.3828
QLSTM	0.1959	0.1851	0.2498	0.2384
GRU	0.3336	0.3375	0.4319	0.4384
QGRU	0.1473	0.1500	0.1931	0.1943

.

Table 2 shows that quantum-based models exhibit superior predictive performance on x value over classical models. Among the models compared, the GRU models also outshine the LSTM models in accuracy and QGRU model gives us the most accurate predictions.

Table 3 compares model performances on the y value. It is very interesting to see that the models produced more error on the prediction of the y values compared to the x values. Moreover, GRU models surpass LSTM models in terms of results, with the QGRU model achieving the highest accuracy among the evaluated models.

The example predictive results over epochs by the different models are shown in Figure 6, Figure 7, Figure 8, Figure 9 and Figure 10.

It is observable that the Van der Pol oscillator exhibits periodic behavior. It can be seen that all the models caught the patterns well. It can be observed that the QRNN models, especially, learn significantly faster than the classical RNN models from the comparison through epoch 5. Again, the QGRU model shows great capability in learning the dynamics.

By comparing the training and test loss over the epochs, the QRNN models show more stable decrease than the classical RNN models and the QGRU converges faster than QLSTM.

4.3. Two Coupled Damped Harmonic Oscillators Simulation

In this experiment, we study the capability the QRNN in learning the patterns in the system of two coupled harmonic oscillators. It is worth pointing out that this experiment actually is an extension of the prediction on a single damped harmonic oscillator by Chen [34,35]. This experiment extends our understanding not only from a single oscillator, but physical systems by introducing interactions between oscillatory motions. Such systems are paramount in numerous fields, including physics and engineering. The governing differential equations for two coupled damped harmonic oscillators, representing an extended model of the single oscillator, are as follows:

$$\begin{array}{cc}\hfill \frac{d^2{\theta }_1}{d{t}^2}& =-\frac{b_1}{m_1}\frac{d{\theta }_1}{dt}-\frac{g}{l_1}sin\left({\theta }_1\right)+\frac{k_c}{m_1}({\theta }_2-{\theta }_1),\hfill \\ \hfill \frac{d^2{\theta }_2}{d{t}^2}& =-\frac{b_2}{m_2}\frac{d{\theta }_2}{dt}-\frac{g}{l_2}sin\left({\theta }_2\right)+\frac{k_c}{m_2}({\theta }_1-{\theta }_2).\hfill \end{array}$$

(44)

Here, ${\theta }_1$ and ${\theta }_2$ represent the angular displacements of the first and second pendulums, respectively. The constants $g=9.81$ m/s² (gravitational acceleration), $b_1=b_2=0.15$ (damping factors), $l_1=l_2=1.0$ m (lengths of the pendulums), $m_1=m_2=1.0$ kg (masses of the pendulums), and $k_c=0.05$ (coupling constant) define the system’s characteristics. The initial conditions are set with angular displacements ${\theta }_1={\theta }_2=0$ and angular velocities $\dot{{\theta }_1}=3.0$, $\dot{{\theta }_2}=0.0$ rad/s.

Simulation Results for the Two Coupled Damped Harmonic Oscillators

Just like the Van der Pol example, we present a comparative analysis of the models’ performance in predicting the dynamic behavior of both oscillators (again, with MAE and RMSE), which are summarized in

Table 4. Comparison of train and test MAE and RMSE for Oscillator 1.

Model	Train MAE	Test MAE	Train RMSE	Test RMSE
LSTM	0.5467	0.4371	0.7761	0.4922
QLSTM	0.5284	0.4763	0.6987	0.5374
GRU	0.3648	0.4396	0.4499	0.4941
QGRU	0.2585	0.2411	0.3587	0.2701

and

Table 5. Comparison of train and test MAE and RMSE for Oscillator 2.

Model	Train MAE	Test MAE	Train RMSE	Test RMSE
LSTM	0.2190	0.3597	0.2814	0.4248
QLSTM	0.1244	0.2591	0.1607	0.2885
GRU	0.1160	0.0858	0.1483	0.1006
QGRU	0.0794	0.0482	0.0949	0.0602

.

Like the results from the first experiment, in Table 4 and Table 5 all the models successfully learn the dynamics, but the QGRU shows excellent predictive results, especially on the prediction of Oscillator 2. We noticed, first, that the predictions on Oscillator 2 are more accurate than Oscillator 1. Second, we noticed that the GRU models outshine LSTM models in general.

The example predictive results over the 100 epochs by the different models are shown in Figure 11, Figure 12, Figure 13, Figure 14 and Figure 15.

Similar to the Van der Pol case, the GRU models converge faster than the LSTM models and the quantum-based models learn the pattern faster than the classical models (which can be seen by the comparison on the results on epoch 5). The quantum-based RNNs also show stabler decrease in loss. Here, we observe several points of interest: Firstly, there is a minor increase in the test loss in LSTM models from epoch 80 to 100, potentially indicative of mild overfitting. Although adjusting the learning rate could mitigate this, we maintain a constant learning rate to achieve a straightforward comparison between the models. Secondly, spikes are observed in the LSTM model’s test loss. Furthermore, at epoch 5, the LSTM model exhibits an undershot in performance, which is not seen in the results of the other models.

From the previous two numerical experiments, the QRNN models demonstrate exceptional capability in learning patterns by system dynamics. In the last experiment, we apply the models to chaotic systems using a different approach.

4.4. System of Lorenz Equations

The Lorenz equations, fundamental in chaos theory, model the dynamics of atmospheric convection and are characterized by their chaotic nature for certain parameter values. The system is described by the following set of differential equations:

$$\begin{array}{cc}\hfill \frac{dx}{dt}& =\sigma (y-x),\hfill \\ \hfill \frac{dy}{dt}& =x(\rho -z)-y,\hfill \\ \hfill \frac{dz}{dt}& =xy-\beta z.\hfill \end{array}$$

(45)

In Equation (45), $x,y,$ and z represent the system states, and the parameters $\sigma ,\rho ,$ and $\beta$ are crucial for the system’s behavior. The chosen values $\sigma =10.0$, $\beta =\frac{8}{3}$, and $\rho =28.0$ are known to induce chaotic dynamics in the Lorenz system. These parameters represent the Prandtl number, normalized Rayleigh number, and certain physical dimensions of the convective cells, respectively. Their specific values make the system a classic example of chaos, making it a compelling subject for studying the predictive capabilities of quantum-enhanced and classical neural networks. Particularly, the research on the utilization of classical neural networks is discussed in [49].

Data Preparation and Hyperparameter Configuration

Unlike the previous two experiments, we generated the data differently in the application of RNN models on Lorenz equations. We first randomly generated 10 datasets; we used 67% of them for training and the remaining 33% for testing. The shapes of the training and test datasets are as follows:

• Training dataset shapes:

  –

  Features: torch.Size([3120, 10, 3]);

  –

  Labels: torch.Size([3120, 3]).

• Testing dataset shapes:

  –

  Features: torch.Size([780, 10, 3]);

  –

  Labels: torch.Size([780, 3]).

Regarding the hyperparameter aspect, the previous two experiments demonstrate that QRNN models rapidly catch the trend of the dataset. Consequently, we aim to explore more about these models’ proficiency in learning features with shorter sequence lengths, reduced data points, and fewer epochs.

We pick sequence length 10 for all the models and all the models will be running over 20 epochs instead of the 100 epochs in the previous two experiments.

Hyperparameter configurations for LSTM, QLSTM, GRU, and QGRU models are presented in

Table 6. Hyperparameter configuration for classic models and quantum models.

Hyperparameter	Quantum	Classic
Optimizer	RMSprop	Adam
Loss Function	MSE	MSE
Backend	default.qubit	-
Number of Qubits	4	-
VQC Layer	4	-
Percentage of Train Set	67%	67%
Percentage of Test Set	33%	33%
Epochs	20	20
Learning Rate	0.01	0.01

:

4.5. Results Analysis

The performances of each model on the Lorenz system data are summarized in

Table 7. Mean Absolute Error (MAE) for each model on test set.

Model	X	Y	Z
LSTM	2.0361	2.1232	2.2119
QLSTM	0.8820	0.9473	1.0206
GRU	1.1684	1.1719	1.1710
QGRU	0.4864	0.4723	0.4555

and

Table 8. Root Mean Square Error (RMSE) for each model on test set.

Model	X	Y	Z
LSTM	2.1736	2.2718	2.3714
QLSTM	1.2234	1.2723	1.3348
GRU	1.1783	1.1748	1.1740
QGRU	0.4971	0.4846	0.4745

. These tables detail the Mean Absolute Error (MAE) and Root Mean Square Error (RMSE) for training and testing datasets across three dimensions.

According to the error metrics, quantum-based RNNs exhibit a marked increase in accuracy, particularly the QGRU model in comparison to the classical GRU. Moreover, the LSTM model demonstrates notably poorer performance compared to the other models, potentially caused by its slower rate of convergence across epochs (again, only 20 epochs were used in this case).

To further present the models’ predictions, we visualize their predictive outcomes across three dimensions, the trajectories and the losses over the epochs, in Figure 16, Figure 17, Figure 18, Figure 19, Figure 20, Figure 21, Figure 22, Figure 23 and Figure 24.

Firstly, regarding to the three-dimensional predictions, it is evident that all models correctly capture the dataset’s trend. Nonetheless, a closer look at the figure scales reveals difficulties in predicting the spike at the figure’s center for all the models (for LSTM in y and z dimensions, QLSTM in z, GRU in y and z, and QGRU in z). We believe this challenge could be solved by increasing the number of epochs, though the performance is deemed satisfactory for the current study.

Furthermore, the QGRU outperforms other models in trajectory plotting, showing a consistent decline in both training and test losses across epochs. In contrast, the classical RNNs display slight fluctuations in their loss plots. Although a spike is observed in the QLSTM’s loss plot, quantum-based RNNs, in general, tend to show a smoother and more rapid reduction in losses than the classical models.

5. Discussion

This study explores the efficacy of quantum-enhanced models, specifically the quantum Long Short-Term Memory (QLSTM) and the Quantum Gated Recurrent Unit (QGRU), in predicting the dynamics of systems governed by ordinary differential equations. These systems include Van der Pol oscillators, two damped coupled oscillators, and the Lorenz system. We benchmarked the performance of these quantum models against traditional Long Short-Term Memory (LSTM) and Gated Recurrent Unit (GRU) models by evaluating their accuracy through MAE and RMSE, alongside observing their training and testing loss trajectories over epochs.

The results from the three numerical experiments showcase that quantum-based models, particularly the QGRU, significantly outperform their classical counterparts in terms of predictive accuracy. This discovery highlights the capability of quantum computing techniques to improve the predictive performance of recurrent neural networks, particularly in the complex dynamics of systems represented by ordinary differential equations. However, it is important to recognize that these quantum-based models require greater computational resources, primarily because the operations of the Variational Quantum Circuit (VQC) are simulated on classical computing hardware. The same challenge is observed across numerous studies in the QRNN field, as highlighted in [50,51]. To address these computational challenges and enhance efficiency, we implemented batch sizes of 64 in this study, which significantly accelerated the processing time. Additionally, a critical aim of our ongoing research is to test the performance of these models on actual quantum hardware. This will not only confirm their theoretical benefits but also evaluate their practical utility and efficiency within a real quantum computing context.

The example code for $classQLSTM$ and $classQGRU$ can be found in the following Github link: https://github.com/YuanChenmt/QRNN-Examples (accessed on 16 April 2024).

6. Conclusions

We have validated the superior performance of quantum-based recurrent neural networks (QRNNs), particularly the Quantum Gated Recurrent Unit (QGRU), over traditional RNN models in predicting the outcomes of systems described by ordinary differential equations in terms of model accuracy, efficiency, and stability. This study aims to contribute to the understanding of QRNNs’ predictive capabilities, suggesting potential pathways for their application in complex, real-world scenarios. It modestly seeks to add to the ongoing discourse in computational science, hoping to inspire further research and exploration in the field.