Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install hiyenwong-ai-collection-collection-skills-learnable-observable-qnngit clone https://github.com/hiyenwong/ai_collection.gitcp ai_collection/SKILL.MD ~/.claude/skills/hiyenwong-ai-collection-collection-skills-learnable-observable-qnn/SKILL.md---
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
```python
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
```python
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
```python
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
```python
# 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