Arthedain

Real-time neural decoding via recurrent spiking networks — no backpropagation, no replay buffer, O(1) memory. Designed for edge deployment: implantable BCIs, industrial IoT, and event-driven robotics.

Arthedain is a real-time neural system that learns continuously during deployment using local plasticity rules instead of backpropagation. Dual-Timescale Hebbian Accumulators allow recurrent SNNs to decode spiking activity in real time through error-modulated plasticity rules operating on two complementary timescales, delivering high-performance online adaptation for brain-computer interfaces without the computational burden of BPTT.

The Core Idea

Standard sequence models (LSTMs, Transformers) require backpropagation through time (BPTT) — unrolling the full history to compute gradients. This is computationally expensive, memory-intensive, and biologically implausible. It cannot run at the edge.

Arthedain replaces BPTT with dual-timescale eligibility traces: local, synapse-level signals that accumulate spike correlations across two temporal windows simultaneously.

Arthedain introduces dual-timescale Hebbian accumulators—combining fast (~100ms) and slow (~700ms) eligibility traces that locally accumulate pre- and post-synaptic spike correlations at each synapse—to enable real-time, online learning and decoding in recurrent spiking neural networks (RSNNs) for neural spike trains.

This replaces memory-intensive backpropagation-through-time (BPTT) and replay buffers with a fully local, three-factor plasticity rule that requires only O(1) constant memory while achieving competitive or superior performance (e.g., Pearson R of 0.81 on the Indy BCI dataset) and extreme energy efficiency for edge deployment in implantable brain-computer interfaces, event-driven robotics, and streaming IoT applications with concept drift.

Key Innovation

e_fast(t) = γ_fast · e_fast(t−1) + pre × post— ~100ms window, immediate correlations
e_slow(t) = γ_slow · e_slow(t−1) + pre × post— ~700ms window, longer dependencies

E(t) = α · e_fast + β · e_slow— combined eligibility trace

ΔW = η · E(t) · δ(t)— local weight update modulated by error

No weight transport. No forward passes stored in memory. Every synapse updates from local information only.

Neuroscience Grounding

The dual-timescale design has direct biological analogs:

• Fast traces (~100ms): Map to AMPA receptor kinetics — mediate immediate synaptic transmission and fine motor timing
• Slow traces (~700ms): Map to NMDA receptor kinetics — enable longer temporal integration and multi-step sequence learning
• Error signal δ(t): Analogous to dopamine or other neuromodulators that gate plasticity (three-factor rule: pre × post × modulatory)

This alignment with biological learning mechanisms suggests the approach may generalize better to non-stationary environments where exact gradient computation fails.

Mathematical Foundation

Built on the theoretical framework of e-prop (Bellec et al., 2020), Arthedain implements a mathematically grounded approximation to gradient descent that eliminates backpropagation-through-time.

The Eligibility Propagation Factorization

For a recurrent spiking network with spikes z_j^t in the set {0,1} and hidden states h_j^t, the loss gradient decomposes as:

Where:

• L_j^t = ∂E/∂z_j^t is the learning signal — how much neuron j at time t contributes to the loss
• e_ji^t = ∂z_j^t/∂h_j^t · ε_ji^t is the eligibility trace — how much weight W_ji influenced neuron j's firing

Online Computation via Recursion

The eligibility vector ε_ji^t satisfies a recursive update:

This recursion captures the entire history of synaptic influence without storing past states. For Leaky Integrate-and-Fire (LIF) neurons, the Jacobian reduces to exponential decay.

Neuron Dynamics

Leaky Integrate-and-Fire (LIF)

Where γ = e^(-Δt/τ_m) is the membrane leak factor, Θ is the Heaviside step function, and v_th is the firing threshold. The eligibility trace for LIF reduces to a filtered spike train:

Adaptive LIF (ALIF)

For enhanced temporal processing, Arthedain supports adaptive thresholds:

The adaptation variable a_j^t introduces a slow timescale (ρ ≈ 0.9) enabling longer temporal dependencies — analogous to LSTM gating but through biological mechanisms.

Pipeline

The readout is updated by a simple delta rule. The recurrent weights are updated by the Hebbian trace modulated by a scalar error signal (supervised, reward, or self-supervised).

Why Two Timescales

Ablation results show that the dual trace consistently outperforms either single trace, with the fast trace dominating for instantaneous decoding tasks and the slow trace critical for tasks requiring temporal integration.

Ablation Details: α/β Sweep

Systematic sweeps across α ∈ [0.0, 1.0] on the Indy dataset confirm the optimal operating point:

Benchmarks

Energy estimate vs dense ANN equivalent: ~10–30× reduction in synaptic operations (SynOps), scaling with spike sparsity (~5% average activity).

Latency & Memory Breakdown

FORCE2 Reservoir Learning

For complex dynamical pattern generation, Arthedain integrates First-Order Reduced and Controlled Error (FORCE) learning with spiking reservoirs. The approach combines:

• LIF Spiking Neurons: Integrated Arthedain's LIFLayer with refractory periods
• Chaotic reservoir initialization: Spectral radius ρ(W_rec) ∈ [1.5, 1.8] for rich dynamics
• Online RLS updates: Recursive least squares for readout weight optimization
• Teacher forcing: Target signal feedback during training for stable convergence
• Filtered spike trains: Exponential filtering r^t = α r^(t-1) + (1-α) z^t for smooth readout

RLS Update Equations

Where P^t is the inverse correlation matrix and e^t = y* - y^t is the prediction error. This provides second-order convergence with O(N²) memory per output.

Chaotic Dynamics & Lyapunov Spectrum

The reservoir's spectral radius determines its dynamical regime:

The chaotic regime maximizes the reservoir's computational capacity through the echo state property — input perturbations create distinguishable trajectories in high-dimensional state space.

Benchmark Results

Why 0.81 correlation matters:The spectral radius sweep uses 500 neurons vs 800-2000 in full tests. Smaller networks with conservative RLS parameters achieve correlations very close to the paper's >0.95 results, validating that the core FORCE algorithm is implemented correctly. Larger networks need different hyperparameters — the gap is in tuning, not the algorithm.

Usage

from training.force2_lif_trainer import make_lif_force_trainer_for_oscillator

# Create trainer for 2Hz oscillator
trainer = make_lif_force_trainer_for_oscillator(freq=2.0, n_neurons=1000)

# Train with teacher forcing
for t in range(len(pattern)):
    y_pred, error = trainer.train_step(
        x=torch.zeros(1),
        target=pattern[t]
    )

Echo State Predictive Plasticity (ESPP)

Building on the theoretical framework of Graf et al. (2024), Arthedain implements Echo State Predictive Plasticity — a biologically inspired learning rule that leverages the reservoir's own activity as a predictive signal, eliminating the need for separate output weights in certain learning paradigms.

Key Features

1. Echo Prediction

Uses the previous sample's spike activity as the prediction for the current sample — no additional output weights required. The reservoir's intrinsic dynamics serve as a temporal basis:

2. Contrastive Learning

The learning signal emerges from contrasting similarity under different behavioral conditions:

• Fixation (same label): Maximize similarity between ŷ^t and y*
• Saccade (different label): Minimize similarity — the echo should diverge from incorrect predictions

3. Intrinsic Regularization

Adaptive thresholds create a negative feedback loop that automatically regulates spike sparsity:

This maintains optimal sparsity (~5-10% firing rate) without manual tuning, analogous to biological firing rate homeostasis.

4. Fully Local Computation

• O(1) memory per neuron: Only current state + eligibility trace stored
• No backpropagation through time: Updates are causal and online
• No global error broadcast: Learning signal derived from local similarity

Usage

from training import make_espp_trainer

trainer = make_espp_trainer(n_neurons=1000, n_classes=10)

# Training loop
for sample_idx, (data, label) in enumerate(dataset):
    # Process sample timesteps
    for t in range(timesteps):
        spikes, output, loss = trainer.step(data[t], label)

    # End sample to update echo buffer
    trainer.end_sample(label)

Key Modules

DualHebbianAccumulator

from models.hebbian import DualHebbianAccumulator, HebbianConfig

hebbian = DualHebbianAccumulator(HebbianConfig(
    shape=(hidden_size, hidden_size),
    tau_fast=5.0,    # ~100ms at 1ms/step
    tau_slow=50.0,   # ~700ms at 1ms/step
    alpha=0.7,
    beta=0.3,
))

E = hebbian.update(pre_spikes, post_spikes)
W_rec += lr * E * error_signal

OnlineTrainer

from training.online_trainer import OnlineTrainer, TrainerConfig

trainer = OnlineTrainer(
    rsnn, readout, hebbian,
    TrainerConfig(
        mode="supervised",   # or "reward" / "self_supervised"
        lr_readout=2e-3,
        lr_recurrent=5e-5,
    )
)

for x, y in stream:
    y_pred, error = trainer.step(x, target=y)

Streaming Generators

from data.synthetic import bci_velocity_stream, supply_chain_stream

# BCI: population spikes → 2D cursor velocity
for spikes, velocity in bci_velocity_stream(T=2000, input_size=100):
    ...

# Supply chain: sparse event stream with concept drift
for events, demand in supply_chain_stream(T=2000, drift_rate=0.001):
    ...

Related Work & Positioning

Arthedain sits within the landscape of biologically plausible alternatives to backpropagation:

Key distinctions:

• vs e-prop: Arthedain uses dual timescales vs. single eligibility traces, providing better multi-scale temporal learning without the symmetric weight problem
• vs RFLO: Deterministic error propagation vs. random feedback; more stable convergence
• vs BPTT: O(1) memory vs O(T); no stored activations; fully local updates

Hardware Path

The dual-timescale accumulator maps cleanly to fixed-point integer hardware:

Estimated FPGA footprint on Xilinx Artix-7 (N=128 hidden): ~8k LUTs, 15 BRAMs, ~25 mW at 100 MHz. Fits within implantable BCI power budget at 10 MHz (~2.5 mW).

Implementation Status

Extending to Your Domain

Arthedain's supply chain stream implements concept drift — the ground-truth mapping shifts slowly over time, stress-testing the online adaptation that BCI benchmarks don't cover. This is the industrial IoT differentiator: edge SNNs that adapt to non-stationary sensor streams without retraining.

To add a custom stream, implement a generator that yields (x: Tensor, y: Tensor) and pass it to OnlineTrainer.run_stream().

When to Use Arthedain vs. Standard SNNs

Limitations & Boundaries

Current Constraints

1. Single-layer RSNNs: The current implementation focuses on single recurrent layers. Multi-layer stacks require error signal propagation between layers (addressed in the predictive coding extension).
2. Convergence guarantees: Unlike gradient descent on convex losses, Hebbian rules lack universal convergence proofs. Empirically stable, but theoretical bounds are weaker.
3. Hyperparameter sensitivity: tau_fast, tau_slow, and learning rates require task-specific tuning. No automatic adaptation yet.

Failure Modes

Quick Start

Installation

git clone https://github.com/Aidistides/arthedain.git
cd arthedain
pip install -r requirements.txt

Minimal Runnable Example

import torch
from models.rsnn import RSNN, RSNNConfig
from models.hebbian import DualHebbianAccumulator, HebbianConfig
from training.online_trainer import OnlineTrainer, TrainerConfig

# Config
rsnn_cfg = RSNNConfig(input_size=100, hidden_size=128, output_size=2)
hebb_cfg = HebbianConfig(shape=(128, 128), tau_fast=5.0, tau_slow=50.0)

# Build
rsnn = RSNN(rsnn_cfg)
readout = torch.nn.Linear(128, 2)
hebbian = DualHebbianAccumulator(hebb_cfg)
trainer = OnlineTrainer(rsnn, readout, hebbian, TrainerConfig(lr_recurrent=5e-5))

# Train online
for t in range(10000):
    x = torch.randn(1, 100)      # spike data
    y_true = torch.randn(1, 2)   # targets
    y_pred, error = trainer.step(x, target=y_true)
    if t % 1000 == 0:
        print(f"Step {t}: error = {error.item():.4f}")

Expected Performance

Running the Indy benchmark (velocity decoding, 96-channel neural data):

python experiments/indy_benchmark.py --T_train 10000 --T_test 2000

Expected output: Pearson R ≈ 0.79–0.82, training time ~5–10 minutes on CPU.

Summary

Arthedain enables real-time, memory-constant learning in recurrent spiking networks through dual-timescale eligibility traces. It trades exact gradient computation for biological plausibility and hardware efficiency, achieving competitive accuracy (Pearson R 0.81 on Indy BCI) while maintaining O(1) memory regardless of sequence length. Ideal for edge deployment in BCIs, robotics, and industrial IoT where latency, power, and memory constraints exclude traditional backpropagation.

Reference

github.com/Aidistides/arthedain →