---
title: Simplified Predictive Local Rule (SPLR)
url: https://www.emergentmind.com/topics/simplified-predictive-local-rule-splr
type: topic
---

# Simplified Predictive Local Rule (SPLR)

The Simplified Predictive Local Rule (SPLR) is a biologically inspired learning algorithm designed for extreme learning machines (ELMs) that eschews global backpropagation and intensive matrix operations in favor of local, prediction-driven, sparse, and hardware-efficient synaptic updates. SPLR operates in an online regimen with per-sample updates that are explicitly triggered only by prediction errors, resulting in significant reductions in computational and memory complexity. Its local and binary update mechanism makes it particularly suitable for logic-only implementation in resource-constrained environments and edge devices [2512.21777].

## 1. Mathematical Formulation and Derivation

SPLR is embedded within the standard ELM framework, which consists of a fixed, randomly projected hidden layer and a linear readout. The principal steps of the SPLR formulation are as follows:

**A. Hidden-layer Activation and Output Prediction:**  
Let $\mathbf{x}\in\mathbb R^D$ be the input vector, $\mathbf{W}_{\rm in}\in\mathbb R^{M\times D}$ the fixed random projection, and $\mathbf b\in\mathbb R^M$ the bias. The hidden state is computed as:
$$
\mathbf{h} = \Theta(\mathbf{W}_{\rm in} \mathbf{x} + \mathbf{b}) \in \{0,1\}^M
$$
where $\Theta$ denotes the Heaviside (step) function. The output score for each class $j$ is obtained via a linear readout:
$$
o_j = \sum_{i=1}^M h_i W_{ij}, \quad \hat y = \arg\max_j o_j
$$

**B. Loss and Local Gradients:**  
A winner-take-all (WTA) loss penalizes the gap between the predicted class $\hat y$ and the true class $y$:
$$
\mathcal{L} = \frac{1}{2}(o_{\hat y} - o_y)^2
$$
The gradient with respect to the output weights is,
$$
\frac{\partial \mathcal{L}}{\partial W_{i\hat y}} = (o_{\hat y} - o_y) h_i \\
\frac{\partial \mathcal{L}}{\partial W_{i y}} = - (o_{\hat y} - o_y) h_i
$$

**C. Discrete, Sparse Update Rule:**  
The SPLR simplifies the update to trigger only when $\hat y \neq y$, absorbing the error term’s sign into a binary learning rate $\eta$:
$$
\Delta W_{i y} = +\eta h_i \\
\Delta W_{i\hat y} = -\eta h_i
$$
Weights are clipped into $[-w_{\max}, w_{\max}]$ after update. No updates occur for correct predictions.

## 2. Online Algorithmic Implementation

SPLR operates in an incremental, single-pass (online) manner. The algorithm proceeds as:

1. Compute hidden activations: $\mathbf{h} \leftarrow \Theta(\mathbf{W}_{\rm in} \mathbf{x} + \mathbf{b})$
2. Compute output vector: $\mathbf{o} \leftarrow \mathbf{W}^T \mathbf{h}$
3. Determine predicted class: $\hat y \leftarrow \arg\max_j o_j$
4. On error ($\hat y \neq y$), update only weights linked to classes $y$ and $\hat y$:
   - $W_{i,y} \leftarrow \mathrm{clip}(W_{i,y} + \eta h_i)$
   - $W_{i,\hat y} \leftarrow \mathrm{clip}(W_{i,\hat y} - \eta h_i)$

This differs fundamentally from standard ELM, which amasses the entire hidden response matrix $H$ and computes the optimal output weights in a batch, closed-form inversion,
$$
W^* = (H^T H)^{-1} H^T T
$$
with $O(M^3)$ cost. SPLR requires only $O(M)$ time per misclassified sample, operating in a streaming, error-driven paradigm [2512.21777].

## 3. Computational Complexity

The breakdown of computational costs is as follows:

| Operation                | Standard ELM                    | SPLR–ELM                |
|--------------------------|----------------------------------|-------------------------|
| Training matrix inversion| $O(M^3)$                         | --                      |
| Per-sample learning      | $O(M^2)$ (in batch accumulation) | $O(M)$                  |
| Total (per $N$ samples)  | $O(M^3 + N M^2)$                 | $O(N M)$                |

For large hidden layers ($M \gg D,C$), SPLR’s per-sample complexity is linear in $M$, while standard ELM is cubic. This constitutes a major advantage for memory- and compute-constrained scenarios. The dominant update in SPLR is binary-driven vector addition to two output weight columns during errors [2512.21777].

## 4. Accuracy and Convergence Characteristics

On the MNIST dataset (5,000 training / 1,000 test samples, $M = 2048$ hidden units):

- Standard ELM achieves $\approx 90.0\%$ training and $\approx 81.3\%$ test accuracy.
- SPLR-ELM reaches $\approx 86.4\%$ training ($-3.6\%$ absolute) and $\approx 79.3\%$ test accuracy ($-2.0\%$ absolute).

SPLR typically stabilizes within a single online pass, whereas standard ELM yields an exact, batch-optimal result but is not suited for streaming input. This suggests SPLR is well-matched to online or continual learning deployments [2512.21777].

## 5. FPGA Implementation and Resource Utilization

The SPLR rule is amenable to highly parallel and energy-efficient hardware implementation:

- **Hidden-Layer Neuron Modules (HN):** Each composed of a pseudo-random number generator (LFSR) for on-the-fly $\mathbf{W}_{\rm in}$ reconstruction, multiply-accumulate logic for projections, comparator for thresholding, and serial shift register output.
- **Output-Layer Neuron Modules (ON):** For each class, prediction is accumulated, and, upon mistaken predictions, weights are updated in external BRAM.
- **Pipeline:** Data are streamed in, hidden activations are serialized, outputs are computed, and weight updates are performed via parallel BRAM access.

On a ZCU104 Ultrascale+ running at 224 MHz with $M = 1700$ hidden units, resource and throughput metrics are:

| Metric      | Value           |
|-------------|-----------------|
| LUTs        | 205,000         |
| FFs         | 158,000         |
| DSPs        | 1,700           |
| BRAM        | 5 blocks        |
| Max Freq    | 224 MHz         |
| Training FPS| 63,454          |
| Inference FPS|122,336         |
| Power       | $\approx 3.12$ W|
| Power Eff.  | $39,210$ FPS/W  |

Compared to R-STDP and STDP-based FPGA cores, SPLR-ELM realizes $>60,000$ FPS in training and $>120,000$ FPS in inference at comparable or lower per-neuron footprint [2512.21777].

## 6. Biological Motivation and Implications for Edge AI

SPLR is distilled from the predictive learning rule (PLR) of Saponati & Vinck (2023), derived from models of cortical predictive coding and spike-timing-dependent plasticity (STDP). Updates are strictly local, depending only on the presynaptic spike ($h_i$) and winner/loser class indicators, mirroring synaptic changes driven by mismatch (prediction error) signals found in neurobiology.

The update rule does not require global synchronization, backpropagation, or eligibility traces, thereby enabling efficient, online, and hardware-friendly learning. This makes SPLR highly applicable to energy-constrained, always-on edge devices such as vision sensors and anomaly detectors, where continuous adaptation with minimal overhead is essential [2512.21777].

Source: https://www.emergentmind.com/topics/simplified-predictive-local-rule-splr