NatSR: Natural Score-driven Replay

• The paper introduces robust methodologies combining Student’s t likelihood and score-based filtering to achieve efficient continual adaptation with reduced KL divergence.
• NatSR is a framework that unifies second-order natural gradient methods with replay buffers and dynamic scaling to handle outliers and regime shifts in online learning.
• By integrating a fixed-size replay buffer with a dynamic scale heuristic, NatSR demonstrates significant performance gains in both time-series forecasting and RL post-training.

Natural Score-driven Replay (NatSR) refers to two distinct but conceptually related algorithmic frameworks introduced for online continual learning (OCL) in time-series forecasting and for prioritized replay in reinforcement learning (RL) post-training of LLMs. Both variants leverage score-based measures—whether in the context of statistical filtering or task-level advantage variance—to guide robust adaptation and efficient replay, yielding improved empirical performance with lightweight, theoretically principled mechanisms.

1. Foundations: Score-driven Methods and Natural Gradients

The core of NatSR in time series OCL (Urettini et al., 19 Jan 2026) is the interpretation of neural network optimization as a parameter filtering problem within a state-space or Generalized Autoregressive Score (GAS) model. Standard stochastic gradient descent is reframed as a filtering update for the time-varying parameter vector $w_t$:

$$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$

where the scaled score $s_t = S_t \nabla_t$ incorporates the likelihood score $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$ and a scaling matrix $S_t$ (typically the inverse Fisher information). Identifying $\theta_t$ with network weights and choosing $A = \eta$, $B = 1$, $S_t = I_t^{-1}$, and $\omega = 0$, the update reduces to natural gradient ascent:

$$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$0

where $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$1 denotes the sample log-likelihood, and $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$2 is the Fisher information matrix:

$$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$3

Proposition 1 establishes that, under regularity and Lipschitz smoothness of the expected log-likelihood, the natural gradient update contracts (in expectation) toward the information-theoretic pseudo-true parameter $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$4 minimizing $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$5, and strictly reduces the Kullback--Leibler divergence to the true conditional law. This ensures theoretical optimality among first-order updates for continual adaptation.

2. Robustness through Student's t Likelihood

Standard Gaussian likelihoods in natural gradient methods can lead to unbounded updates in the presence of outliers. NatSR addresses this via a Student’s t likelihood with $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$6 degrees of freedom and scale $$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$7, modeling the residuals as

$$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$8

The heavy tails result in the per-sample negative log-likelihood

$$y_t \sim p(y_t\,|\,\theta_t),\qquad \theta_{t+1} = \omega + A s_t + B \theta_t,$$9

As the error increases, the Student’s t score decays, conferring robustness. Theorem 1 gives a uniform $s_t = S_t \nabla_t$0 bound on the natural gradient when including Tikhonov regularization $s_t = S_t \nabla_t$1:

$s_t = S_t \nabla_t$2

where $s_t = S_t \nabla_t$3 is the output dimension. This boundedness is not generally achieved with a Gaussian loss.

3. NatSR Algorithmic Architecture

NatSR in time-series OCL (Urettini et al., 19 Jan 2026) combines three core ingredients: the second-order robust Student-t natural gradient, a fixed-size replay buffer, and a dynamic scale heuristic to control adaptation rates during regime shifts.

Replay Buffer

At each $s_t = S_t \nabla_t$4, a new sample $s_t = S_t \nabla_t$5 arrives, and a batch $s_t = S_t \nabla_t$6 of prior samples is drawn from the buffer $s_t = S_t \nabla_t$7 (maintained via reservoir sampling). The loss is

$s_t = S_t \nabla_t$8

with buffer weight $s_t = S_t \nabla_t$9. The corresponding natural gradient update is computed using Fisher–information approximations for both the current and replay batches, along with a Tikhonov regularizer.

Dynamic Scale Heuristic

The scale parameter $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$0 is updated using a score-driven rule:

$$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$1

where $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$2. Persistently large errors increase $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$3, relaxing the regularization and accelerating adaptation to new regimes; small errors contract $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$4, tightening update bounds and recovering stability.

Computational Considerations

The algorithm leverages K-FAC approximations of the Fisher matrix (holding two Kronecker factors per layer) and periodic updates (e.g., on large errors only). The replay buffer is small ($$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$5), so memory and computation scale modestly beyond standard gradient methods.

4. NatSR for Prioritized Replay in RL Post-Training

A distinct but related application of NatSR appears in RL fine-tuning for LLMs (Fatemi, 6 Jan 2026). Here, NatSR denotes a problem-level prioritized replay scheme for group-regularized policy optimization (GRPO) based RL post-training.

Priority Score Definition

For each problem $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$6, an empirical success rate $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$7 is maintained ($$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$8 binary reward). The per-response advantage is $$\nabla_t = \partial \log p(y_t\,|\,\theta_t)/\partial \theta_t$$9. Informativeness is quantified by mean squared advantage, leading to the priority score:

$S_t$0

Only problems with intermediate $S_t$1's contribute non-trivial gradients in GRPO, so prioritizing by $S_t$2 targets maximal learning signal.

Scheduling and Buffer Management

NatSR maintains a max-heap $S_t$3 of "learnable" problems keyed by $S_t$4, and solved/unsolved pools $S_t$5 and $S_t$6. Each step, the $S_t$7 highest-priority problems are selected, updated with fresh rollouts and gradients, then moved between $S_t$8, $S_t$9, and $\theta_t$0 by empirical criteria. Periodic retesting mitigates forgetting and starvation. Priority statistics are smoothed by an EMA to suppress sampling noise.

Integration and Hyperparameters

NatSR is readily composable with the GRPO loop, requiring only upstream modification to task sampling. Because the focus on high-$\theta_t$1 problems increases expected gradient magnitude, a reduced learning rate is usually required. The framework requires negligible additional memory per problem and heap operations are $\theta_t$2.

5. Empirical Evaluation

Time Series Forecasting

NatSR (Urettini et al., 19 Jan 2026) was evaluated on seven multivariate, non-stationary datasets (ETTm$\theta_t$3, ETTm$\theta_t$4, ETTh$\theta_t$5, ETTh$\theta_t$6, ECL, Traffic, WTH). Using Mean Absolute Scaled Error (MASE) as the metric, NatSR (with $\theta_t$7, SGD) attained the best MASE on five datasets and the second-best on two, outperforming Online Gradient Descent (OGD), Experience Replay (ER), DER++, FSNET, and OneNet. Ablation showed that omitting replay or the dynamic scale heuristic harms accuracy by up to 13% and 6%, respectively; omitting both degrades performance by up to 19%. Training time remains only a few minutes on a single GPU.

RL Post-Training

For RL post-training (Fatemi, 6 Jan 2026), NatSR was applied to GRPO fine-tuning of Qwen2.5-7B on the GURU math dataset. Compared to uniform sampling, prioritized replay via NatSR consistently yielded higher pass@1 and pass@4 metrics (early-stage gains of +3–5% absolute pass@1), with the heap focusing on problems providing the strongest learning signal. Empirical results demonstrate rapid convergence and robust task coverage. The heap and solved/unsolved pools remain lightweight, and the prioritization is adaptive and non-parametric.

6. Connections and Implications

NatSR unifies econometric score-driven filtering and second-order natural gradient methods in a single framework for online adaptation. The use of Student's t likelihood aligns robust optimization and heavy-tailed error modeling. The replay buffer and dynamic volatility scale recover long-term memory and rapid regime adaptation without task labels or explicit regime-change detection. In RL, NatSR exploits advantage variance to maximize expected learning signal rather than following pre-determined curricula.

A plausible implication is that this general score-driven replay principle may be extensible to other data modalities and continual learning settings requiring both robustness and sample efficiency. The modularity of the prioritized replay mechanisms (e.g., heap-based scheduling, task pools, adaptive smoothing) admits straightforward adaptation to large-scale or high-throughput environments.

7. Summary Table of NatSR Instantiations

Context	Key Mechanism	Reference
Time Series OCL	Student-t natural gradient + buffer + dynamic scale	(Urettini et al., 19 Jan 2026)
RL Post-training (GRPO)	Advantage-variance prioritized replay, heap/pools, EMA smoothing	(Fatemi, 6 Jan 2026)

NatSR thus denotes both a robust, theoretically justified online learning algorithm for forecasting and a simple, non-parametric prioritized replay schedule for RL fine-tuning, each leveraging the central principle of score-driven selection or update.