Hybrid Quantum Neural Networks

Embed a parameterized quantum circuit as a layer inside a classical PyTorch network and train the whole model end-to-end. It treats a quantum circuit as a "special layer" of a neural network, stitched seamlessly together with classical layers.

The core idea — a quantum circuit as a layer

A modern neural network is a stack of "layers": each takes the previous layer's tensor, applies a differentiable transformation, and passes it on. The key insight of a hybrid quantum neural network is that a parameterized quantum circuit can itself serve as such a layer. It takes a numeric vector, encodes it into qubits, applies trainable rotations, and outputs a set of observable expectation values. From the outside, it is just a layer that "takes a tensor in, puts a tensor out, and holds trainable parameters" — no different from a Linear or Conv2d.

This gives a hybrid stack: classical layers handle efficient feature extraction and dimensionality reduction, the quantum layer provides a different non-linear feature map and inductive bias, and a classical layer reads it back out — whether that helps over a purely classical layer must be validated task by task. The whole pipeline is trained end-to-end together.

Inside the quantum layer — encoding plus trainable weights

Inside, the quantum layer reuses the standard two-part structure of a variational quantum model:

• Data encoding: use the input components as rotation angles (e.g. ry(x0, q0)) to write the classical data into the quantum state.
• Trainable rotations: a set of rotation gates with learnable parameters w, forming the layer's "weights".

The layer's output is the expectation value of some observable, e.g. ⟨Z0⟩ — a real number in [−1, 1] that can be fed directly to a following classical layer.

The hybrid training loop — how gradients flow through

End-to-end training requires gradients to flow through both the classical and quantum layers simultaneously. Classical layers use ordinary backpropagation; the difficulty is the quantum layer — there is no classical automatic differentiation on a circuit. The solution is again the parameter-shift rule: for each parameter of the quantum layer, run the circuit once with that parameter shifted by +π/2 and once by −π/2, and half the difference of the two expectation values is the exact analytic gradient (exact for the Pauli-generated rotations used here, such as ry; gates with other generators need adapted shift values). When the quantum layer sits after a classical layer, the same rule applied to the input encoding angles also yields the gradient with respect to the layer's inputs, so the upstream classical layer receives gradients too.

Once this gradient is connected into the framework's computation graph by the chain rule, a classical optimizer (such as Adam) can update the quantum-layer parameters just like any ordinary weight. The whole hybrid model thus forms one unified, differentiable training loop: the forward pass runs through both classical and quantum layers to a prediction, and the backward pass sends gradients seamlessly back to every layer.

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

• Flexible architecture. The quantum layer can be placed anywhere in the network and freely combined with mature classical components, making it easy to run controlled experiments inside existing deep-learning pipelines.
• Constrained by the same hard problems. The quantum layer still meets barren plateaus, sampling noise, and the data-encoding bottleneck; wrapping it in PyTorch does not remove these fundamental constraints.
• Expensive to simulate. Every step and every sample in training must execute the quantum circuit (multiple times); on a classical simulator this is often far slower than a comparable purely classical network.
• Advantage not yet proven. Consistent with QML as a whole: when and for which tasks a hybrid model truly surpasses a purely classical network is an open research question, not a settled fact.

The algorithm, step by step

1. Define the quantum layer: encode with rotations from the input components, then apply rotations with trainable parameters, and output an observable's expectation value.
2. Wrap the layer as a standard framework module (e.g. torch.nn.Module) and declare its trainable parameters.
3. Stack the quantum layer with classical layers into a hybrid model.
4. Forward pass: data flows through the layers in turn to a prediction and a loss.
5. Backward pass: classical layers use automatic differentiation, the quantum layer uses the parameter-shift rule, and gradients flow through the whole stack.
6. The optimizer updates all parameters uniformly; repeat until convergence.

Seeing it in code

The q_layer below is exactly the quantum layer described above: ry(x[0], …) and ry(x[1], …) are the data encoding, ry(w[0], …) and ry(w[1], …) are the trainable weights; quantum_forward takes ⟨Z0⟩ as the layer's output.

import qalgora
from qalgora import spin

@qalgora.kernel
def q_layer(features: list[float], w: list[float]):
    q = qalgora.qvector(2)
    ry(features[0], q[0]); ry(features[1], q[1])     # data encoding
    x.ctrl(q[0], q[1])
    ry(w[0], q[0]); ry(w[1], q[1])     # trainable weights

def quantum_forward(features, w):
    return qalgora.observe(q_layer, spin.z(0), features, w).expectation()

Now wrap the quantum layer as a standard torch.nn.Module: self.w is the weight declared as a trainable parameter, and forward calls quantum_forward sample by sample; then Sequential sandwiches it between two classical Linear layers to form the shape of an end-to-end hybrid stack. (The torch.tensor(…, requires_grad=True) line shown is a forward-pass stub — it does not produce correct gradients for self.w, and xi.tolist() likewise detaches the input x, so upstream classical layers receive no gradient either; a true backward pass needs a custom torch.autograd.Function implementing the parameter-shift gradient above.)

import torch

class QuantumLayer(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.w = torch.nn.Parameter(torch.rand(2))
    def forward(self, x):
        outs = [quantum_forward(xi.tolist(), self.w.tolist()) for xi in x]
        return torch.tensor(outs, requires_grad=True).unsqueeze(1)   # (batch, 1) for the next Linear

# Linear(4, 2) -> 2 encoding angles -> 1 expectation per sample -> Linear(1, 1)
model = torch.nn.Sequential(torch.nn.Linear(4, 2), QuantumLayer(),
                            torch.nn.Linear(1, 1))