learnable-observable-qnn

name: learnable-observable-qnn description: "Learnable Observable Quantum Neural Network methodology. Makes quantum measurement observables (Hermitian matrices) trainable parameters alongside circuit parameters. Reduces expert dependency in QML. Activation: quantum observable, QNN measurement, learnable observable, quantum neural network training, QML optimization."

Learnable Observable QNN (LO-QNN)

Making quantum measurement observables trainable parameters in Quantum Neural Networks (QNNs). Eliminates the need for expert-crafted Hermitian measurement operators by learning them end-to-end alongside circuit parameters.

Core Concept

Traditional QNNs require manually designed measurement observables (Hermitian matrices) to extract classical outputs from quantum states. LO-QNN parameterizes the observable and trains it jointly with the quantum circuit via gradient descent.

Mathematical Formulation

The QNN output is:

f(x) = ⟨ψ(x, θ)| O(φ) |ψ(x, θ)⟩

Where:

• |ψ(x, θ)⟩ is the quantum state from parameterized circuit with parameters θ
• O(φ) is the parameterized observable with trainable parameters φ
• Both θ and φ are optimized simultaneously via backpropagation

Observable Parameterization

The observable O(φ) is parameterized as:

O(φ) = Σᵢ φᵢ Pᵢ

Where Pᵢ are Pauli string basis operators and φᵢ are trainable coefficients.

Alternatively, parameterize via unitary rotation:

O(φ) = U(φ)† Z U(φ)

Where U(φ) is a parameterized unitary and Z is a fixed measurement operator.

Implementation Steps

Step 1: Parameterize the Observable

import torch
import numpy as np

class LearnableObservable:
    def __init__(self, num_qubits):
        # Learnable coefficients for Pauli basis decomposition
        self.coefficients = torch.nn.Parameter(
            torch.randn(4**num_qubits) * 0.01
        )
        self.num_qubits = num_qubits
    
    def forward(self):
        # Reconstruct observable from learned coefficients
        return self.build_pauli_observable(self.coefficients)
    
    def build_pauli_observable(self, coeffs):
        """Build Hermitian observable from Pauli basis."""
        # Implementation depends on quantum framework (PennyLane, Qiskit)
        pass

Step 2: Joint Training Loop

def train_qnn_with_learnable_observable(qnn_circuit, observable, 
                                          data, labels, epochs, lr=0.01):
    optimizer = torch.optim.Adam([
        *qnn_circuit.parameters(),
        *observable.parameters()
    ], lr=lr)
    
    for epoch in range(epochs):
        optimizer.zero_grad()
        
        # Forward: quantum circuit + learnable measurement
        outputs = []
        for x in data:
            state = qnn_circuit(x)  # Prepare quantum state
            obs_matrix = observable()  # Get current observable
            pred = torch.expectation(state, obs_matrix)
            outputs.append(pred)
        
        loss = torch.nn.MSELoss()(torch.stack(outputs), labels)
        loss.backward()
        optimizer.step()
    
    return qnn_circuit, observable

Step 3: PennyLane Implementation

import pennylane as qml
import numpy as np

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

@qml.qnode(dev)
def lo_qnn_circuit(inputs, circuit_params, obs_params, wires):
    # Encoding
    for i, w in enumerate(wires):
        qml.RY(inputs[i], wires=w)
    
    # Parameterized quantum circuit
    for i, w in enumerate(wires):
        qml.Rot(*circuit_params[i], wires=w)
    qml.CNOT(wires=[0, 1])
    
    # Measurement with learnable coefficients
    coeffs = obs_params
    paulis = [qml.PauliX, qml.PauliY, qml.PauliZ]
    hamiltonian = coeffs[0] * qml.PauliZ(0) + coeffs[1] * qml.PauliZ(1) + coeffs[2] * qml.PauliZ(0) @ qml.PauliZ(1)
    return qml.expval(hamiltonian)

When to Use

• QML model design without measurement expertise
• Quantum circuits where optimal measurement basis is unknown
• Hybrid quantum-classical training pipelines
• NISQ-era variational quantum algorithms
• Tasks requiring adaptive quantum measurements

Advantages

1. Reduced Expert Dependency: No need to hand-craft measurement operators
2. Adaptive Measurements: Observable evolves during training to match the task
3. End-to-End Differentiability: Full gradient flow from loss to both circuit and observable
4. Better Convergence: Joint optimization can find better optima than fixed observables
5. Framework Agnostic: Works with PennyLane, Qiskit, Cirq

Key Pitfalls

1. Observable Norm: Without constraints, learned observables can grow unbounded. Add regularization: λ * ||O(φ)||²
2. Barren Plateaus: Parameterized observables may worsen gradient vanishing. Use layerwise training.
3. Measurement Complexity: Full Pauli decomposition scales as 4^n. Use truncated basis for large systems.
4. Overparameterization: Observable params + circuit params = more parameters than data points. Use weight decay.
5. Hardware Constraints: On real quantum devices, decompose learned observable into measurable terms.

Verification

# Verify Hermiticity of learned observable
def verify_observable(O):
    import torch
    assert torch.allclose(O, O.conj().T), "Observable not Hermitian!"
    eigenvalues = torch.linalg.eigvalsh(O)
    print(f"Eigenvalue range: [{eigenvalues.min():.4f}, {eigenvalues.max():.4f}]")
    
# Training convergence check
def check_convergence(loss_history, window=10, threshold=1e-4):
    recent = loss_history[-window:]
    return max(recent) - min(recent) < threshold

Activation Keywords

• learnable observable
• quantum measurement training
• QNN observable optimization
• differentiable quantum measurement
• quantum neural network measurement
• parameterized observable
• quantum ML measurement design
• QML training without expert knowledge