Quantum Machine Learning

Quantum-Classical ML Hybrids

Quantum machine learning (QML) combines quantum computing with classical machine learning. The main paradigms are:

1. Quantum-enhanced feature maps: encode data into quantum states
2. Parameterized quantum circuits: quantum analogues of neural networks
3. Quantum kernels: compute kernel functions in quantum feature spaces
4. Quantum data: process quantum data with quantum algorithms

The promise of QML is accessing exponentially large feature spaces while using only polynomially many qubits.

Quantum Feature Maps

A quantum feature map maps classical data to a quantum state:

The kernel trick uses inner products in the quantum feature space:

This kernel is efficiently estimable on a quantum computer but may be hard to compute classically — providing potential quantum advantage.

Quantum Support Vector Machine (QSVM)

The QSVM uses a quantum kernel in a classical SVM framework:

1. Encode training data into quantum states:
2. Estimate the kernel matrix via quantum circuits
3. Feed into a classical SVM for training

The quantum advantage arises if the kernel is hard to compute classically. However, dequantization results suggest this advantage may be limited for certain data distributions.

Quantum Neural Networks (QNNs)

A QNN uses a parameterized quantum circuit as a model:

where encodes input data and is a trainable circuit.

The training loop:

1. Forward pass: measure the QNN output
2. Compute loss
3. Compute gradients (via parameter-shift rule)
4. Update parameters:

The parameter-shift rule provides exact gradients:

Barren Plateaus in QML

QNNs suffer from barren plateaus where gradients vanish exponentially. For a random QNN with qubits and depth :

This means training requires measurements to estimate gradients — negating any quantum advantage.

Solutions: structured circuits, local cost functions, layerwise training, and noise-aware optimization can mitigate barren plateaus.

Quantum Generative Models

Quantum Born machines use quantum circuits to generate probability distributions:

Training minimizes the KL divergence between the quantum distribution and the data distribution. Quantum GANs use a quantum generator and classical (or quantum) discriminator.

These models can represent distributions that are exponentially hard for classical generators, though practical advantages remain an active research area.

Python: Quantum Kernel Estimation

import numpy as np

def quantum_kernel(x1, x2, depth=2):
    # Estimate quantum kernel using simulated quantum circuit.
    n = len(x1)
    def feature_map(x, angles):
        return np.prod(np.cos(x - angles) + 1j * np.sin(x - angles))

    phi1 = feature_map(x1, np.zeros(n))
    phi2 = feature_map(x2, np.zeros(n))
    kernel = np.abs(np.vdot(phi1, phi2))**2
    return kernel

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
K = np.zeros((4, 4))

for i in range(4):
    for j in range(4):
        K[i,j] = quantum_kernel(X[i], X[j])

print("Quantum kernel matrix:")
print(np.round(K, 4))

This computes a quantum kernel matrix for use in a quantum SVM.

Quantum Kernel Methods

The quantum kernel must satisfy:

1. Positive semi-definiteness:
2. Efficient estimation: computable on quantum hardware
3. Classical hardness: should be hard to compute classically for quantum advantage

For the kernel to provide advantage, the quantum feature map must access a feature space that is exponentially large and classically intractable.

Quantum ML Challenges

1. Data loading: encoding classical data into quantum states may negate speedup
2. Barren plateaus: gradients vanish exponentially with qubit count
3. Noise: NISQ errors degrade model performance
4. Classical simulability: many QML models can be efficiently simulated classically
5. Interpretability: quantum models may be harder to interpret than classical ones

The field is actively researching which QML applications can provide genuine quantum advantage.