Gate Model for QML

Gate Model for QML#

Parameterized quantum circuits as ML models. Data encoding strategies (amplitude, angle, basis encoding) and trainable layers.

The gate model provides the hardware abstraction layer for most quantum machine learning algorithms. A quantum ML model is a parameterized quantum circuit: data is encoded into the circuit, trainable gates transform the state, and measurements produce predictions. This chapter covers the building blocks: standard gates, data encoding strategies, and the structure of trainable layers.

Quantum Gates#

A quantum gate is a unitary matrix acting on one or more qubits. The most common gates in QML circuits:

Gate	Matrix	Action
\(X\) (NOT)	\(\begin{bmatrix}0 & 1\\1 & 0\end{bmatrix}\)	Bit flip: \(\|0\rangle \leftrightarrow \|1\rangle\)
\(Z\)	\(\begin{bmatrix}1 & 0\\0 & -1\end{bmatrix}\)	Phase flip: \(\|1\rangle \to -\|1\rangle\)
\(H\) (Hadamard)	\(\frac{1}{\sqrt{2}}\begin{bmatrix}1 & 1\\1 & -1\end{bmatrix}\)	Creates equal superposition
\(R_x(\theta)\)	\(e^{-i\theta\sigma_x/2}\)	Rotation around X axis
\(R_y(\theta)\)	\(e^{-i\theta\sigma_y/2}\)	Rotation around Y axis
\(R_z(\theta)\)	\(e^{-i\theta\sigma_z/2}\)	Rotation around Z axis
CNOT	\(\|0\rangle\langle 0\|\otimes I + \|1\rangle\langle 1\|\otimes X\)	Entangling gate

Unlike classical computers where the NOT gate is the only non-trivial single-bit operation, quantum computers have infinitely many single-qubit gates parameterized by continuous rotation angles. This continuity is what makes parameterized circuits natural function approximators.

Data Encoding#

Before a quantum circuit can process classical data, the data must be encoded into quantum states. The choice of encoding profoundly affects the model’s expressiveness and the potential for quantum advantage.

Basis Encoding#

Map an integer \(x\) to the corresponding computational basis state:

\[x = 5 \to |101\rangle\]

Requires \(\lceil\log_2 N\rceil\) qubits for \(N\) data points. Simple but limited: encodes only integers and uses exponentially many qubits for large datasets.

Angle Encoding#

Encode each feature \(x_j\) as a rotation angle on a dedicated qubit:

\[|\psi(x)\rangle = \bigotimes_{j=1}^{d} R_y(x_j)|0\rangle\]

Requires \(d\) qubits for \(d\)-dimensional data. This is the most common encoding in variational QML because it maps naturally to parameterized circuits and each feature gets its own qubit.

Amplitude Encoding#

Encode a normalized \(d\)-dimensional vector \(\mathbf{x}\) as the amplitudes of a quantum state:

\[|\psi(x)\rangle = \sum_{j=0}^{d-1} x_j |j\rangle\]

Requires only \(\lceil\log_2 d\rceil\) qubits, an exponential compression. However, preparing this state generically requires \(O(d)\) gates, which negates the qubit savings. Amplitude encoding is most useful when the data has structure that allows efficient preparation.

Comparison#

Encoding	Qubits	Gate Depth	Expressiveness
Basis	\(\lceil\log_2 N\rceil\)	\(O(n)\)	Integers only
Angle	\(d\)	\(O(1)\) per qubit	Continuous features, one per qubit
Amplitude	\(\lceil\log_2 d\rceil\)	\(O(d)\) generic	Full vector, exponential compression
IQP / Hamiltonian	\(d\)	\(O(d^2)\)	Nonlinear feature interactions

The encoding bottleneck

Data encoding is often the computational bottleneck in QML. If encoding \(d\)-dimensional data requires \(O(d)\) gates, the quantum circuit is already as expensive as a classical linear operation. Quantum advantage in QML typically requires either structured data that admits efficient encoding or problems where the encoding itself provides the advantage (as in kernel methods).

Parameterized Circuit Structure#

A typical QML circuit alternates between data-encoding layers and trainable layers:

\[U(\mathbf{x}, \boldsymbol{\theta}) = \prod_{\ell=1}^{L} W(\boldsymbol{\theta}_\ell) \cdot S(\mathbf{x})\]

where \(S(\mathbf{x})\) encodes the data and \(W(\boldsymbol{\theta}_\ell)\) is a trainable unitary parameterized by angles \(\boldsymbol{\theta}_\ell\). A single trainable layer typically consists of:

Single-qubit rotations \(R_y(\theta_j)\) or \(R_z(\theta_j)\) on each qubit.
Entangling gates (CNOTs) connecting pairs of qubits.

The output is an expectation value \(\langle\psi|O|\psi\rangle\) for some observable \(O\), which serves as the model’s prediction.

Code Examples#

Qiskit

from qiskit.circuit import QuantumCircuit, Parameter
import numpy as np

n_qubits = 4
n_layers = 2

qc = QuantumCircuit(n_qubits)

# Data encoding: angle encoding
x = [Parameter(f'x_{i}') for i in range(n_qubits)]
for i in range(n_qubits):
    qc.ry(x[i], i)

# Trainable layers
for layer in range(n_layers):
    theta = [Parameter(f'θ_{layer}_{i}') for i in range(n_qubits)]
    for i in range(n_qubits):
        qc.ry(theta[i], i)
    for i in range(n_qubits - 1):
        qc.cx(i, i + 1)

qc.measure_all()
print(qc)

Cirq

import cirq
import sympy

n_qubits = 4
n_layers = 2
qubits = cirq.LineQubit.range(n_qubits)
circuit = cirq.Circuit()

# Data encoding: angle encoding
x = [sympy.Symbol(f'x_{i}') for i in range(n_qubits)]
circuit.append(cirq.ry(x[i]).on(qubits[i]) for i in range(n_qubits))

# Trainable layers
for layer in range(n_layers):
    theta = [sympy.Symbol(f'θ_{layer}_{i}') for i in range(n_qubits)]
    circuit.append(cirq.ry(theta[i]).on(qubits[i]) for i in range(n_qubits))
    circuit.append(cirq.CNOT(qubits[i], qubits[i+1]) for i in range(n_qubits - 1))

circuit.append(cirq.measure(*qubits, key='result'))
print(circuit)

PennyLane

import pennylane as qml
from pennylane import numpy as np

n_qubits = 4
n_layers = 2
dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def circuit(x, theta):
    # Data encoding: angle encoding
    for i in range(n_qubits):
        qml.RY(x[i], wires=i)
    # Trainable layers
    for layer in range(n_layers):
        for i in range(n_qubits):
            qml.RY(theta[layer, i], wires=i)
        for i in range(n_qubits - 1):
            qml.CNOT(wires=[i, i + 1])
    return qml.expval(qml.PauliZ(0))

x = np.random.uniform(0, np.pi, n_qubits)
theta = np.random.uniform(0, np.pi, (n_layers, n_qubits))
print(circuit(x, theta))

PyQuil

from pyquil import Program
from pyquil.gates import RY, CNOT, MEASURE
from pyquil.quilbase import Declare

n_qubits = 4
n_layers = 2
p = Program()
ro = p.declare('ro', 'BIT', n_qubits)

# Data encoding: angle encoding
# In practice, parameters are substituted at runtime
for i in range(n_qubits):
    theta_x = p.declare(f'x_{i}', 'REAL')
    p += RY(theta_x, i)

# Trainable layers
for layer in range(n_layers):
    for i in range(n_qubits):
        theta = p.declare(f'theta_{layer}_{i}', 'REAL')
        p += RY(theta, i)
    for i in range(n_qubits - 1):
        p += CNOT(i, i + 1)

for i in range(n_qubits):
    p += MEASURE(i, ro[i])

print(p)