Quantum Machine Learning for Signals

Every other lesson in this course gave quantum computing at least one honest win. Amplitude estimation buys a real quadratic speedup; QUBO solvers genuinely fit the discrete, cardinality-constrained problems that make classical convex solvers sweat. This lesson is different. This is the one where the brochure is glossiest and the bank account is emptiest.

Quantum Machine Learning (QML) for trading signals is the most over-promised idea in the entire over-promised field. The pitch is intoxicating: map your data into an exponentially large quantum feature space, compute a similarity measure no classical machine can match, and let a quantum classifier find the alpha that eluded everyone’s gradient-boosted trees. The reality, audited end to end, is a pile of elegant theory sitting on top of the same brutal wall you met in Machine Learning for Alpha and Deep Learning for Market Data: markets are starved for signal and effectively starved for samples, and no amount of feature-space wizardry manufactures information that isn’t there.

So put your skeptic’s hat on before we even start — and do not take it off.

The pitch, and the skeptic’s prior

The pitch. QML proposes encoding each data point as a quantum state living in a Hilbert space whose dimension grows like $2^n$ for $n$ qubits. Thirty qubits buys a feature space of over a billion dimensions; fifty qubits buys more dimensions than there are stars you could ever sample. The hope is that somewhere in that astronomically large space, your data becomes linearly separable in a way a classical machine could never efficiently discover — and that this exotic separability translates into a tradable edge.

The skeptic’s prior — set it now and keep it. You already carry the hard-won creed of the ML-for-alpha lineage:

• An honest information coefficient (IC) lives around 0.02–0.05.
• A good day out-of-sample is an $R^2$ of 0.01–0.05.
• The binding constraint is signal-to-noise and effective sample size, never raw model expressiveness.
• More capacity in a low-signal-to-noise world mostly buys a more exquisite fit to noise.

A quantum feature space is the most expressive feature space imaginable. By the creed, that is a warning sign, not a selling point. The mission of this lesson is not to learn QML so you can deploy it — it is to learn it well enough to audit the claim and almost always reject it.

Analogy. Suppose your radio station is broadcasting a faint melody buried in a thunderstorm of static — the classic low-signal-to-noise picture from the deep-learning lesson. QML walks in and hands you a receiver with a billion tuning knobs instead of one. More knobs do not add melody to the broadcast; they add a billion new ways to lock onto a particularly melodic-sounding gust of static and swear it is the song.

When to use it

Carry this prior into every QML claim you read for the rest of your career. Before evaluating any quantum-advantage-in-trading result, ask the gating question first: is the bottleneck here actually expressiveness? If the dataset is small, noisy, and non-stationary — i.e. if it is a real financial dataset — the answer is almost always no, and the fancier feature space is a liability. Reserve genuine interest for the rare case where someone demonstrates the constraint really was model class, on honest out-of-sample data.

Quantum feature maps and quantum kernels

Analogy. A kernel is nothing mystical — it is a similarity score. Two news articles are similar if they share many words; two faces are similar if their landmarks line up. A support vector machine (SVM) only ever needs these pairwise similarities, never the raw points themselves. The “quantum” part just computes an unusually exotic similarity, the way a strange new ruler might measure distance in a curved space. The SVM does not care how the ruler works; it only consumes the numbers.

Definition. A quantum feature map is a circuit $U_\phi$ that encodes a classical data point $x$ as a quantum state $|\phi(x)\rangle = U_\phi(x)\,|0\rangle$. The quantum kernel between two points is the squared overlap of their encoded states:

$K(x, x') = \left| \langle \phi(x) \mid \phi(x') \rangle \right|^2.$

You estimate each entry on hardware (run the circuit, measure repeatedly), assemble the full kernel matrix $K$ over your training set, and hand that matrix to an ordinary classical SVM. The quantum computer’s only job is to fill in the similarity matrix; the learning algorithm is 100% classical. This is the most defensible corner of QML precisely because it leans on a battle-tested classical method.

Worked example. Take a one-qubit feature map that encodes a scalar $x$ as a rotation by angle $x$, so the encoded state sits at angle $x$ on a circle. The overlap of two such states is $\langle \phi(x) \mid \phi(x') \rangle = \cos\!\big(\tfrac{x - x'}{2}\big)$, so the kernel is

$K(x, x') = \cos^2\!\left( \frac{x - x'}{2} \right).$

Plug in three points $x_1 = 0$, $x_2 = \pi/2$, $x_3 = \pi$:

So a point is perfectly similar to itself ($K = 1$), half-similar to the quarter-turn point ($K = 0.5$), and totally dissimilar to the half-turn point ($K = 0$). That is a perfectly sensible similarity matrix — and notice it is also trivially classically computable: a cosine. Which is exactly the first trap.

Pitfall 1 — classical simulability. For a great many feature maps, the resulting kernel can be computed efficiently on a classical machine (the example above is literally a cosine). If a classical algorithm reproduces your kernel, there is no quantum advantage — you have built a slow, noisy way to compute something a laptop does instantly. Advantage requires a kernel believed to be classically hard, and those are a much narrower, much more fragile set.

Pitfall 2 — kernel concentration. Push the feature map into a genuinely high-dimensional, hard-to-simulate regime and a different disaster strikes. In large Hilbert spaces, the overlap between two distinct random states concentrates near zero, so off-diagonal kernel entries collapse toward a tiny constant: $K(x, x') \approx c$ for all $x \neq x'$, and $K(x, x) = 1$. The kernel matrix becomes nearly the identity — every point looks equally dissimilar to every other point. An SVM handed an (almost) identity kernel memorizes the training set and generalizes to nothing. The very expressiveness that was supposed to help destroys the similarity structure the SVM needs.

When to use it

Consider a quantum kernel only when you can argue three things at once: the kernel is plausibly classically hard (or you would just use the classical version), it is not in the concentration regime (check the off-diagonal spread — if every pair scores nearly the same, abandon ship), and its inductive bias genuinely matches your problem’s structure. For low-signal-to-noise return prediction, this trifecta has never been convincingly demonstrated. The honest default remains a well-tuned classical kernel (RBF) SVM with cross-validated bandwidth.

Variational quantum classifiers (VQC)

Analogy. Picture a neural network where the “neurons” are quantum gates and the “weights” are rotation angles. You feed in the data (encoded by a feature map), the circuit shuffles amplitudes around, you measure a qubit, and you read its outcome probability as a class score. Then — exactly like training a net — a classical optimizer nudges the angles to reduce the loss, and you go again. It is a neural net wearing a lab coat.

Definition. A variational quantum classifier uses a parameterized circuit, the ansatz $U(\theta)$, applied after the feature-map encoding. You measure an observable to obtain a class probability, compute a loss against the labels, and use a classical optimizer to update the parameters $\theta$. Schematically,

$\hat{y}(x) = f\!\big( \langle \phi(x) \mid U^\dagger(\theta)\, M\, U(\theta) \mid \phi(x) \rangle \big),$

where $M$ is the measured observable and $f$ maps the expectation to a class score. The hybrid loop — quantum forward pass, classical parameter update — is the defining structure. The quantum device is a fancy, noisy function evaluator; the optimization is classical.

Worked example — the scale of the search. Even a modest VQC ansatz on 4 qubits with 3 layers and 3 rotation angles per qubit per layer carries $4 \times 3 \times 3 = 36$ trainable angles. Now recall the effective-sample-size catastrophe from the deep-learning lesson: a single financial series might offer only tens of effectively independent observations after you discount autocorrelation and overlapping labels. Thirty-six parameters chasing a few dozen real observations is the exact parameter-to-information mismatch that defines overfitting. Scale to 10 qubits and 5 layers and you are at $10 \times 5 \times 3 = 150$ angles — a noise-memorizing machine pointed at data that has almost no signal to memorize honestly.

Pitfall — barren plateaus. Here is the failure unique to VQCs, and it is brutal. For broad classes of expressive ansätze, the gradient of the loss with respect to the parameters vanishes exponentially in the number of qubits: roughly,

$\mathrm{Var}\!\left[ \frac{\partial L}{\partial \theta} \right] \sim \frac{1}{2^{\,n}}.$

When the gradient variance is $\sim 2^{-n}$, the loss landscape is an exponentially flat desert — the barren plateau. The classical optimizer wanders a featureless plain with no slope to follow, and the number of measurement shots needed just to estimate a gradient that small grows exponentially. So the more qubits you add to gain expressiveness, the harder it becomes to train at all. You inherit every overfitting risk of an expressive model and a training problem that gets exponentially worse precisely as you scale up the thing that was supposed to be the advantage.

When to use it

For trading-signal prediction, the honest recommendation is: essentially never, today. A VQC combines the worst of both worlds — the overfitting hazard of a high-capacity model on data that has almost no learnable structure, plus a barren-plateau training problem that worsens exponentially with scale. If you must experiment, keep the circuit tiny, regularize ferociously, and benchmark against a logistic regression — which will usually win while being a thousand times cheaper and fully interpretable.

The data-loading wall, for QML specifically

Analogy. Imagine the world’s fastest calculator, but to enter each number you must hand-carve it into a stone tablet, one digit at a time, and the tablet crumbles a little each carve. If carving the inputs takes longer than the arithmetic saved, the fast calculator is a net loss. QML’s data-loading wall is exactly this: the carving (state preparation) can cost more than the computation buys.

Definition. Before a quantum kernel or VQC can touch a data point, that point must be loaded into a quantum state — state preparation. For a data point with $m$ features, a generic exact encoding requires circuit depth that scales at least linearly,

$\text{loading depth} = O(m),$

and for amplitude encoding of an arbitrary vector it can be far worse (up to exponential in qubit count without special structure or a quantum-RAM device that does not yet exist at scale). Crucially, you pay this per sample, for every training and test point. A kernel SVM needs roughly $O(N^2)$ kernel entries over $N$ samples, and each entry requires preparing states for two points. The loading bill is not a one-time setup; it is woven through the entire pipeline.

Worked example. Suppose you have $N = 1{,}000$ samples, each with $m = 50$ features, and state preparation costs $\sim m = 50$ gate layers per point. Building the kernel matrix needs about $\tfrac{N(N-1)}{2} \approx 500{,}000$ overlap circuits, each loading two points: roughly $2 \times 50 = 100$ loading layers apiece, before any of the kernel computation. That is on the order of $500{,}000 \times 100 = 5 \times 10^{7}$ loading-layer executions — every one of them accumulating gate noise on a machine that decoheres after a few hundred operations (the NISQ wall of the next lesson). Now ask: what did the quantum part save? If the answer is a polynomial factor on the learning step but the loading is itself polynomial and noisy, the end-to-end ledger frequently comes out negative. This is precisely why QML demonstrations almost always use tiny, low-dimensional datasets — a handful of features and a few hundred points — where the loading bill stays small. Scale to a realistic feature set and the wall reappears.

When to use it

Whenever you audit a QML-for-finance result, the first forensic question is: did they count the data-loading cost? If the paper benchmarks only the kernel evaluation or only the circuit’s forward pass and quietly assumes the states are free to prepare, the reported advantage is an accounting fiction. A claim is credible only when the loading depth, the per-sample repetition, and the noise it injects are all on the ledger — and the method still wins.

The evidence audit

The honest status. There is, as of today, no robust, independently reproduced evidence that QML beats a well-tuned classical baseline — gradient boosting or a kernel SVM — on real financial signals. The much-cited “advantage” results are overwhelmingly on synthetic datasets, often constructed so the quantum kernel is by design the matched inductive bias (the data is literally generated by a quantum process, or by a function the quantum kernel happens to separate cleanly). Demonstrating that a quantum kernel separates data engineered to be separated by that quantum kernel is a tautology dressed as a discovery. It tells you nothing about whether markets — noisy, non-stationary, signal-starved — happen to live in that same convenient structure. They do not appear to.

Carry the deflated-Sharpe creed. Recall from Machine Learning for Alpha: a theoretical separation is not a PnL edge. A method that can separate classes in principle, or that posts a flattering accuracy on a curated set, has cleared none of the bars that matter. Before believing any QML trading claim, demand the same end-to-end discipline you would demand of any backtest:

1. Leakage-safe validation — purged, embargoed cross-validation; no peeking across overlapping labels.
2. Cost-aware, out-of-sample PnL — net of transaction costs and slippage, on data the model never saw.
3. The best classical baseline, well-tuned — not a deliberately crippled logistic regression, but a properly cross-validated gradient-boosted tree or RBF-kernel SVM.
4. A deflated Sharpe — adjusted for the number of configurations, qubit counts, ansätze, and feature maps tried.

A QML result that skips any of these is marketing.

The comparison table — the core deliverable of this lesson:

A second, blunter way to read the same audit:

When to use it

Treat QML for trading signals as a research curiosity to monitor, not a tool to deploy. The defensible posture: keep the best-tuned classical model (gradient boosting, RBF-kernel SVM, regularized linear) as your production workhorse, and update your prior only when — and exactly when — someone publishes a reproduced, leakage-safe, cost-aware, loading-included out-of-sample win over that classical baseline on genuinely real financial data. Until that day, the elegant theory stays elegant theory, and the brutal data-loading wall stays brutal.

Recap

You came in braced for the most skeptical lesson in the course, and the skepticism was earned the whole way down. QML’s pitch — encode data into an exponentially large quantum feature space and find an edge classical machines cannot — collides head-on with the iron law of the ML lineage: in finance the bottleneck is signal-to-noise and effective sample size, not expressiveness. Quantum kernels are trapped in a pincer between classical simulability and kernel concentration. VQCs add barren plateaus, a training problem that worsens exponentially exactly as you scale the supposed advantage. The data-loading wall taxes every single sample and routinely erases the speedup before any learning happens. And the evidence audit comes back null: no robust, reproduced, leakage-safe, cost-aware, loading-included win over a well-tuned classical baseline on real financial data. Elegant theory; empty ledger.