Quantum Machine Learning

Treat a parameterized quantum circuit as a trainable model: encode classical data into qubits, apply learnable rotations, then optimize the parameters against a loss. It carries machine learning's "model–loss–gradient" paradigm into a quantum circuit.

The core idea — the circuit is the model

In classical machine learning, a model is a function fw(x) with tunable weights, and we adjust the weights so it performs better on the data. Quantum machine learning (QML) replaces that function with a quantum circuit: the input x determines how the front of the circuit encodes, the weights w determine how the back of the circuit rotates, and the model's output is the expectation value of some observable. The whole "forward pass — compute loss — adjust parameters" loop stays exactly the same; only the function in the middle has become quantum.

Encoding classical data into a quantum state

A quantum circuit only understands quantum states, not arrays of floats, so the first step must be data encoding (also called a feature map): writing the classical vector x into the qubits. The most common angle encoding uses the components of x as the rotation angles of rotation gates, e.g. ry(x0, q0).

The encoding matters enormously: it determines what data geometry the model can "see". Some encodings map the input into highly nonlinear regions of state space — precisely where QML hopes to gain expressive power. Encoding that is too weak leaves different inputs hard to tell apart; encoding that is too strong, or too high-dimensional, can instead cause poor generalization, concentration of kernel values, or unstable training. The choice of encoding is a central part of QML model design, not a detail.

The parameterized circuit as a trainable layer

After encoding comes a variational layer with tunable parameters: a series of parameterized rotation gates, often alternating with entangling gates. These parameters w are the model's "weights". Given an input x, the circuit prepares a state |ψ(x, w)⟩, and the model's prediction is taken from the expectation value of some observable, e.g. ⟨Z0⟩:

f(x, w) = ⟨ψ(x, w)| Z0 |ψ(x, w)⟩

Training means adjusting w so that f(x, w) matches the target labels on the training data — exactly like a classical neural network.

Where the gradient comes from — the parameter-shift rule

To train with a gradient-based optimizer we need the partial derivative of f(x, w) with respect to each parameter. Classical automatic differentiation cannot be done directly on a quantum circuit, but there is an elegant result: the parameter-shift rule. For a rotation gate of the form e−iθP/2, the exact analytic gradient of its expectation value equals half the difference of the expectation values evaluated at the parameter plus π/2 and minus π/2:

∂⟨O⟩/∂θ = ½ · [ ⟨O⟩θ+π/2 − ⟨O⟩θ−π/2 ]

Note: this is the exact gradient, not a finite-difference approximation — you just run the same circuit once at each of the two shifted points. It lets a quantum layer plug seamlessly into standard optimizers like Adam and SGD.

This holds for rotation gates of the form e−iθP/2 whose generator satisfies P² = I (such as a Pauli generator): the parameter-shift rule then gives the exact analytic gradient. For more general parameterized gates or pulse-level parameters, a different shift, more evaluation points, or an approximate method may be required, and the simple two-point ±π/2 formula does not necessarily apply.

Barren plateaus — a real obstacle

QML faces a distinctive and stubborn training obstacle — barren plateaus. For many randomly initialized, sufficiently "expressive" circuits, the gradient of the loss landscape vanishes exponentially with the number of qubits. In other words, the loss surface is nearly flat across most of the space, the optimizer receives almost no directional signal, and training stalls.

Mitigations include: structured ansätze (with problem priors), carefully designed initialization, local rather than global losses, and layer-wise training. But barren plateaus are one of the fundamental constraints on QML scalability, and any serious practice must confront them.

What it is good at — and what it isn't

• The advantage is not yet proven. This is the most important point to be honest about: for the vast majority of practical data tasks, whether QML beats mature classical machine learning is not currently established. Many seemingly leading results do not hold up against stronger classical baselines.
• Training can be hard. Barren plateaus, sampling noise, and the encoding–expressivity trade-off together make training far more fragile than for classical networks.
• Data in and out is a bottleneck. Efficiently loading large-scale classical data into a quantum state is itself expensive and can cancel any potential speedup.
• There are theoretically interesting special cases. For data that is itself quantum in structure (quantum states, quantum processes), or for certain kernel methods, there are provable hints of advantage — and that is the most worthwhile direction to explore right now.

Seeing it in code

The circuit below stitches the two structures above together: the first half — ry(x[0], …), ry(x[1], …) plus an entangling gate — is the data encoding (feature map); the second half — ry(weights[0], …), ry(weights[1], …) — is the trainable variational layer; and observable = spin.z(0) sets the model's prediction to ⟨Z0⟩.

import qalgora
from qalgora import spin

@qalgora.kernel
def classifier(features: list[float], weights: list[float]):
    q = qalgora.qvector(2)
    # feature map: encode the input
    ry(features[0], q[0])
    ry(features[1], q[1])
    x.ctrl(q[0], q[1])
    # trainable layer
    ry(weights[0], q[0])
    ry(weights[1], q[1])

observable = spin.z(0)   # prediction = <Z_0>

The training loop is a standard machine-learning workflow: predict takes the circuit's output expectation value as the prediction; loss is the mean squared error; the Adam optimizer adjusts weights to drive the loss down. The gradient is wired in explicitly via qalgora.gradients.ParameterShift(), so the parameter-shift rule above is what computes the gradients with respect to weights.

import numpy as np

# 4-point parity dataset; labels encoded as -1/+1 because <Z_0> in [-1, 1]
train_x = np.array([[0.0, 0.0], [0.0, np.pi], [np.pi, 0.0], [np.pi, np.pi]])
train_y = np.array([1.0, -1.0, -1.0, 1.0])

def predict(x, w):
    return qalgora.observe(classifier, observable, x, w).expectation()

def loss(w, data, labels):
    return np.mean([(predict(x, w) - y) ** 2 for x, y in zip(data, labels)])

grad = qalgora.gradients.ParameterShift()
opt = qalgora.optimizers.Adam(gradient=grad)
weights, _ = opt.optimize(dimensions=2,
                          function=lambda w: loss(w, train_x, train_y))

Because ⟨Z0⟩ ∈ [−1, 1], the binary-classification labels can be encoded as −1 / +1.

Where it helps

• Quantum kernels — circuits as feature maps for classical SVMs.
• Variational classifiers — end-to-end trainable quantum models.
• Generative models — Born-machine sampling of distributions.