Stock Market Price Prediction Lstm Capstone

Contextual Quantum Neural Networks for Stock Price Prediction

(Dated: February 17, 2026)

In this paper, we apply quantum machine learning (QML) to predict the distribution of stock prices of multiple assets using a contextual quantum neural network. Our approach captures re- cent trends to predict future stock price distributions, moving beyond traditional models that fo- cus on entire historical data.

Utilizing the principles of quantum superposition, we introduce a new training technique called the quantum batch gradient update (QBGU), which accelerates the standard stochastic gradient descent (SGD) in quantum applications and improves convergence.

Consequently, we propose a quantum multi-task learning (QMTL) architecture, specifically, the share-and-specify ansatz, that integrates task-specific operators controlled by quantum labels, en- abling the simultaneous and efficient training of multiple assets on the same quantum circuit as well as enabling efficient portfolio representation with logarithmic overhead in the number of qubits.

Through extensive experimentation on S&P 500 data for Apple, Google, Microsoft, and Amazon stocks, we demonstrate that our approach outperforms quantum single-task learning (QSTL) models by effectively capturing inter-asset correlations. Our findings highlight the transformative potential of QML in financial applications, paving the way for more advanced, resource-efficient quantum algorithms in stock price prediction and other complex financial modeling tasks.

Keywords: Quantum Machine Learning, Quantum Neural Networks, Quantum Finance, Quantum Multi-

Introduction

Quantum computing is a computational paradigm that transcends the limitations of classical computing by har- nessing the principles of quantum superposition and en- tanglement. These unique features enable quantum com- puters to tackle complex problems faster than classical systems can[1, 2, 4, 5]. Owing to the potential exponen- tial scaling of computational power with the number of qubits, quantum computing is expected to revolutionize diverse sectors, including medicine, engineering, energy, and finance [6, 7]. Despite its immense potential, build- ing a fully functional quantum computer is a monumental challenge that could take years, if not decades, to achieve a clear computational advantage over classical comput- ers [8, 9]. However, the near-term applications of quan- tum computing are particularly promising in fields like finance, where its ability to process vast amounts of com- plex data with fewer resources is transformative. Even with today’s noisy intermediate scale quantum (NISQ) devices - limited by a small number of qubits and short coherence times - quantum methods can provide ap- proximate solutions to certain financial problems, making them highly relevant in the immediate future .

Machine learning has become essential for financial tasks like, asset management , risk analysis , crash detection , and portfolio optimization . The abil- ity of machine learning algorithms to analyze massive datasets, recognize patterns, and make fast predictions provides a significant competitive edge.

Quantum Ma-

chine learning (QML) emerges at the intersection of these fields, combining quantum computing’s ability to process and represent complex states efficiently with the powerful predictive tools of machine learning . With the exponential growth of financial data, current machine learning systems are quickly reaching the boundaries of classical computational models.

In This Context, Quan-

tum algorithms present a promising alternative by offer- ing faster or higher quality solutions for specific classes of problems. Additionally, breakthroughs in quantum learn- ing theory suggest that, under certain conditions, there is a provable distinction between classical and quantum learnability . This implies that problems deemed chal- lenging for classical systems could see significant improve- ments through the adoption of QML approaches.

Quantum machine learning can be broadly categorized into two main components: parametric quantum circuit (PQC) optimization and classical-to-quantum informa- tion encoding . These categories represent two core components of QML algorithms and workflows, each ad-

2

dressing a different aspect of how classical data inter- acts with quantum systems and how quantum models are trained. PQCs are quantum circuits that contain tunable parameters, interpretable as weights of a quantum neu- ral network.

These Parameters Are Adjusted Iteratively

to minimize or maximize a cost function, similar to how classical machine learning algorithms optimize parame- ters during training. PQCs can further be classified into two categories: variational quantum circuits (VQC) and quantum neural networks (QNN). VQCs involve a hybrid architecture where a classical computer works alongside a quantum computer in a loop, while QNNs consist of circuit architectures tailored to specific problems.

Recently, there have been a surge of research interest in these areas. For instance, hybrid architectures using parameterized quantum circuits in combination with clas- sical optimization loops have been successfully deployed for classification tasks , while support vector machines (SVM) have been utilized for data classification . In another study, quantum state space was used as the fea- ture space to improve the learnability of QML and achieve quantum advantage in classification tasks . Quantum versions of machine learning models, such as Boltzmann

Machines , Recurrent Neural Networks , Genera-

tive adversarial neural networks , reinforcement learn-

Ing , And Reservoir Computing , Have Been Exten-

sively studied. In finance, quantum machine learning has been applied to various tasks, including options pricing , time-series forecasting , and stock price prediction . A notable example is a hybrid architecture developed for financial predictions , while quantum Wasserstein generative adversarial neural networks were employed for time-series predictions on the S&P 500 .

Unsupervised Quan-

tum machine learning has also been explored for cluster- ing and fraud detection .

On The Other Hand, Sig-

nificant progress has also been made in loading classical information onto quantum states.

For Example, Quan-

tum adversarial neural networks have been utilized to load random distributions onto quantum circuits using

Feature Maps , And Quantum Wasserstein Gans Have

achieved similar tasks with a gradient penalty, improving performance over previous approaches .

While Many Financial Computational Problems Like

portfolio management and risk analysis require training across multiple assets, only few studies have addressed this need.

For Instance, Joint Learning Of Two Distribu-

tions was achieved in , though its direct application to financial problems like stock price prediction remains limited due to computational expense and the reliance on feature maps, which will be further explained in this paper.

A Related Study Applied Quantum Reservoir

computing and multi-task learning , which is hindered by the complexity of quantum reservoir systems, lacking generalization.

In this paper, we aim to address the challenge of train- ing a parameterized quantum circuit over multiple assets on a single quantum device by utilizing minimal resources and optimizing various components of the training pro- cess. The contributions of this work are as follows: 1. We adopted fidelity loss over quantum represen-

Coded Context Distribution And Empirical Context-

continuation distribution to accelerate convergence and improve convergence quality compared to train-

Ing By Stochastic Gradient Descent (Sgd) Through

expensive reconstruction of classical distributions.

Tion Supported) Backpropagation, Across Different

loss functions.

(Qmtl) Architecture - Share-And-Specify Ansatz -

for predicting the stock price distribution over a portfolio of assets. By achieving logarithmic over-

Head In The Number Of Assets In The Portfolio And

controllable scaling in the size of the context, we can load highly nontrivial non-static distributions

Gorithms For Speed-Up Like Quantum Linear System

solving at inference time.

Section Ii Gives

a brief background of the required terminology used throughout this paper. Section III gives an overview of loading classical data onto quantum registers.

Section

IV and V introduces quantum single-task and multi-task learning respectively followed by numerical simulations in Section VI.

Background

In this section, we introduce all the background infor- mation needed to understand this paper including the time-series prediction model and contextual Quantum Neural Networks (QNN) for modeling asset futures.

3

Figure 1. Quantum Neural Networks for Contextual Sequence Generation. Given historical data of context and continuations, a Quantum Neural Network is trained to produce quantum distributions over future prices, enabling utilization of quantum advantageous algorithms, such as quantum risk analysis , downstream for tasks (labeled M in the rightmost diagram at a particular future) over all sequences in superposition.

Time-Series Prediction

A financial asset price prediction model is a time-series forecasting model designed to predict future asset prices by leveraging historical numeric price data and additional contextual information . In this section, we outline the mathematical framework and notations that will be used subsequently to develop a quantum machine learn- ing (QML) model for multi-asset price prediction.

For

any given financial asset, the associated contextual string represents a sequence of numeric values corresponding to the asset over a specific time frame. Typically, this se- quence is formed by considering a series of consecutive past asset prices within the designated time window. In this work, we utilize asset price data derived from the S&P 500 index, which provides historical stock prices for corporations listed on the index. Stock prices are inher- ently volatile, influenced by market activity, news, and other external factors. These short-term fluctuations of- ten introduce noise that can adversely affect model per- formance.

Therefore, In This Paper, We Preprocess The

stock prices by computing the finite difference between consecutive stock prices to capture the moving difference (returns). This is followed by performing a moving aver- age, smoothing out these short-term fluctuations, reveal- ing the underlying trends.

The value or movement of an asset at a time, denoted by t, is represented by a random variable Xt and we de- note Xt = xt when it attains a value xt. Thus, a con- text string of T ≥1 numeric values is represented by a random vector X(T ) = (X1, X2, . . . , XT ).

Then The

task of a prediction model f is to predict the value(s) of X(T +τ)\X(T ) := (XT +1, XT +2, . . . , XT +τ) as a proba- bility distribution f(X(T +τ)\(T ); X(T )) for some values of the future time τ ≥0. To be specific, given X(T ) = x(T ), the task of the prediction model is to assign probabilities to future states x(T +τ)\x(T ) := (xT +1, xT +2, . . . , xT +τ), the possible asset-price at the future times between T + 1 and T + τ, as f(x(T +τ)\T ; x(T )) and the effi- ciency of f is determined by the closeness of a dis- tance between f(x(T +τ)\T ; x(T )) and the observed dis- tribution over x(T +τ)\x(T ) to zero. Thus the design of a prediction model f(X(T +τ)\(T ); X(T ), θ) with param- eters θ is concerned with modeling f such that the loss function L(f(x(T +τ)\(T ); x(T )), x(T +τ)\x(T )), which esti- mates a notion of closeness between the probability dis- tribution f(X(T +τ)\(T ); X(T )) and observed frequencies X(T +τ)\X(T ) is minimized for all or a collection of as- sets in a financial market. In most occasions dealing with time-series data models, the loss function is considered as the mean squared error (MSE), binary cross entropy or any other custom function specifically designed for the task.

In our proposal of developing a QML model for multi- asset price prediction, it is customary to encode the con- text string data x(T ) into a quantum state which will be evolved under a unitary transformation. We define the

(1)

to encode x(T ) after encoding the context data point xt into its corresponding qudit |xt⟩for 1 ≤t ≤T. Here, ⊗ denotes the Kronecker product (also called tensor prod- uct) of two vectors. In this framework, the state of the qudit, |xt⟩, represents the quantized return of an asset at

4

time t. The mapping of returns to the orthogonal states |0⟩, |1⟩, . . . , |d −1⟩is determined by dividing the range of possible returns into d discrete intervals. Each inter- val corresponds to one of the orthogonal basis states of the qudit. For instance, let the minimum and maximum returns between 1 ≤t ≤T be xmin and xmax, then the price range is divided into d equal intervals of length

D −1

. For any price xt, its corresponding qudit state |xt⟩is de-

,

it ∈{0, 1, . . . , d −1}.

(2)

This mapping ensures that each basis state |it⟩rep- resents a specific quantized interval of prices.

Over

time, as the asset price evolves, the state of the qu-

∈

Cd transitions between the basis states.

Θ

designed to capture the stochastic behavior of returns and generate an approximation to the quantum state

Such That Direct Measurement Samples From The Un-

derlying distribution.

Is A T + Τ-Qudit

basis state with ϕt ∈{0, . . . , d −1} and c(ϕ) ∈C such

That P

ϕ |c(ϕ)|2 = 1.

Now, The Prediction Is A Density

operator after taking the partial trace over the context:

Y(T +Τ)Ed

y(T +τ) .

(4)

Note that the prediction of future returns constitutes only the last τ qudits. However, in our situation, the QNN

),

making it not suitable for reuse for repeated predictions. To circumvent that, we require the whole input and out-

) To Be Involved In The

loss function to make sure that the context qudits are un- changed. With this, we can approximate the prediction

X(T )E Φt +1

. . .

Φt +1

. . .

, Which

is a superposition of all possible outcomes with different

Φt +T

→xmin + ϕT +t · ∆x.

(6)

These mapped values can then be used to calculate the expected value or movement of the stock prices by com- bining with the probability (|c(ϕ)|2) of each possible out- come. Measuring the last τ qudits over the computation basis states yields a sample from the underlying probabil-

Ity Distribution Over Futures By The Model:

f(ϕT +1, . . . , ϕT +τ; x(T ), θ) = |c(ϕ)|2.

(7)

Given M measurement samples, we define the resulting distribution fM(X(T +τ)\(T ); x(T )) based on the frequency of observing specific continuation strings x(T +τ)\(T ); in the high sample limit fM ≈f. We can also estimate the most probable future outcomes, which would be useful in repeated predictions. If we wish to predict a future state, τR + T, we can use R repeated application of the underlying QNN to generate a superposition over those outcomes. Fig. 1 shows how a contextual QNN can be utilized for such time-series based predictions.

,

In this paper, we are particularly interested in τ = 1 sce- nario along with binary quantization (d = 2), for which the qudits are reduced to qubits such that |0⟩and |1⟩ correspond to the negative and positive stock price move- ment respectively. Hereafter, we stick to the binary quan- tization d = 2 throughout the paper unless otherwise stated. This choice provides a simple and interpretable

Mapping Between Price Movements And Quantum Mea-

surement outcomes, where each qubit directly represents an upward or downward movement in returns. Using bi- nary encoding allows us to focus on the model’s ability to learn and reproduce the underlying conditional proba- bility distributions, without additional complexity intro- duced by higher-dimensional encoding schemes.

More-

over, binary quantization keeps the circuit depth and the

5

number of qubits manageable, which is particularly im- portant when studying scalability across multiple assets. By reducing representational overhead, we can isolate and analyze the learning dynamics of QMTL itself, establish- ing a clear baseline before extending the framework to multi-level quantization in later experiments.

In Addi-

tion, during training, we also consider the statistics of the contextual data including the contextual probabil- ity distribution P(X(T )), the target probability distri- bution P(X(T +1)), the conditional probability distribu- tion P(XT +1|X(T )), and the total probability distribu- tion P(XT +1, X(T )). In particular, we train θ such that f(XT +1; X(T ), θ) ≈P(XT +1|X(T )).

Now We Recall That A Qnn Architecture On An N-

qubit register represents a parametrized unitary matrix ˆU(θ) of dimension 2n, which is defined by a sequence of parametrized quantum gates that produces an n-qubit output state ˆU(θ) |Ψ⟩for any input state |Ψ⟩∈C2n, where θ is the set of (real) parameters in the QNN and |Ψ⟩encodes a classical input data for the problem. The parameters in θ can be learned and trained to produce a desired output state which is approximated by perform- ing several quantum measurements to all or a subset of the qubits. Deciding the parametrized quantum circuit (PQC), also known as ansatz which represents ˆU(θ) in a QNN model is one of the fundamental problems in QML applications. In this section, we will introduce the impor- tant components of a QNN.

1.

Loading Classical Data

The first step in a QNN involves encoding classical data into quantum states. This is typically done using

Quantum Feature Maps , Where Classical Input Data

Ψ ∈Cγ, 1 ≤γ ≤2n is encoded into a quantum state |Ψ⟩, where 2n is its dimension. This state can be prepared by

(8)

where ˆUF (Ψ) is a quantum feature map circuit that de- pends on the classical data Ψ, and |0⟩⊗n represents the initial quantum state. A feature map consists of a set of controlled rotation gates, parameterized by the contents in the classical register Ψ.

Different Feature Maps Can

be employed depending on the application to project the classical data on the quantum state space. Some of the common feature maps used are the first and second-order Pauli-Z evolution circuits .

2.

Parametric Quantum Circuits

Once the classical data is encoded into a quantum state, it is processed by a PQC. The goal of the training process is to optimize the parameters θ such that the PQC out- puts a quantum state that corresponds to accurate pre- dictions for the learning task. In this paper, inspired from the traditional layered neural networks, we focus on PQCs with L repeated layers, composed on fixed and parameter- ized gates such that the unitary represented by the circuit

J Glij(Θlij) As Shown In

Fig. 2, where V l is a fixed unitary at layer l (which could be identity or a sequence of CNOT gates) and Glij(θlij) denote a single-qubit rotation gate acting at layer l, at po- sition (i, j). Here, i ∈[1, n] and j ∈[1, c], with i and j cor- responding to the row and column indices of the quantum circuit, respectively as shown in Fig. 2. In this notation,

Θ = Ll

l=1 θl, where θl = {θl11, θl12, . . . , θlnc} such that m(= Lnc) is the total number of parameters in the circuit, n(= m/Lc) is the number of of qubits and c(= m/Ln) is the number of sub-layers in each layer.

This Represen-

tation will be explored in detail in later sections. Each parameter θlij ∈θ can correspond to the angles of single qubit rotation gates such as RX(θlij), RY (θlij), RZ(θlij).

In the proposed QML model in this paper, along with the

, We Need Ancilla Qubits To

extract information from the output state of a QNN for the learning task. The ancilla qubit states control the ap- plication of certain quantum gates on the main quantum register to obtain a desired output state. Assuming that there are τ ancilla qubits, the QNN represents a unitary matrix ˆU(θ) with dimension 2T +τ ×2T +τ, resulting in the number of qubits n = T + τ. Setting the initial state of the ancilla register as |0⟩⊗τ , the output state is given by

L ˆU L(Θl) Is The Unitary Operator Corre-

sponding to the parametric quantum circuit. In addition to rotation gates, our circuit may include fixed gates, such as CNOT gates, that help spread entanglement in the sys- tem.

3.

Training

Classical neural networks are primarily trained by back- propagation, which is not directly possible in QNNs.

6

Figure 2. Parameterized Quantum Circuit. Block dia- gram of the layered parametric quantum circuit showing vari- ous blocks in the lth layer such as fixed unitary and parametric rotation gates.

Quantum states collapse upon measurement, meaning the quantum information is destroyed. Backpropagation re- lies on preserving intermediate computations (like activa- tions) during the forward pass for use in the backward pass. In quantum systems, measurements required to ex- tract information disrupt the state, preventing reuse. In addition, the no-cloning theorem prohibits copying quan- tum states for reuse, further complicating backpropaga- tion. Consequently, QNNs have adopted to other tech- niques for gradient computation such as parameter shift and simultaneous perturbation stochastic approxima- tion (SPSA) . Unlike backpropagation, which requires explicit differentiation through each layer, these methods compute gradients by evaluating the quantum circuit at slightly shifted parameter values. It works based on the fact that the output of quantum circuits often depends on the parameters through trigonometric functions (such as sine and cosine), enabling exact gradient computation.

=

x(T +τ) ˆU †(θ) ˆB ˆU(θ)|x(T +τ)⟩.

(11)

where δ is hyperparameter, typically between 0 and 1 and α is a stochastic perturbation vector with dimen- sions same as θ. The vector α is sampled from a zero Figure 3. SWAP Test. A diagram of the SWAP test, which measures the fidelity loss between two wavefunction states

Y(T +Τ)E

. mean distribution such that αlij ∈{−1, 1}. The primary difference between the two approaches is in parameter up- dates: parameter-shift updates one parameter at a time, requiring 2m evaluations for m parameters, while SPSA updates all parameters simultaneously with just two eval- uations per iteration.

4.

Loss Functions

Different loss functions are employed depending on the nature of the QNN and the gradient update rule.

For

instance, mean squared error (MSE) is commonly used in regression tasks due to its smooth gradients and sim- plicity in optimization. However, for classification tasks, cross-entropy loss might be preferred as it better captures the probabilistic nature of the output. Therefore, we in- troduce different loss functions that are relevant to our paper.

Mean squared error loss is the most common loss func- tion used for optimization tasks and in our context, it is

Defined As:

Lm(θ, x(T +τ)) = |fM(x(T +τ)\(T ); x(T )) −δ(x(T +τ))|2.

(12)

Note that for the MSE loss, full state measurement is required i.e., all the qubits must be measured and the returns have to retrieved from the output state vector as per Eq. (6). To circumvent this, we use the fidelity loss or

2 (|0⟩+ |1⟩), Whose Logical State Is

then used to control SWAP the wavefunction (e.g. qubit by qubit). Thereafter, a Hadamard gate is applied on the ancilla, leading to a phase kick back, and then the ancilla is measured in the computational (Pauli-Z) basis.

7

Figure 4. Loading a distribution onto a hardware ef- ficient ansatz. The circuit inside the blue box ( ˆO(α, β)) is applied sequentially for a sufficient number of iterations fol- lowed by an MSE loss with the SPSA update rule.

of the ancilla qubit is proportional to the fidelity

Loading Classical Data

Contextual data x(T ) can be encoded onto a quantum state using feature maps , as described in Eq. (8). However, feature maps are computationally intensive and slow to train due to the convoluted nature of ˆUf. More- over, training requires encoding a different contextual in- put during each iteration, further increasing the complex- ity.

To Address This Challenge, We Propose Loading The

entire contextual distribution onto the quantum state us- ing a hardware-efficient ansatz . By encoding the data only once, our approach achieves significantly faster train- ing. In this section, we discuss the procedure for encoding the contextual probability distribution P(X(T )), where X(T ) represents the contextual time-series data of an as- set, onto a quantum state using the hardware efficient ansatz architecture.

Once the data has been preprocessed, we construct the

(2) To Obtain A Basis For The

T-qubit representation of the returns, where the quan- tization levels for the returns are also chosen. Now, we need to represent the stochastic behavior of the asset in the space defined by the basis vectors such that the in- formation can be used to train the QNN model and make reasonable predictions.

To This End, We Normalize The

preprocessed data and compute its histogram to obtain the contextual probability distribution of the quantized returns as P(X(T ) = (i1, . . . , iT )), where it denotes the quantized return at time t. Thereafter, we load the con- textual distribution onto the T-qubit state as follows

(15)

where P(i1, . . . , iT ) is the value of the quantized distribu-

It

. Note that, using the definition of x(T ) and equations (1)

Eq. (16) Can Be Achieved Using The Grover-Rudolph

technique for state preparation . However, due to its higher computational complexity, we adopt a simpler ma- chine learning-based approach for state preparation. This method utilizes a hardware-efficient ansatz combined with a mean squared error (MSE) loss function (Eq. (12)), where the parameters of the rotation gates are iteratively updated in a loop using the SPSA rule to minimize the loss function, as illustrated in Fig.4. This circuit is chosen due to its hardware-efficient architecture , which con- stitutes a repeated layers of RY , RZ, and CNOT gates to perform rotations and entanglement. Although several loss functions exist for comparing distributions, we choose MSE due to its smooth gradients and computational ef- ficiency, enabling faster optimization. For each layer, the

(17)

where CNOTj,(j+1)%T acts on qubits j (control) and (j + 1)%T (target) and RY (αi), RZ(βi) are 2 × 2 unitary matrices acting on the jth qubit. To enhance the accuracy of loading the distribution, multiple such transformations are applied iteratively, as illustrated in the figure. This approach improves the learnability of the circuit, thereby increasing the fidelity of the loaded distribution.

Note

that the parameters in the circuit {{αi} ∪{βi}} are opti- mized through the training process to accurately load the contextual distribution.

8

Figure 5. Quantum Batch Learning. A diagram showing the learning procedure of our proposed quantum batch gradi- ent update for a context of T. The top most qubit is an ancilla qubit. For a batch, a distribution over inputs is loaded suc- ceeding qubits (the input qubits) and the following qubit(s) is for the output. The joint distribution of the inputs and out- puts for the batch is loaded on the subsequent qubits. The circuit inside the Grey box ( ˆU(θ)) is applied sequentially for a required number of iterations, is a contextual quantum neural network to prepare an approximate of the loaded joint distri- bution.

A SWAP test is then used to take the fidelity loss between the two distributions.

Quantum Single-Task Learning

Now that we have encoded the contextual distribution into the quantum states, we can move on to discussing predictions based on the given context. Before diving into quantum multi-task learning for predicting multiple asset prices, we’ll first present a complete case of using quantum circuits for predicting the price of a single stock, which we will refer to as quantum single-task learning (QSTL).

Unlike previous approaches [35, 37], which rely only on using the entire historical data to make predictions, we in- corporate contextual information as well to forecast future outcomes, as shown in Fig. 5. This method offers the ad- vantage of adapting to the constantly changing stock mar- ket, whereas past methods may become less relevant due to outdated data. In our approach, the contextual distri-

, Which,

along with a prediction qubits, forms the input of the

⊗|0⟩⊗Τ. Hereafter, We Will Stick

to τ = 1 and binary quantization unless otherwise stated.

To The Last

T + 1 qubits, which serves as an input to the SWAP test. The layered PQC forms the bulk of the circuit followed by the SWAP test between the predicted distribution and target distribution (as shown in Fig.5). Finally, measure- ment is done on the ancillary qubit, obtaining the fidelity loss, which guides the training process through SPSA gra- dient update rule.

A unitary transformation ˆU(θ), where θ is the trainable parameters, enables the circuit to learn the conditional probability distribution represented by P(XT +1|x(T ), θ).

This probability distribution serves as the desired output state of the PQC at the end of the training process, allow- ing for the prediction of future returns via measurement.

Learning conditional probability distributions is crucial for time-series prediction as they capture the dependency between past context and future outcomes. In contrast, marginal distributions are unsuitable for time-series pre- diction because they lack the ability to incorporate tem- poral dependencies and contextual information.

Quantum Data Processing Has Been Explored For Ma-

chine Learning due to the inherent memory compres- sion associated. For example Ref. utilizes access in superposition to models for quantum speedup in tasks like k-means clustering, while Ref. achieves quantum speedup for Support Vector Machines by learning over a superposition of data points.

In The Context Of Qnns,

Ref. recently considered a construction for parallel quantum batches in which a reduced density matrix is constructed over the ancilla, output, and label space. In comparison, our approach loads the entire contextual dis- tribution at once according to Eq. (16), resulting in a straight forward loss function that leads to higher quality gradients. Then our QNN generates an approximate rep- resentation of the continuation for each context in super- position. This leverages the linearity of quantum circuits, allowing a superposition of all possible inputs to train the circuit without breaking the correspondence between the respective inputs and outputs. This correspondence reduces the multi-step stochastic gradient descent to a single step.

For example, consider Eq. (9), when the input of the

as shown in Fig. 5. Let the gradient update for θ, obtained from SPSA, be denoted as g(θ, x(T +1)), with

, (18)

where the last step is obtained by using Eq. (11) with

(19)

where β is the learning rate. Similarly, if the input to the PQC is a distribution of basis states (superposition of all

Is The Total Distribution Learned By

the circuit ˆU(θ) over the contextual distribution

Ψ(T )E

. Given that the gradient update corresponding to the out-

X(T )∈{0,1}T

P(x(T )) g(θ, x(T +1)).

(20)

This expression (Eq. 20) effectively corresponds to ap- plying stochastic gradient descent (SGD) across all input context samples from the dataset, achieving a single gra- dient update after processing the entire dataset. Notably, this result is obtained in one step due to the inherent linearity of quantum mechanics, facilitating the quantum circuit to train on large batches. Using the QBGU train- ing process, the model ˆU(θ) in Fig. 5 is trained to learn Figure 6.

Share-and-specify Ansatz.

A Diagram Of Our

Quantum Multi-Task Learning Architecture showing various components for the QNN. A single asset state is loaded by setting the label |k⟩and the inference-time context x(T ) is loaded over qubits |0⟩⊗T +τ. The input can then be processed through the parameterized circuit, composed of L layers of

That Can

be utilized for a downstream task. For example, as depicted in the figure, measurement can be used to sample possible continuations xτ.

the conditional probability distribution P(xT +1|x(T ), θ),

Y(T +1)

at the time of inference.

As

shown in Fig. 5, we preload both the contextual distri-

, And

the SWAP test then measures the distance between the estimated and the original target distributions, guiding the training process.

Multi-Task Learning (Mtl) Is A Machine Learning

approach where multiple tasks are learned at the same time, allowing the model to share information between them. It uses shared parameters to capture common pat- terns across all tasks, while task-specific parameters fo- cus on unique aspects of each task. In financial time se- ries prediction, MTL can be used to predict the prices or trends of multiple assets together.

Shared Parame-

ters can represent factors that affect the entire market, such as economic indicators, while task-specific parame- ters account for unique characteristics of each asset, like individual volatility or trading patterns. This helps the model make better predictions by learning both shared and asset-specific information. In this section, we extend these ideas to QNNs by introducing the quantum multi- task learning (QMTL).

In Order To Incorporate Mtl In A Qnn Framework,

we introduce the share-and-specify ansatz (Fig. 6) which

10

Figure 7. Quantum Multi-Task Learning Architecture for T = 3 and K = 2. The circuits inside the Grey ( ˆUs(θs)) and

2 (Θ1

2)) are applied sequentially for a required number of iterations followed by the SWAP test. breaks each layer of the PQC into a block of universal gates (shared ansatz), followed by a block of asset spe- cific label-controlled gates acting based on the state of the label registers (specify ansatz). The share ansatz for each layer can be embodied by the same gates used in the single-asset task, leading to identity operations applied to

(21)

where 1K is the identity operator with dimension K ×K. The label qubits, collectively represented by the qudit |k⟩= |k1⟩⊗|k2⟩· · · ⊗|klog K⟩with kj ∈{0, 1}, are used to distinguish the assets. Each asset is assigned a unique label k ∈[1, K], ensuring that the quantum operations are applied selectively to the corresponding asset based on its label. These label qubits are then used to form the

(22)

resulting in the specify ansatz (with control) for asset k

1K −|K⟩⟨K|

is a projection onto the orthogonal space of |k⟩⟨k|,

K ) Is Only Applied When The La-

bel qudit is |k⟩.

Is A Control Rotation Based On

label |k⟩. We can then define the specify ansatz for one

(24)

where the dimension of ˆU(θ) is 2T +τK × 2T +τK. Note

, Undergoes

the transformation determined by the label qudit and the

⊗|0⟩⊗Τ

⊗|k⟩.

S Helps Facilitate Learn-

ing across assets while the specify ansatz layer ˆU l

K Al-

lows focus on potential peculiarities of an individual asset. This entire architecture is demonstrated in Fig. 6. 1.

Two-Assets Case

Extending the previous framework to handle two as- sets, the forward pass equations for a set of inputs