quantum-reservoir-computing

name	quantum-reservoir-computing
description	Quantum Reservoir Computing (QRC) framework for chaotic time-series prediction and dynamical systems modeling. Use for benchmarking fixed-reservoir vs variational quantum architectures, implementing quantum physics-informed neural networks (QPINN), and analyzing quantum machine learning performance on NISQ devices. Focus on Lorenz system and chaotic dynamics applications.

Quantum Reservoir Computing for Chaotic Dynamics

This skill implements the Quantum Reservoir Computing (QRC) framework for time-series prediction on chaotic systems, benchmarking against variational Quantum Physics-Informed Neural Networks (QPINN).

Overview

Deploying quantum machine learning on NISQ devices requires architectures where training overhead does not negate computational advantages. This methodology systematically compares QRC (fixed-reservoir) vs QPINN (variational) approaches for chaotic time-series prediction.

Key Findings

Performance Comparison (4-5 qubits, 2-3 layers)

• QRC MSE: ~10^-3 (significantly lower)
• QPINN MSE: Higher error
• Training Speed: QRC trains ~10,000x faster (0.2s vs hours per seed)
• Root Cause: QPINN instability stems from capacity limitations and competing loss terms, NOT barren plateaus

Activation Keywords

• quantum reservoir computing
• QRC
• QPINN
• quantum physics-informed neural network
• chaotic dynamics
• Lorenz system
• fixed-reservoir quantum
• variational quantum architecture

Tools Used

• exec: Run quantum simulations and benchmarks
• python: Implement QRC and QPINN architectures

Core Methodology

1. Quantum Reservoir Computing (QRC)

Architecture

Input State → Quantum Reservoir (Fixed Hamiltonian) → Measurement → Classical Readout

Fixed Hamiltonian

• Transverse-field Ising model
• Fixed parameters (no variational optimization)
• Natural quantum dynamics as reservoir states

Temporal Windowing Technique

Based on classical delay-embedding principle:

def temporal_window(input_history, window_size):
    """
    Provide bounded, structured input history
    Improves attractor reconstruction
    """
    return input_history[-window_size:]

2. Quantum Physics-Informed Neural Network (QPINN)

Architecture

Input → Variational Quantum Circuit (Trainable) → Measurement → Physics-Informed Loss

Loss Components

1. Data Loss: MSE between predictions and ground truth
2. Physics Loss: Residuals of governing equations
3. Regularization: Parameter norm constraints

Failure Mode Analysis

• NOT Barren Plateaus: Gradient norms remain large (~10^-1)
• Capacity Limitation: Limited expressivity for complex dynamics
• Competing Objectives: Data fidelity vs physics constraints

Implementation

QRC Implementation

import pennylane as qml
import numpy as np

class QuantumReservoir:
    def __init__(self, n_qubits, hamiltonian_params):
        self.n_qubits = n_qubits
        self.params = hamiltonian_params  # Fixed!
        self.dev = qml.device("default.qubit", wires=n_qubits)
    
    @qml.qnode
    def reservoir_dynamics(self, input_state, time_steps):
        # Initialize state
        qml.MottonenStatePreparation(input_state, wires=range(self.n_qubits))
        
        # Apply fixed Hamiltonian evolution
        for t in range(time_steps):
            self._ising_step()
        
        # Return expectation values
        return [qml.expval(qml.PauliZ(i)) for i in range(self.n_qubits)]
    
    def _ising_step(self):
        # Transverse-field Ising model
        for i in range(self.n_qubits):
            qml.RX(self.params['h'], wires=i)
        for i in range(self.n_qubits - 1):
            qml.IsingXX(self.params['J'], wires=[i, i+1])

Temporal Windowing

class TemporalWindowEncoder:
    def __init__(self, window_size, stride=1):
        self.window_size = window_size
        self.stride = stride
    
    def encode(self, time_series):
        """
        Create delay-embedded windows for reservoir input
        """
        windows = []
        for i in range(0, len(time_series) - self.window_size, self.stride):
            window = time_series[i:i + self.window_size]
            windows.append(window)
        return np.array(windows)

Benchmarking Framework

class QuantumChaosBenchmark:
    def __init__(self, system='lorenz'):
        self.system = system
        self.systems = {
            'lorenz': LorenzSystem(),
            'rossler': RosslerSystem(),
            'lorenz96': Lorenz96System()
        }
    
    def benchmark(self, model, n_seeds=10):
        results = []
        for seed in range(n_seeds):
            # Generate data
            train_data, test_data = self.systems[self.system].generate(seed)
            
            # Train and evaluate
            model.train(train_data)
            mse = model.evaluate(test_data)
            train_time = model.training_time
            
            results.append({
                'seed': seed,
                'mse': mse,
                'train_time': train_time
            })
        
        return self._aggregate(results)

Test Systems

1. Lorenz System

dx/dt = σ(y - x)
dy/dt = x(ρ - z) - y
dz/dt = xy - βz

Parameters: σ=10, ρ=28, β=8/3

2. Rössler System

dx/dt = -y - z
dy/dt = x + ay
dz/dt = b + z(x - c)

Parameters: a=0.2, b=0.2, c=5.7

3. Lorenz-96 System

N-dimensional chaotic system with forcing F:

dx_i/dt = (x_{i+1} - x_{i-2})x_{i-1} - x_i + F

Results Summary

System	QRC MSE	QPINN MSE	QRC Training	QPINN Training
Lorenz	~10^-3	Higher	0.2s	Hours
Rössler	~10^-3	Higher	0.2s	Hours
Lorenz-96	~10^-3	Higher	0.2s	Hours

Key Insights

1. Fixed-Reservoir Advantage: Non-variational approach avoids optimization instabilities
2. No Barren Plateaus: Gradients remain tractable at tested scales
3. Temporal Structure: Delay embedding crucial for attractor reconstruction
4. NISQ Compatibility: Minimal quantum circuit depth required

Advanced Technique: Split-Ensemble Training

From "Reorganizing Quantum Measurement Records Improves Time-Series Prediction" (arXiv:2604.28160v1, 2026-04-30).

Problem

Standard approach averages all shots from one labeled time step into a single feature vector. This reduces finite-shot noise but gives the readout only one training example per time step — too few for effective learning.

Solution: Split-Ensemble Training

Split the same measurement shots into groups, and use each group average as a separate, partially denoised feature vector for the same target:

def split_ensemble(shots, n_groups):
    """
    Split measurement records into n_groups.
    Each group average becomes a separate training example.
    No additional quantum circuit executions required.
    """
    group_size = len(shots) // n_groups
    groups = [shots[i*group_size:(i+1)*group_size] for i in range(n_groups)]
    feature_vectors = [np.mean(g, axis=0) for g in groups]
    return feature_vectors  # n_groups examples for same target

Benefits

• More training data without additional quantum hardware cost
• Partial denoising from group averaging (trade-off between noise reduction and data quantity)
• Strongest gains on real hardware where shot noise is significant
• Broadly applicable across quantum reservoir computing tasks

Integration with QRC

class EnhancedQRC(QuantumReservoir):
    def extract_features_split(self, input_history, window_size, n_groups=4):
        """
        Split-ensemble feature extraction for QRC.
        Instead of averaging all shots, split into groups.
        """
        all_shots = self.run_circuit(input_history, n_shots=1024)
        # Split into groups, each gives a training example
        feature_groups = split_ensemble(all_shots, n_groups)
        # Each group is a partially-denoised feature vector
        return feature_groups

References

• Paper: "Fixed-Reservoir vs Variational Quantum Architectures for Chaotic Dynamics: Benchmarking QRC and QPINN on the Lorenz System" (arXiv:2604.23743)
• Paper: "Reorganizing Quantum Measurement Records Improves Time-Series Prediction" (arXiv:2604.28160v1, 2026-04-30) - Split-Ensemble Training
• Author: Tushar Pandey (QRC); Markus Baumann et al. (Split-Ensemble)
• Categories: Quantum Physics (quant-ph), Machine Learning (cs.LG)

Best Practices

1. Use Temporal Windowing: Essential for capturing dynamics
2. Apply Split-Ensemble: When readout has too few training examples, split shots into groups (n_groups=4-8 recommended)
3. Start Small: Test on 4-5 qubits before scaling
4. Monitor Gradients: Verify non-vanishing gradients in QPINN
5. Multiple Seeds: Average over random initializations
6. Physics Validation: Compare reconstructed attractors visually

Medical Dataset Applications

Hardware-Induced Regularization on Small Medical Data

When applying QRC to small, complex medical datasets (biomarker prediction, < 1000 samples), hardware execution on neutral-atom Rydberg processors produces a beneficial regularization effect:

• Mean compression — feature values shift toward mean, reducing extreme values
• Mutual information decay — progressive MI reduction between features
• Reduced variance across data splits vs noiseless emulation

This is NOT simple noise degradation — it acts as implicit regularization (analogous to dropout in classical DL). See [[quantum-reservoir-medical-regularization]] skill (arXiv: 2602.14641) for full methodology.

When to Use QRC for Medical Prediction

• Dataset < 1000 samples with nonlinear, correlated biomarkers
• Classical ML overfits on emulation; hardware noise provides regularization
• Use SHAP for feature subset selection before quantum encoding
• Always compare emulation vs hardware execution

Limitations

• Tested on small qubit counts (4-5)
• Quantum advantage not yet demonstrated
• Requires classical optimization of readout layer
• Hardware noise not fully characterized
• Split-ensemble: optimal group size depends on total shot budget and noise level

Related Skills

• quantum-machine-learning
• physics-informed-neural-networks
• chaotic-systems-modeling
• quantum-reservoir-medical-regularization — QRC for small medical datasets; hardware-induced regularization effect on neutral-atom processors