1 Introduction↩︎

Continual learning—the ability to acquire new skills without erasing old ones—remains a defining challenge for deployed neural networks. A model trained on a stream of tasks typically suffers catastrophic forgetting [1], [2]: each round of gradient updates overwrites the parameters that encoded earlier knowledge. The difficulty is structural. A conventional network spreads each task’s knowledge across its entire parameter space, so there is no protected substrate for old skills and no reserved capacity for new ones. When the distribution shifts, the only thing the optimiser can do is overwrite.

Existing remedies each address one facet of this problem. Regularisation methods [3], [4] penalise changes to important weights but eventually saturate as constraints accumulate. Replay methods [5], [6] rehearse stored examples but require a growing memory of raw data. Architecture methods [7], [8] add or freeze parameters but either grow without bound or permanently lock capacity. Recent parameter-efficient approaches based on Low-Rank Adaptation (LoRA) [9]—such as O-LoRA [10], PEARL [11], and PLAN [12]—allocate low-rank subspaces per task, but the allocation rule is hand-designed and, crucially, memoryless: it cannot recognise when a past task recurs, nor reuse what previously worked.

A biological lens. The human brain manages a fixed neural substrate across a lifetime of learning, and it does so through four mechanisms that current methods capture only in isolation. Selective activation: only a small fraction of neurons fire for any given task [13], leaving the rest available. Synaptic consolidation: during rest, labile memories are compressed into stable cortical traces, pruning redundant connections while preserving essential ones [14]—strikingly, neurons proliferate in infancy and then prune during maturation, yet knowledge grows, suggesting that fewer, well-organised parameters can hold more. Context-dependent reactivation: a familiar situation reactivates dormant pathways, enabling rapid recovery rather than relearning [15]. Background-knowledge transfer: related new material is acquired faster because the brain retrieves and builds on existing schemas [16].

Our approach. We introduce Neural Subspace Reallocation (NSR), which unifies these four mechanisms into a single recurring cycle over a frozen base model whose only trainable elements are LoRA modules organised into groups:

1. Compress (consolidation): after a task, SVD-based rank reduction distils each LoRA into its dominant directions, freeing capacity.

2. Reserve (selective dormancy): compressed LoRAs, their allocation mask, and task embeddings are stored in a TaskKnowledgeBank.

3. Recall (reactivation & transfer): a new or returning task retrieves similar past tasks by cosine similarity and warm-starts from their LoRAs.

4. Reallocate (subspace selection): the active subspace is set from the retrieved mask (with distillation shielding prior tasks). We treat the allocation rule itself as a design variable and, in a controlled study, ask which rule is actually needed.

Why memory matters. The central claim in NSR is that continual-learning performance under fixed capacity is driven by the memory mechanism—compressing past LoRAs and retrieving them by similarity—rather than by a sophisticated learned allocation policy. We support this both theoretically and empirically. Theoretically, we prove (Theorem 1) that in cyclic environments any memoryless policy incurs cumulative regret \(\Omega(T(M{-}1)\Delta_{\text{switch}})\) relative to a history-aware policy backed by the Bank: a memoryless policy cannot tell that a task has returned, so it re-explores from scratch, whereas a Bank-backed policy recognises it and restores what worked. Empirically, we hold the Bank fixed and vary only the allocation rule; a simple similarity-retrieval rule matches or beats a learned RL controller. The history-awareness that the theory requires is therefore supplied by retrieval, not by reinforcement learning.

Findings. On Split-CIFAR-100, NSR attains the lowest forgetting among learning-based policies (BWT \(=-0.068\)). A TaskKnowledgeBank ablation isolates the mechanism: removing the Bank slows cyclic recovery \(10\times\), exactly as the theory predicts. On the heterogeneous 5-Datasets benchmark—five distinct visual domains learned in sequence—NSR achieves the highest accuracy and the least forgetting (about \(9\times\) closer to zero BWT than the memoryless heuristics), showing the approach is not tied to one dataset. Most importantly, a controlled allocation study (Section 6.4) shows that with the Bank in place a parameter-free similarity rule recovers recurring tasks in \(0\) steps and reaches accuracy equal to or above a learned RL controller—identifying the memory mechanism, not the policy, as the source of performance. We are also candid about boundaries: NSR’s advantage narrows when an already-powerful frozen backbone makes every task easy.

Contributions.

• Reframing. We cast continual learning as retrieval-based subspace memory management: LoRA modules become compressible, retrievable memory units on a frozen backbone, not disposable per-task adapters (Section 5).

• Mechanism. The TaskKnowledgeBank: SVD-compressed LoRA memory with similarity retrieval, enabling exact restoration for recurring tasks and similarity-weighted transfer for related tasks. The allocation step is controller-agnostic—it accepts heuristic, similarity-based, gradient-based, or learned (RL) rules as interchangeable plug-ins (Section 5).

• Theory. A regret bound (Theorem 1, Corollaries 1–3) proving that any memoryless allocation is structurally suboptimal in cyclic environments, with the gap growing linearly in recurrence and the Bank identified as the dominant factor (Section 4).

• What actually matters. A controlled study that fixes the Bank and swaps only the allocation plug-in, showing that a parameter-free similarity rule matches or beats a learned RL controller on every metric. This isolates the source of performance in the memory mechanism and yields a simpler recommended method (no controller training), supported by a \(10\times\) Bank ablation and consistent cross-domain gains on 5-Datasets (Section 6).

2 Motivation↩︎

2.1 The Capacity Utilisation Problem↩︎

A network with \(N\) parameter groups trained jointly has three failure modes: no headroom for new knowledge (parameters must be repurposed), no memory of what worked before (returning tasks are re-learned from scratch), and no leveraging of related prior knowledge. All stem from treating the parameter space as a monolithic resource rather than a managed, queryable memory.

2.2 NSR as Computational Neuroplasticity↩︎

4pt

The key insight is not that allocation must be learned, but that it must be history-aware. A memoryless heuristic cannot remember which groups a recurring task previously used, nor detect a novel-but-related task. In NSR, history-awareness is supplied by retrieval from the TaskKnowledgeBank; a learned controller is an optional plug-in, not a requirement (Section 6.4).

3 Problem Formulation↩︎

Let \(\boldsymbol{\theta}\) be a base model partitioned into \(N\) groups, each with a LoRA module \((A_i, B_i)\). Tasks \(\mathcal{T}_1, \ldots, \mathcal{T}_S\) arrive with distributions \(\mathcal{D}_s\). At each step the learner: (1) computes a task embedding \(\boldsymbol{e}_s\); (2) recalls related past tasks \(\mathcal{R}_s\) from the Bank; (3) seeds LoRAs via similarity-weighted averaging; (4) injects by choosing a mask \(\boldsymbol{m}_s \in \{0,1,2,3\}^N\) with \(|\{i: m_s[i]>0\}| \le k\); (5) trains with \(\mathcal{L}= \mathcal{L}_{\mathrm{CE}} + \lambda\mathcal{L}_{\mathrm{KD}}\); (6) compresses active LoRAs via SVD; (7) reserves them in the Bank.

The objective is \(\max_\pi \sum_s \mathbb{E}[\mathrm{Acc}(f_{\boldsymbol{\theta},\pi(s)}, \mathcal{D}_s)]\) subject to the capacity constraint. What distinguishes NSR from memoryless heuristics is that the allocation \(\pi\) is history-aware: it conditions on a history/retrieval state \(\boldsymbol{s}_t = (\boldsymbol{g}_t, \boldsymbol{e}_t, \Delta\boldsymbol{e}_t, \boldsymbol{h}_t, \boldsymbol{\sigma}_t)\), where \(\boldsymbol{h}_t\) is an LSTM history encoding and \(\boldsymbol{\sigma}_t\) the top-\(K\) Bank-retrieval similarity. The recommended allocation reads \(\boldsymbol{\sigma}_t\) directly (similarity rule); a learned controller that consumes the full state is an optional alternative (Section 6.4).

4 Theoretical Analysis↩︎

5 Method↩︎

Architecture. The base model (ImageNet-pretrained ResNet-18) is fully frozen; all learning flows through LoRA modules of max rank \(r{=}8\). CNN groups correspond to residual stages (layer1–4) plus the classifier.

Allocation rule. Given the retrieved neighbours, NSR sets the active-subspace mask. Our recommended rule is similarity-based: copy the allocation mask of the most similar stored task (exact restore when a task returns). We also implement and compare a learned controller—a distribution embedder \(\boldsymbol{e}_t\), an LSTM history encoder \(\boldsymbol{h}_t\), and an actor–critic with cross-group attention trained by PPO—and simple baselines (random, round-robin, gradient). Section 6.4 shows the similarity rule matches or beats the learned controller, so the default NSR trains no controller. The capacity budget projects the chosen mask to at most \(k\) active groups.

TaskKnowledgeBank. For each task \(\tau\) it stores the embedding \(\boldsymbol{e}_\tau\), compressed LoRAs, the allocation mask, the classifier head, and soft targets. Two retrieval modes: exact restore (returning tasks) and similarity-weighted average (related tasks).

Training. Per task we minimise \(\mathcal{L}= \mathcal{L}_{\mathrm{CE}} + \lambda_{\mathrm{distill}}\mathcal{L}_{\mathrm{KD}}\) with distillation temperature \(T{=}2\), the soft targets coming from the Bank to protect prior tasks. The learned-controller variant additionally optimises a PPO [17] objective with reward \(R_t = 2\,\mathrm{Acc}_t + 5\,\Delta\mathrm{Acc}_t + \lambda_{\mathrm{ret}}\mathrm{Ret}_t - \lambda_{\mathrm{smooth}}\mathrm{Smooth}_t\); the recommended similarity variant has no such objective.

SVD compression. Each active LoRA’s \(\Delta W = BA\) is truncated to rank \(\lceil\rho r\rceil\) via SVD, preserving dominant singular directions—the analogue of synaptic pruning.

6 Experiments↩︎

Setup. ImageNet-pretrained ResNet-18 (frozen), Split-CIFAR-100 (5 tasks \(\times\) 20 classes). LoRA rank 8, capacity \(k/N{=}0.5\), compression \(\rho{=}0.5\), \(\lambda_{\mathrm{distill}}{=}0.1\). Three seeds \(\{42,123,456\}\); we report mean\(\pm\)std. Eight allocation rules: NSR-RL, Gradient, Random, Round-Robin, EWC-Inspired, Full-Active, PEARL [11], PLAN [12]. All share the frozen backbone, Bank, and consolidation, and differ only in allocation. Experiments 1–6 report the learned-controller variant, labelled NSR-RL (variant), for continuity with prior allocation literature; Section 6.4 introduces the recommended parameter-free variant NSR-Sim, which matches or exceeds NSR-RL on every metric, so all NSR-RL rows are upper-bounded by NSR-Sim on recovery and forgetting.

6.1 Experiment 1: Policy Comparison↩︎

Table 2 reports average accuracy (AA) and backward transfer (BWT) after sequential training on all 5 tasks. NSR-RL achieves the lowest forgetting among learning-based policies (BWT \(=-0.068\)), strongly outperforming gradient (\(-0.151\)), EWC (\(-0.157\)), Full-Active (\(-0.198\)), PEARL (\(-0.247\)), and PLAN (\(-0.168\)). The memoryless heuristics that achieve marginally higher AA do so at the cost of \(2\)–\(4\times\) more forgetting. This matches Theorem 1: in purely sequential settings without recurrence, allocation choice has limited effect on AA, but NSR’s consolidation mechanisms protect prior tasks far better.

4pt

6.2 Experiment 2: Cyclic Task Return↩︎

The schedule \(A \to B \to C \to A' \to B' \to C' \to A'' \to B'' \to C''\) tests recovery on recurring tasks. We measure adaptation steps (mini-batches) to reach 97% of original accuracy. Table 3 shows NSR-RL recovers fastest at \(3.33\) steps, dramatically faster than gradient (\(14.72\)), EWC (\(14.83\)), Full-Active (\(14.94\)), and PLAN (\(14.06\))—a \(4.4\times\) improvement over the strongest gradient heuristic, and ahead of all memoryless baselines including round-robin (\(4.06\)). This directly validates Theorem 1: memoryless policies cannot identify returning tasks and must re-explore, while NSR warm-starts from the Bank.

4pt

6.3 Experiment 3: LoRA Bank Ablation↩︎

To isolate the source of NSR’s cyclic advantage (Corollary 3), we compare NSR-RL with and without the Bank, plus PEARL. Table 4 shows a striking result: with the Bank, recovery takes \(1.27\) steps; without it, \(13.33\) steps—a \(10\times\) difference. PEARL, which has no Bank, behaves like NSR-without-Bank (\(14.27\) steps). This confirms that the warm-start parameter restoration, not the allocation rule, is the dominant mechanism.

4pt

6.4 Is the Learned Allocation Necessary?↩︎

The Bank ablation shows the Bank is the dominant mechanism, raising a sharp question that we confront head-on: given the Bank, does a learned allocation policy add anything, or does the memory mechanism do the work? We hold the TaskKnowledgeBank fixed—identical compression and warm-start restoration for every configuration—and vary only how the per-task allocation mask is chosen: a learned RL controller, random, round-robin, gradient-magnitude, and a parameter-free similarity rule that copies the mask of the most similar past task in the Bank.

Table 5 reports the result over three seeds. The finding is unambiguous: the learned RL controller is not the best allocation rule. The similarity rule—which we call NSR-Sim and adopt as the recommended method—recovers recurring tasks in \(0.0\) steps with zero forgetting, simply restoring the most similar stored mask (for exact recurrence, the task’s own), while the RL controller needs \(1.8\) steps and shows \(-0.056\) BWT. On average accuracy the simple rules (NSR-Sim \(0.437\), round-robin \(0.439\)) match or exceed RL (\(0.393\)). RL only clearly beats random allocation.

We take this as the paper’s central, mechanism-isolating result rather than a negative one. Because NSR’s allocation step is controller-agnostic, this study is not a failure of one method but a fair comparison within our framework: every rule sees the same Bank, so the comparison cleanly attributes performance to the memory mechanism rather than the controller. It localises NSR’s effectiveness in SVD compression plus similarity retrieval, and shows that an expensive learned policy is unnecessary once that memory is in place. The recommended NSR therefore uses similarity-based reallocation with no controller training—simpler, faster, and reproducible—while the framework still admits a learned controller as a drop-in for settings where it may help (e.g.only partial task similarity).

3pt

6.5 Experiment 4: Capacity Budget Ablation↩︎

We sweep \(k/N \in \{0.2,0.4,0.6,0.8,1.0\}\) (Table 6). NSR-RL is most robust at tight budgets, achieving its best AA (\(0.435\)) at \(k/N{=}0.2\) and degrading gracefully. PEARL collapses outside \(k/N{=}0.2\) (dropping to \(0.11\)–\(0.15\)). This shows NSR’s allocation is especially valuable when capacity is scarce—the regime where intelligent reallocation matters most.

4pt

6.6 Experiment 5: Increasing Gap↩︎

We vary the number of intervening tasks before a task returns (Table 7). At small gaps (1, 3), all policies fail to recover within the measurement window (15 steps). But at gaps 5 and 7, only NSR-RL recovers (\(10.3\) steps), while all memoryless baselines remain at the ceiling (\(15.0\)). This is qualitative evidence for Corollary 1: as the gap grows, the memory-based advantage emerges—memoryless policies forget, while NSR retrieves.

4pt

6.7 Experiment 6: Distillation Strength↩︎

Sweeping \(\lambda_{\mathrm{distill}}\) (Table 8) reveals a clear plasticity–stability trade-off. At \(\lambda{=}0\), forgetting is minimal but AA is moderate; AA peaks at \(\lambda{=}0.1\) (\(0.459\)), then declines as excessive distillation impairs new-task learning. This identifies \(\lambda{=}0.1\) as the sweet spot and quantifies the trade-off.

4pt

6.8 Experiment 7: When a Learned Controller Struggles↩︎

To further motivate our similarity-based default over a learned controller, we construct a setting with explicit group interactions: groups 0,1 boost accuracy when co-active (synergy) and groups 2,3 degrade when co-active (interference). A gradient heuristic, which deterministically selects high-gradient groups, happens to co-activate the synergy pair (rate \(1.00\)) and reaches accuracy \(0.462\). The RL controller, which must discover this combinatorial structure through PPO exploration, co-activates the synergy pair only \(8.7\%\) of the time and reaches \(0.435\).

This illustrates a general weakness of learned allocation: in combinatorial action spaces (\(\binom{6}{3}\) allocations here) with a modest accuracy signal, PPO does not reliably find the synergistic configuration within a practical budget. It reinforces our main message—learned control is fragile and unnecessary here—and points to the memory-and-retrieval mechanism, not policy learning, as the reliable component. Settings that genuinely require discovering group synergies would need dedicated exploration mechanisms beyond the scope of this framework.

6.9 Experiment 8: Cross-Dataset Generalization↩︎

A common reviewer concern for continual learning papers is that results may not transfer beyond a single benchmark. To address this directly, we evaluate NSR on the 5-Datasets benchmark—five distinct 10-class datasets learned sequentially in the order CIFAR-10, MNIST, SVHN, FashionMNIST, then KMNIST. These cover natural images, handwritten digits, street-view digits, fashion items, and Japanese characters. Unlike CIFAR-100 splits where all tasks share the same underlying distribution, here each task is a genuinely different domain, making both forgetting and cross-task interference far more severe. All images are converted to \(3 \times 32 \times 32\) to share a single ResNet-18 backbone with a 50-class shared head.

Table 9 shows that NSR-RL achieves \(\mathrm{AA}=0.665\) with low forgetting (\(\mathrm{BWT}=-0.024\)), outperforming all baselines: \(+2\%p\) over PEARL (\(0.646\)), \(+8\%p\) over the gradient heuristic (\(0.581\)), and \(+9\%p\) over EWC (\(0.572\)). The forgetting gap is the clearest signal: NSR’s \(-0.024\) BWT is about \(9\times\) closer to zero than the gradient and EWC heuristics (\(-0.218\), \(-0.243\)), which suffer severe forgetting across heterogeneous domains, and edges out the strongest baseline PEARL (\(-0.033\)). NSR and PEARL—the two memory-based methods—clearly separate from the memoryless heuristics here.

4pt

We note that NSR’s accuracy shows higher seed variance on this benchmark (\(\sigma{=}0.036\)) than on Split-CIFAR-100, driven by one seed with a harder domain ordering; the ranking (NSR and PEARL ahead of the memoryless heuristics) is nonetheless stable across all three seeds.

This result strengthens the paper’s central claim: NSR’s advantage is not specific to a particular dataset structure but holds across heterogeneous domain shifts—precisely the setting where catastrophic forgetting is hardest to control.

6.10 Experiment 9: Memory Footprint under Bank Pruning↩︎

The Bank stores one compressed LoRA set per task, so its footprint grows linearly with the number of tasks—a natural concern for long horizons. We analyse the memory–performance trade-off directly, capping the Bank at \(K\) tasks with a retention policy (recency: keep the most recent \(K\); utility: keep the highest-validation-accuracy \(K\)).

Memory is small and separable. We distinguish two components, measured directly. NSR’s primary mechanism is compressed-LoRA restoration, whose Bank parameter memory—SVD-compressed LoRA states at \(\rho{=}0.5\), plus the task embedding, allocation mask, and classifier head—is \(0.29\) MB per task for our ResNet-18 backbone, scaling exactly linearly (\(2.35\) MB at \(8\) tasks; Table 10). The optional distillation exemplars (stored inputs and soft targets) are far larger—about \(6.2\) MB per task, dominated by raw images—so total memory is \(6.46\) MB per task (\(51.7\) MB at \(8\) tasks). This separation matters: NSR’s core restoration mechanism needs only the compact parameter memory, and the exemplar store is an optional add-on for distillation that can be reduced (e.g.fewer exemplars) or dropped independently. A top-\(K\) retention cap bounds both components linearly in \(K\), since they share the same task key.

Recovery degrades gracefully. We measure recovery directly under each budget (Table 10). Retained tasks recover quickly regardless of how aggressively we prune: \(3\)–\(5\) adaptation steps across all budgets and both retention policies, essentially flat as \(K\) shrinks from \(8\) to \(2\). Evicted tasks, by contrast, fall back to cold-start and do not reach the \(97\%\) threshold within the \(15\)-step measurement window, exactly as expected—eviction removes the warm-start, leaving ordinary from-scratch learning. Critically, an evicted task is never worse than under a memoryless method, since eviction only removes a warm-start a memoryless baseline never had. We do not protect returning tasks during pruning; retention is decided solely by the stated policy (recency or utility), so these numbers are not favourably biased. The practical takeaway: a fixed cap converts linear growth into a bounded footprint while keeping fast recovery for every retained task; the only cost is that evicted tasks revert to baseline cold-start, which one mitigates by choosing \(K\) and the retention policy to match the expected recurrence pattern.

3pt

6.11 Qualitative: Allocation Evolution↩︎

Figure 2 visualises the learned-controller (NSR-RL) allocation mask across the cyclic schedule. Distinct per-task patterns emerge, and returning tasks partially reactivate prior patterns—a qualitative signature of the recall mechanism.

7 Related Work↩︎

Continual learning. Regularisation (EWC [3], SI [4]), replay (GEM [5]), and architecture methods (Progressive Nets [7], PackNet [8]) address forgetting differently. NSR is architecture-based but uniquely manages a fixed budget as a queryable memory of compressed subspaces, combining distillation and retrieval.

LoRA for CL. O-LoRA [10], InfLoRA [18], PEARL [11], PLAN [12], and SD-LoRA [19] adapt LoRA for continual learning, typically as task-specific, orthogonal, or adaptive-rank adapters. NSR differs by treating each LoRA as a retrievable, SVD-compressed memory trace: rather than discarding or merely freezing a task’s adapter, it stores the adapter, its mask, head, and embedding, and recalls them by similarity for exact or weighted restoration. This memory view, not a particular allocation rule, is the source of our gains.

Retrieval-augmented learning. HiDe-Prompt [20] and LoRA Hub [21] use retrieval/composition, but operate on prompts or pre-trained experts with inference-time optimisation; NSR retrieves continually-learned LoRAs via \(O(1)\) cosine similarity and restores them directly, with no inference-time search.

8 Discussion and Limitations↩︎

NSR helps most in (1) cyclic environments (Theorem 1, Exp 2,3), (2) forgetting-sensitive sequential settings (Exp 1), and (3) heterogeneous cross-domain sequences (Exp 8). Its advantage diminishes in purely sequential settings without recurrence, where there is no stored subspace to recall.

Backbone strength and task difficulty. NSR’s benefit is largest when the base representation is limited or the task sequence is hard, so that intelligent reallocation matters. In preliminary experiments with a much stronger pretrained backbone (ViT-B/16), per-task accuracy is already very high (\(0.78\)–\(0.84\) versus \(\sim\) \(0.40\) for ResNet-18 features), and recurring tasks are recovered quickly by all policies (warm-start accuracy \(\approx 0.80\) regardless of allocation strategy). In this regime simple heuristics become competitive and NSR’s margin narrows, because the gap that NSR exploits—the cost of re-learning a forgotten task—is small when the backbone alone nearly solves each task. We note that the Bank’s warm-start effect remains observable even here (recovery \(4.8\) vs \(13.3\) steps with vs without the Bank), but the overall advantage is muted. This delineates NSR’s operating regime: it is most valuable under constrained representational capacity or hard, forgetting-prone task sequences, and least necessary when a powerful frozen backbone already generalizes across tasks. A full cross-backbone study is left to future work.

What the allocation policy contributes. Our controlled study (Section 6.4) shows that, with the TaskKnowledgeBank in place, a parameter-free similarity rule matches or beats a learned RL controller on accuracy, forgetting, and recovery. We therefore do not claim a learned policy is necessary; the recommended NSR uses similarity-based reallocation and trains no RL agent. This is a deliberate, evidence-driven simplification: the theory (Theorem 1) requires history-awareness, and retrieval from the Bank already supplies it. Casting NSR as retrieval-based subspace memory management—rather than “RL selects LoRA groups”—matches what the experiments actually support and avoids overclaiming. Whether a learned controller helps in settings with only partial task similarity (no exact Bank match) is an open question our current evidence does not resolve in its favour.

Memory growth. The Bank stores one compressed LoRA set per task, so its footprint grows linearly with the number of tasks. Experiment 6.10 shows this is manageable: the compact Bank parameter memory (NSR’s primary mechanism) is only \(\sim\) \(0.29\) MB per task, and a top-\(K\) retention policy bounds both parameter and total memory while preserving near-instant recovery for retained tasks; evicted tasks degrade gracefully to cold-start, never worse than a memoryless baseline. If distillation exemplars are used they dominate total memory, so they too are bounded by the same cap. Merging similar tasks (rather than evicting) is a promising refinement. A further limitation is that we evaluate only vision tasks.

9 Conclusion↩︎

NSR reframes continual learning as retrieval-based memory management over parameter subspaces: it compresses each task’s LoRA via SVD, reserves it in a TaskKnowledgeBank, and recalls it by similarity to reallocate the active subspace. Theory and experiments agree: memoryless allocation is structurally suboptimal in cyclic environments, a Bank ablation confirms a \(10\times\) recovery effect, and the framework generalises to the heterogeneous 5-Datasets benchmark with the highest accuracy and least forgetting among all baselines. A controlled study shows that the memory mechanism—not a learned controller—is the source of these gains, yielding a simple, reproducible method, and a memory-budget analysis shows the compressed Bank stays small (\(0.29\) MB/task) and boundable by a retention cap. NSR offers a theoretically-motivated, controller-agnostic framework for continual learning under fixed capacity.

10 Full Proof of Theorem 1↩︎

Step 1. Decompose \(V(\pi)=\sum_{c=1}^M\sum_{j=1}^T V_j^c(\pi)\).

Step 2 (memoryless on returning tasks). For \(c\ge2\), by Assumption 3 \(\pi_{\mathrm{mem}}\) cannot identify \(\tau_j\) as returning, so it either selects a suboptimal mask (requiring \(\Omega(C_{\mathrm{cold}})\) exploration) or, with probability \(p_{\mathrm{lucky}}=O(\binom{N}{k}^{-1})\), the right mask but with overwritten parameters (still requiring cold-start). Thus \(\mathbb{E}[\text{steps}] \ge (1-p_{\mathrm{lucky}})C_{\mathrm{cold}}(\varepsilon)\).

Step 3 (history-aware). By Assumption 4, \(\boldsymbol{h}_t\) identifies \(\tau_j\); the Bank restores \((A_i^{\tau_j},B_i^{\tau_j})\); by Assumption 2 with \(\delta{=}0\), \(\mathbb{E}[\text{steps}]\le C_{\mathrm{warm}}(\varepsilon,0)=O(1)\).

Step 4 (per-return gap). \(V_j^c(\pi_{\mathrm{hist}})-V_j^c(\pi_{\mathrm{mem}}) \ge \Delta_{\mathrm{switch}} - p_{\mathrm{lucky}}C_{\mathrm{cold}}L_{\mathrm{relearn}}\). For large \(N\), \(p_{\mathrm{lucky}}\to0\).

Step 5 (sum). Cycle 1 contributes \(\ge0\); cycles \(2,\ldots,M\) contribute \(T(M-1)\) returning instances, yielding \(V(\pi_{\mathrm{hist}})-V(\pi_{\mathrm{mem}}) \ge T(M-1)\Delta_{\mathrm{switch}}\). 0◻

11 Hyperparameters↩︎

References↩︎