Quantum Autoencoders

Quantum Autoencoders

A quantum autoencoder compresses quantum data from qubits to qubits:

The encoder compresses the important information into qubits, while the remaining qubits are disentangled (in state).

This is useful for quantum data compression, denoising, and dimensionality reduction.

Architecture

The quantum autoencoder consists:

1. Encoder: parameterized circuit maps qubits to qubits
2. Decoder: reconstructs the original state
3. Loss function: fidelity between input and output states

The training loop:

1. Prepare input state
2. Apply encoder and decoder
3. Measure fidelity with input
4. Optimize parameters to maximize fidelity

Training

Training uses the parameter-shift rule for gradient computation:

The loss function is typically:

Minimizing this loss maximizes the reconstruction fidelity.

Applications

Quantum autoencoders are used for:

1. Quantum data compression: reduce the number of qubits needed to represent quantum data
2. Quantum denoising: remove noise from quantum states
3. Feature extraction: learn low-dimensional representations
4. Quantum error correction: detect and correct errors
5. Quantum machine learning: pre-processing for quantum ML models

Noise Reduction

Quantum autoencoders can denoise quantum states:

1. Train on noisy quantum states as input
2. Learn to map noisy states to clean states
3. The bottleneck layer filters out noise

This is particularly useful for NISQ devices where noise is significant.

Python: Quantum Autoencoder

import numpy as np

def quantum_autoencoder_encode(state, params):
    # Simplified quantum autoencoder encoding.
    # Parameterized rotation for compression
    theta = params[0]
    # Compress: map |psi> to fewer qubits
    compressed = np.array([
        state[0]*np.cos(theta) + state[1]*np.sin(theta),
        -state[0]*np.sin(theta) + state[1]*np.cos(theta)
    ])
    return compressed

def quantum_autoencoder_decode(compressed, params):
    # Simplified quantum autoencoder decoding.
    theta = params[0]
    return np.array([
        compressed[0]*np.cos(theta) - compressed[1]*np.sin(theta),
        compressed[0]*np.sin(theta) + compressed[1]*np.cos(theta)
    ])

# Train
psi = np.array([0.6, 0.8], dtype=complex)
params = np.array([0.5])

from scipy.optimize import minimize
def loss(theta):
    c = quantum_autoencoder_encode(psi, theta)
    r = quantum_autoencoder_decode(c, theta)
    return 1 - np.abs(np.vdot(psi, r))**2

result = minimize(loss, params, method='COBYLA')
print(f"Reconstruction fidelity: {1-result.fun:.4f}")

Autoencoder Architecture

The quantum autoencoder uses:

1. Encoder: maps qubits to qubits
2. Bottleneck: qubits carry compressed information
3. Decoder: reconstructs from to qubits

The compression ratio: . For , we use half the qubits.

Training minimizes:

Quantum Denoising Applications